]>
Commit | Line | Data |
---|---|---|
2bda0e17 | 1 | ///////////////////////////////////////////////////////////////////////////// |
1e6feb95 | 2 | // Name: wx/msw/window.h |
2bda0e17 KB |
3 | // Purpose: wxWindow class |
4 | // Author: Julian Smart | |
1e6feb95 VZ |
5 | // Modified by: Vadim Zeitlin on 13.05.99: complete refont of message handling, |
6 | // elimination of Default(), ... | |
2bda0e17 KB |
7 | // Created: 01/02/97 |
8 | // RCS-ID: $Id$ | |
371a5b4e | 9 | // Copyright: (c) Julian Smart |
cc2b7472 | 10 | // Licence: wxWindows licence |
2bda0e17 KB |
11 | ///////////////////////////////////////////////////////////////////////////// |
12 | ||
bbcdf8bc JS |
13 | #ifndef _WX_WINDOW_H_ |
14 | #define _WX_WINDOW_H_ | |
2bda0e17 | 15 | |
cc2b7472 VZ |
16 | // --------------------------------------------------------------------------- |
17 | // headers | |
18 | // --------------------------------------------------------------------------- | |
19 | ||
2bda0e17 | 20 | #ifdef __GNUG__ |
cc2b7472 | 21 | #pragma interface "window.h" |
2bda0e17 KB |
22 | #endif |
23 | ||
1e6feb95 VZ |
24 | // [at least] some version of Windows send extra mouse move messages after |
25 | // a mouse click or a key press - to temporarily fix this problem, set the | |
26 | // define below to 1 | |
27 | // | |
28 | // a better solution should be found later... | |
a23fd0e1 VZ |
29 | #define wxUSE_MOUSEEVENT_HACK 0 |
30 | ||
1bffa913 VZ |
31 | #include "wx/hash.h" |
32 | ||
33 | // pseudo-template HWND <-> wxWindow hash table | |
34 | WX_DECLARE_HASH(wxWindow, wxWindowList, wxWinHashTable); | |
35 | ||
36 | extern wxWinHashTable *wxWinHandleHash; | |
37 | ||
cc2b7472 VZ |
38 | // --------------------------------------------------------------------------- |
39 | // constants | |
40 | // --------------------------------------------------------------------------- | |
1e6d9499 | 41 | |
cc2b7472 VZ |
42 | // FIXME does anybody use those? they're unused by wxWindows... |
43 | enum | |
1e6d9499 | 44 | { |
cc2b7472 VZ |
45 | wxKEY_SHIFT = 1, |
46 | wxKEY_CTRL = 2 | |
1e6d9499 JS |
47 | }; |
48 | ||
cc2b7472 VZ |
49 | // --------------------------------------------------------------------------- |
50 | // wxWindow declaration for MSW | |
51 | // --------------------------------------------------------------------------- | |
b782f2e0 | 52 | |
1e6feb95 | 53 | class WXDLLEXPORT wxWindowMSW : public wxWindowBase |
1e6d9499 | 54 | { |
2bda0e17 | 55 | public: |
1e6feb95 VZ |
56 | wxWindowMSW() { Init(); } |
57 | ||
58 | wxWindowMSW(wxWindow *parent, | |
59 | wxWindowID id, | |
60 | const wxPoint& pos = wxDefaultPosition, | |
61 | const wxSize& size = wxDefaultSize, | |
62 | long style = 0, | |
63 | const wxString& name = wxPanelNameStr) | |
bfc6fde4 VZ |
64 | { |
65 | Init(); | |
66 | Create(parent, id, pos, size, style, name); | |
67 | } | |
2bda0e17 | 68 | |
1e6feb95 | 69 | virtual ~wxWindowMSW(); |
2bda0e17 | 70 | |
cc2b7472 VZ |
71 | bool Create(wxWindow *parent, |
72 | wxWindowID id, | |
73 | const wxPoint& pos = wxDefaultPosition, | |
74 | const wxSize& size = wxDefaultSize, | |
75 | long style = 0, | |
76 | const wxString& name = wxPanelNameStr); | |
bfc6fde4 | 77 | |
cc2b7472 | 78 | // implement base class pure virtuals |
42e69d6b VZ |
79 | virtual void SetTitle( const wxString& title); |
80 | virtual wxString GetTitle() const; | |
81 | ||
bfc6fde4 | 82 | virtual void Raise(); |
bfc6fde4 VZ |
83 | virtual void Lower(); |
84 | ||
cc2b7472 VZ |
85 | virtual bool Show( bool show = TRUE ); |
86 | virtual bool Enable( bool enable = TRUE ); | |
bfc6fde4 | 87 | |
cc2b7472 | 88 | virtual void SetFocus(); |
ddf9d04f | 89 | virtual void SetFocusFromKbd(); |
bfc6fde4 | 90 | |
1e6feb95 | 91 | virtual bool Reparent(wxWindowBase *newParent); |
bfc6fde4 | 92 | |
cc2b7472 | 93 | virtual void WarpPointer(int x, int y); |
bfc6fde4 | 94 | |
cc2b7472 VZ |
95 | virtual void Refresh( bool eraseBackground = TRUE, |
96 | const wxRect *rect = (const wxRect *) NULL ); | |
1e6feb95 | 97 | virtual void Update(); |
cc2b7472 | 98 | virtual void Clear(); |
a0e449ff VZ |
99 | virtual void Freeze(); |
100 | virtual void Thaw(); | |
bfc6fde4 | 101 | |
b2d5a7ee | 102 | virtual void SetWindowStyleFlag( long style ); |
cc2b7472 VZ |
103 | virtual bool SetCursor( const wxCursor &cursor ); |
104 | virtual bool SetFont( const wxFont &font ); | |
bfc6fde4 | 105 | |
bfc6fde4 VZ |
106 | virtual int GetCharHeight() const; |
107 | virtual int GetCharWidth() const; | |
cc2b7472 VZ |
108 | virtual void GetTextExtent(const wxString& string, |
109 | int *x, int *y, | |
110 | int *descent = (int *) NULL, | |
111 | int *externalLeading = (int *) NULL, | |
112 | const wxFont *theFont = (const wxFont *) NULL) | |
113 | const; | |
114 | ||
1e6feb95 | 115 | #if wxUSE_MENUS_NATIVE |
a1665b22 | 116 | virtual bool DoPopupMenu( wxMenu *menu, int x, int y ); |
1e6feb95 | 117 | #endif // wxUSE_MENUS_NATIVE |
cc2b7472 VZ |
118 | |
119 | virtual void SetScrollbar( int orient, int pos, int thumbVisible, | |
120 | int range, bool refresh = TRUE ); | |
121 | virtual void SetScrollPos( int orient, int pos, bool refresh = TRUE ); | |
122 | virtual int GetScrollPos( int orient ) const; | |
123 | virtual int GetScrollThumb( int orient ) const; | |
124 | virtual int GetScrollRange( int orient ) const; | |
125 | virtual void ScrollWindow( int dx, int dy, | |
126 | const wxRect* rect = (wxRect *) NULL ); | |
2bda0e17 | 127 | |
9cd6d737 VZ |
128 | virtual bool ScrollLines(int lines); |
129 | virtual bool ScrollPages(int pages); | |
b9b3393e | 130 | |
47d67540 | 131 | #if wxUSE_DRAG_AND_DROP |
cc2b7472 VZ |
132 | virtual void SetDropTarget( wxDropTarget *dropTarget ); |
133 | #endif // wxUSE_DRAG_AND_DROP | |
9f3362c4 | 134 | |
bfc6fde4 VZ |
135 | // Accept files for dragging |
136 | virtual void DragAcceptFiles(bool accept); | |
2bda0e17 | 137 | |
2bda0e17 | 138 | #if WXWIN_COMPATIBILITY |
bfc6fde4 VZ |
139 | // Set/get scroll attributes |
140 | virtual void SetScrollRange(int orient, int range, bool refresh = TRUE); | |
141 | virtual void SetScrollPage(int orient, int page, bool refresh = TRUE); | |
142 | virtual int OldGetScrollRange(int orient) const; | |
143 | virtual int GetScrollPage(int orient) const; | |
42e69d6b VZ |
144 | |
145 | // event handlers | |
146 | // Handle a control command | |
147 | virtual void OnCommand(wxWindow& win, wxCommandEvent& event); | |
148 | ||
149 | // Override to define new behaviour for default action (e.g. double | |
150 | // clicking on a listbox) | |
151 | virtual void OnDefaultAction(wxControl * WXUNUSED(initiatingItem)) { } | |
cc2b7472 | 152 | #endif // WXWIN_COMPATIBILITY |
bfc6fde4 | 153 | |
34636400 | 154 | #if wxUSE_CARET && WXWIN_COMPATIBILITY |
789295bf VZ |
155 | // caret manipulation (old MSW only functions, see wxCaret class for the |
156 | // new API) | |
157 | void CreateCaret(int w, int h); | |
158 | void CreateCaret(const wxBitmap *bitmap); | |
159 | void DestroyCaret(); | |
160 | void ShowCaret(bool show); | |
161 | void SetCaretPos(int x, int y); | |
162 | void GetCaretPos(int *x, int *y) const; | |
163 | #endif // wxUSE_CARET | |
bfc6fde4 | 164 | |
1e6feb95 | 165 | #ifndef __WXUNIVERSAL__ |
cc2b7472 VZ |
166 | // Native resource loading (implemented in src/msw/nativdlg.cpp) |
167 | // FIXME: should they really be all virtual? | |
bfc6fde4 VZ |
168 | virtual bool LoadNativeDialog(wxWindow* parent, wxWindowID& id); |
169 | virtual bool LoadNativeDialog(wxWindow* parent, const wxString& name); | |
42e69d6b VZ |
170 | wxWindow* GetWindowChild1(wxWindowID id); |
171 | wxWindow* GetWindowChild(wxWindowID id); | |
1e6feb95 | 172 | #endif // __WXUNIVERSAL__ |
2bda0e17 | 173 | |
cc2b7472 VZ |
174 | // implementation from now on |
175 | // -------------------------- | |
2bda0e17 | 176 | |
cc2b7472 VZ |
177 | // simple accessors |
178 | // ---------------- | |
2bda0e17 | 179 | |
d7c24517 VZ |
180 | WXHWND GetHWND() const { return m_hWnd; } |
181 | void SetHWND(WXHWND hWnd) { m_hWnd = hWnd; } | |
182 | virtual WXWidget GetHandle() const { return GetHWND(); } | |
2bda0e17 | 183 | |
cc2b7472 VZ |
184 | bool GetUseCtl3D() const { return m_useCtl3D; } |
185 | bool GetTransparentBackground() const { return m_backgroundTransparent; } | |
186 | void SetTransparent(bool t = TRUE) { m_backgroundTransparent = t; } | |
2bda0e17 | 187 | |
cc2b7472 VZ |
188 | // event handlers |
189 | // -------------- | |
00c4e897 | 190 | |
bfc6fde4 | 191 | void OnEraseBackground(wxEraseEvent& event); |
bfc6fde4 | 192 | void OnIdle(wxIdleEvent& event); |
63da7df7 | 193 | void OnPaint(wxPaintEvent& event); |
2bda0e17 | 194 | |
2bda0e17 | 195 | public: |
bfc6fde4 VZ |
196 | // For implementation purposes - sometimes decorations make the client area |
197 | // smaller | |
198 | virtual wxPoint GetClientAreaOrigin() const; | |
199 | ||
bfc6fde4 VZ |
200 | // Windows subclassing |
201 | void SubclassWin(WXHWND hWnd); | |
202 | void UnsubclassWin(); | |
bfc6fde4 | 203 | |
a23fd0e1 VZ |
204 | WXFARPROC MSWGetOldWndProc() const { return m_oldWndProc; } |
205 | void MSWSetOldWndProc(WXFARPROC proc) { m_oldWndProc = proc; } | |
bfc6fde4 | 206 | |
5a403e3f VZ |
207 | // return TRUE if the window is of a standard (i.e. not wxWindows') class |
208 | // | |
209 | // to understand why does it work, look at SubclassWin() code and comments | |
210 | bool IsOfStandardClass() const { return m_oldWndProc != NULL; } | |
211 | ||
197dd9af | 212 | wxWindow *FindItem(long id) const; |
42e69d6b | 213 | wxWindow *FindItemByHWND(WXHWND hWnd, bool controlOnly = FALSE) const; |
bfc6fde4 | 214 | |
bfc6fde4 VZ |
215 | // MSW only: TRUE if this control is part of the main control |
216 | virtual bool ContainsHWND(WXHWND WXUNUSED(hWnd)) const { return FALSE; }; | |
217 | ||
b2d5a7ee VZ |
218 | // translate wxWindows style flags for this control into the Windows style |
219 | // and optional extended style for the corresponding native control | |
220 | // | |
221 | // this is the function that should be overridden in the derived classes, | |
222 | // but you will mostly use MSWGetCreateWindowFlags() below | |
fe3d9123 | 223 | virtual WXDWORD MSWGetStyle(long flags, WXDWORD *exstyle = NULL) const ; |
b2d5a7ee VZ |
224 | |
225 | // get the MSW window flags corresponding to wxWindows ones | |
226 | // | |
227 | // the functions returns the flags (WS_XXX) directly and puts the ext | |
228 | // (WS_EX_XXX) flags into the provided pointer if not NULL | |
229 | WXDWORD MSWGetCreateWindowFlags(WXDWORD *exflags = NULL) const | |
230 | { return MSWGetStyle(GetWindowStyle(), exflags); } | |
231 | ||
b225f659 VZ |
232 | // translate wxWindows coords into Windows ones suitable to be passed to |
233 | // ::CreateWindow() | |
234 | // | |
235 | // returns TRUE if non default coords are returned, FALSE otherwise | |
236 | bool MSWGetCreateWindowCoords(const wxPoint& pos, | |
237 | const wxSize& size, | |
238 | int& x, int& y, | |
239 | int& w, int& h) const; | |
240 | ||
9dfef5ac VZ |
241 | // get the HWND to be used as parent of this window with CreateWindow() |
242 | virtual WXHWND MSWGetParent() const; | |
243 | ||
b225f659 VZ |
244 | // creates the window of specified Windows class with given style, extended |
245 | // style, title and geometry (default values | |
246 | // | |
247 | // returns TRUE if the window has been created, FALSE if creation failed | |
248 | bool MSWCreate(const wxChar *wclass, | |
249 | const wxChar *title = NULL, | |
250 | const wxPoint& pos = wxDefaultPosition, | |
251 | const wxSize& size = wxDefaultSize, | |
252 | WXDWORD style = 0, | |
a23fd0e1 | 253 | WXDWORD exendedStyle = 0); |
b225f659 | 254 | |
42e69d6b | 255 | virtual bool MSWCommand(WXUINT param, WXWORD id); |
bfc6fde4 | 256 | |
42e69d6b VZ |
257 | #if WXWIN_COMPATIBILITY |
258 | wxObject *GetChild(int number) const; | |
259 | virtual void MSWDeviceToLogical(float *x, float *y) const; | |
260 | #endif // WXWIN_COMPATIBILITY | |
bfc6fde4 | 261 | |
1e6feb95 | 262 | #ifndef __WXUNIVERSAL__ |
bfc6fde4 VZ |
263 | // Create an appropriate wxWindow from a HWND |
264 | virtual wxWindow* CreateWindowFromHWND(wxWindow* parent, WXHWND hWnd); | |
265 | ||
266 | // Make sure the window style reflects the HWND style (roughly) | |
267 | virtual void AdoptAttributesFromHWND(); | |
1e6feb95 | 268 | #endif // __WXUNIVERSAL__ |
bfc6fde4 VZ |
269 | |
270 | // Setup background and foreground colours correctly | |
271 | virtual void SetupColours(); | |
272 | ||
42e69d6b VZ |
273 | // ------------------------------------------------------------------------ |
274 | // helpers for message handlers: these perform the same function as the | |
275 | // message crackers from <windowsx.h> - they unpack WPARAM and LPARAM into | |
276 | // the correct parameters | |
277 | // ------------------------------------------------------------------------ | |
278 | ||
279 | void UnpackCommand(WXWPARAM wParam, WXLPARAM lParam, | |
280 | WXWORD *id, WXHWND *hwnd, WXWORD *cmd); | |
281 | void UnpackActivate(WXWPARAM wParam, WXLPARAM lParam, | |
282 | WXWORD *state, WXWORD *minimized, WXHWND *hwnd); | |
283 | void UnpackScroll(WXWPARAM wParam, WXLPARAM lParam, | |
284 | WXWORD *code, WXWORD *pos, WXHWND *hwnd); | |
285 | void UnpackCtlColor(WXWPARAM wParam, WXLPARAM lParam, | |
286 | WXWORD *nCtlColor, WXHDC *hdc, WXHWND *hwnd); | |
287 | void UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam, | |
288 | WXWORD *item, WXWORD *flags, WXHMENU *hmenu); | |
289 | ||
a23fd0e1 | 290 | // ------------------------------------------------------------------------ |
3cfcd50b | 291 | // internal handlers for MSW messages: all handlers return a boolean value: |
a23fd0e1 VZ |
292 | // TRUE means that the handler processed the event and FALSE that it didn't |
293 | // ------------------------------------------------------------------------ | |
bfc6fde4 | 294 | |
42e69d6b VZ |
295 | // there are several cases where we have virtual functions for Windows |
296 | // message processing: this is because these messages often require to be | |
297 | // processed in a different manner in the derived classes. For all other | |
298 | // messages, however, we do *not* have corresponding MSWOnXXX() function | |
299 | // and if the derived class wants to process them, it should override | |
300 | // MSWWindowProc() directly. | |
a23fd0e1 | 301 | |
42e69d6b | 302 | // scroll event (both horizontal and vertical) |
a23fd0e1 VZ |
303 | virtual bool MSWOnScroll(int orientation, WXWORD nSBCode, |
304 | WXWORD pos, WXHWND control); | |
305 | ||
42e69d6b | 306 | // child control notifications |
a23fd0e1 VZ |
307 | #ifdef __WIN95__ |
308 | virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result); | |
309 | #endif // __WIN95__ | |
310 | ||
42e69d6b VZ |
311 | // owner-drawn controls need to process these messages |
312 | virtual bool MSWOnDrawItem(int id, WXDRAWITEMSTRUCT *item); | |
313 | virtual bool MSWOnMeasureItem(int id, WXMEASUREITEMSTRUCT *item); | |
314 | ||
315 | // the rest are not virtual | |
316 | bool HandleCreate(WXLPCREATESTRUCT cs, bool *mayCreate); | |
317 | bool HandleInitDialog(WXHWND hWndFocus); | |
318 | bool HandleDestroy(); | |
319 | ||
320 | bool HandlePaint(); | |
321 | bool HandleEraseBkgnd(WXHDC pDC); | |
322 | ||
323 | bool HandleMinimize(); | |
324 | bool HandleMaximize(); | |
325 | bool HandleSize(int x, int y, WXUINT flag); | |
5706de1c | 326 | bool HandleSizing(wxRect& rect); |
42e69d6b VZ |
327 | bool HandleGetMinMaxInfo(void *mmInfo); |
328 | ||
329 | bool HandleShow(bool show, int status); | |
330 | bool HandleActivate(int flag, bool minimized, WXHWND activate); | |
331 | ||
332 | bool HandleCommand(WXWORD id, WXWORD cmd, WXHWND control); | |
333 | bool HandleSysCommand(WXWPARAM wParam, WXLPARAM lParam); | |
334 | ||
335 | bool HandleCtlColor(WXHBRUSH *hBrush, | |
101f488c VZ |
336 | WXHDC hdc, |
337 | WXHWND hWnd, | |
338 | WXUINT nCtlColor, | |
339 | WXUINT message, | |
340 | WXWPARAM wParam, | |
341 | WXLPARAM lParam); | |
a23fd0e1 | 342 | |
42e69d6b VZ |
343 | bool HandlePaletteChanged(WXHWND hWndPalChange); |
344 | bool HandleQueryNewPalette(); | |
345 | bool HandleSysColorChange(); | |
574c939e | 346 | bool HandleDisplayChange(); |
a5e84126 | 347 | bool HandleCaptureChanged(WXHWND gainedCapture); |
a23fd0e1 | 348 | |
42e69d6b VZ |
349 | bool HandleQueryEndSession(long logOff, bool *mayEnd); |
350 | bool HandleEndSession(bool endSession, long logOff); | |
a23fd0e1 | 351 | |
42e69d6b VZ |
352 | bool HandleSetFocus(WXHWND wnd); |
353 | bool HandleKillFocus(WXHWND wnd); | |
bfc6fde4 | 354 | |
42e69d6b | 355 | bool HandleDropFiles(WXWPARAM wParam); |
bfc6fde4 | 356 | |
42e69d6b VZ |
357 | bool HandleMouseEvent(WXUINT msg, int x, int y, WXUINT flags); |
358 | bool HandleMouseMove(int x, int y, WXUINT flags); | |
d2c52078 | 359 | bool HandleMouseWheel(WXWPARAM wParam, WXLPARAM lParam); |
bfc6fde4 | 360 | |
33ac7e6f KB |
361 | bool HandleChar(WXWPARAM wParam, WXLPARAM lParam, bool isASCII = FALSE); |
362 | bool HandleKeyDown(WXWPARAM wParam, WXLPARAM lParam); | |
363 | bool HandleKeyUp(WXWPARAM wParam, WXLPARAM lParam); | |
b74cce40 VZ |
364 | #ifdef __WIN32__ |
365 | int HandleMenuChar(int chAccel, WXLPARAM lParam); | |
366 | #endif | |
bfc6fde4 | 367 | |
42e69d6b VZ |
368 | bool HandleQueryDragIcon(WXHICON *hIcon); |
369 | ||
370 | bool HandleSetCursor(WXHWND hWnd, short nHitTest, int mouseMsg); | |
bfc6fde4 | 371 | |
bfc6fde4 VZ |
372 | // Window procedure |
373 | virtual long MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam); | |
374 | ||
375 | // Calls an appropriate default window procedure | |
376 | virtual long MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam); | |
a37d422a VZ |
377 | |
378 | // message processing helpers | |
379 | ||
380 | // return FALSE if the message shouldn't be translated/preprocessed but | |
381 | // dispatched normally | |
382 | virtual bool MSWShouldPreProcessMessage(WXMSG* pMsg); | |
383 | ||
384 | // return TRUE if the message was preprocessed and shouldn't be dispatched | |
bfc6fde4 | 385 | virtual bool MSWProcessMessage(WXMSG* pMsg); |
a37d422a VZ |
386 | |
387 | // return TRUE if the message was translated and shouldn't be dispatched | |
bfc6fde4 | 388 | virtual bool MSWTranslateMessage(WXMSG* pMsg); |
a37d422a VZ |
389 | |
390 | // called when the window is about to be destroyed | |
bfc6fde4 VZ |
391 | virtual void MSWDestroyWindow(); |
392 | ||
a23fd0e1 VZ |
393 | // this function should return the brush to paint the window background |
394 | // with or 0 for the default brush | |
395 | virtual WXHBRUSH OnCtlColor(WXHDC hDC, | |
396 | WXHWND hWnd, | |
397 | WXUINT nCtlColor, | |
398 | WXUINT message, | |
399 | WXWPARAM wParam, | |
400 | WXLPARAM lParam); | |
bfc6fde4 | 401 | |
cc2b7472 VZ |
402 | #if WXWIN_COMPATIBILITY |
403 | void SetShowing(bool show) { (void)Show(show); } | |
404 | bool IsUserEnabled() const { return IsEnabled(); } | |
405 | #endif // WXWIN_COMPATIBILITY | |
bfc6fde4 VZ |
406 | |
407 | // Responds to colour changes: passes event on to children. | |
408 | void OnSysColourChanged(wxSysColourChangedEvent& event); | |
409 | ||
a23fd0e1 VZ |
410 | // initialize various fields of wxMouseEvent (common part of MSWOnMouseXXX) |
411 | void InitMouseEvent(wxMouseEvent& event, int x, int y, WXUINT flags); | |
bfc6fde4 | 412 | |
1e6feb95 VZ |
413 | // check if mouse is in the window |
414 | bool IsMouseInWindow() const; | |
415 | ||
2bda0e17 | 416 | protected: |
d7c24517 VZ |
417 | // the window handle |
418 | WXHWND m_hWnd; | |
419 | ||
cc2b7472 | 420 | // the old window proc (we subclass all windows) |
bfc6fde4 | 421 | WXFARPROC m_oldWndProc; |
2bda0e17 | 422 | |
cc2b7472 VZ |
423 | // additional (MSW specific) flags |
424 | bool m_useCtl3D:1; // Using CTL3D for this control | |
cc2b7472 VZ |
425 | bool m_backgroundTransparent:1; |
426 | bool m_mouseInWindow:1; | |
68304caf | 427 | bool m_lastKeydownProcessed:1; |
bfc6fde4 | 428 | |
cc2b7472 | 429 | // the size of one page for scrolling |
bfc6fde4 VZ |
430 | int m_xThumbSize; |
431 | int m_yThumbSize; | |
2bda0e17 | 432 | |
a23fd0e1 VZ |
433 | #if wxUSE_MOUSEEVENT_HACK |
434 | // the coordinates of the last mouse event and the type of it | |
cc2b7472 VZ |
435 | long m_lastMouseX, |
436 | m_lastMouseY; | |
437 | int m_lastMouseEvent; | |
a23fd0e1 | 438 | #endif // wxUSE_MOUSEEVENT_HACK |
bfc6fde4 | 439 | |
bfc6fde4 | 440 | WXHMENU m_hMenu; // Menu, if any |
bfc6fde4 | 441 | |
cc2b7472 | 442 | // implement the base class pure virtuals |
dabc0cd5 VZ |
443 | virtual void DoClientToScreen( int *x, int *y ) const; |
444 | virtual void DoScreenToClient( int *x, int *y ) const; | |
cc2b7472 VZ |
445 | virtual void DoGetPosition( int *x, int *y ) const; |
446 | virtual void DoGetSize( int *width, int *height ) const; | |
447 | virtual void DoGetClientSize( int *width, int *height ) const; | |
448 | virtual void DoSetSize(int x, int y, | |
449 | int width, int height, | |
450 | int sizeFlags = wxSIZE_AUTO); | |
bfc6fde4 | 451 | virtual void DoSetClientSize(int width, int height); |
2bda0e17 | 452 | |
94633ad9 VZ |
453 | virtual void DoCaptureMouse(); |
454 | virtual void DoReleaseMouse(); | |
68304caf | 455 | |
b782f2e0 VZ |
456 | // move the window to the specified location and resize it: this is called |
457 | // from both DoSetSize() and DoSetClientSize() and would usually just call | |
458 | // ::MoveWindow() except for composite controls which will want to arrange | |
459 | // themselves inside the given rectangle | |
460 | virtual void DoMoveWindow(int x, int y, int width, int height); | |
461 | ||
cc2b7472 VZ |
462 | #if wxUSE_TOOLTIPS |
463 | virtual void DoSetToolTip( wxToolTip *tip ); | |
bd9cd534 VZ |
464 | |
465 | // process TTN_NEEDTEXT message properly (i.e. fixing the bugs in | |
466 | // comctl32.dll in our code -- see the function body for more info) | |
467 | bool HandleTooltipNotify(WXUINT code, | |
468 | WXLPARAM lParam, | |
469 | const wxString& ttip); | |
cc2b7472 VZ |
470 | #endif // wxUSE_TOOLTIPS |
471 | ||
b09bda68 | 472 | // the helper functions used by HandleChar/KeyXXX methods |
9c7df356 VZ |
473 | wxKeyEvent CreateKeyEvent(wxEventType evType, int id, |
474 | WXLPARAM lParam = 0, WXWPARAM wParam = 0) const; | |
b09bda68 | 475 | |
fd3f686c VZ |
476 | private: |
477 | // common part of all ctors | |
478 | void Init(); | |
479 | ||
a23fd0e1 VZ |
480 | // the (non-virtual) handlers for the events |
481 | bool HandleMove(int x, int y); | |
5706de1c | 482 | bool HandleMoving(wxRect& rect); |
a23fd0e1 VZ |
483 | bool HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags); |
484 | ||
485 | #ifdef __WIN95__ | |
486 | bool HandleNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result); | |
487 | #endif // __WIN95__ | |
488 | ||
d7cbabe0 VZ |
489 | // list of disabled children before last call to our Disable() |
490 | wxWindowList *m_childrenDisabled; | |
491 | ||
e8e4fa12 GT |
492 | DECLARE_DYNAMIC_CLASS(wxWindowMSW) |
493 | DECLARE_NO_COPY_CLASS(wxWindowMSW) | |
fd3f686c | 494 | DECLARE_EVENT_TABLE() |
2bda0e17 KB |
495 | }; |
496 | ||
cc2b7472 VZ |
497 | // --------------------------------------------------------------------------- |
498 | // global functions | |
499 | // --------------------------------------------------------------------------- | |
2bda0e17 | 500 | |
cc2b7472 | 501 | // kbd code translation |
184b5d99 JS |
502 | WXDLLEXPORT int wxCharCodeMSWToWX(int keySym); |
503 | WXDLLEXPORT int wxCharCodeWXToMSW(int id, bool *IsVirtual); | |
2bda0e17 | 504 | |
b225f659 VZ |
505 | // window creation helper class: before creating a new HWND, instantiate an |
506 | // object of this class on stack - this allows to process the messages sent to | |
507 | // the window even before CreateWindow() returns | |
508 | class wxWindowCreationHook | |
509 | { | |
510 | public: | |
511 | wxWindowCreationHook(wxWindowMSW *winBeingCreated); | |
512 | ~wxWindowCreationHook(); | |
513 | }; | |
514 | ||
2bda0e17 | 515 | #endif |
bbcdf8bc | 516 | // _WX_WINDOW_H_ |