]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: wx/msw/window.h | |
3 | // Purpose: wxWindowMSW class | |
4 | // Author: Julian Smart | |
5 | // Modified by: Vadim Zeitlin on 13.05.99: complete refont of message handling, | |
6 | // elimination of Default(), ... | |
7 | // Created: 01/02/97 | |
8 | // RCS-ID: $Id$ | |
9 | // Copyright: (c) Julian Smart | |
10 | // Licence: wxWindows licence | |
11 | ///////////////////////////////////////////////////////////////////////////// | |
12 | ||
13 | #ifndef _WX_WINDOW_H_ | |
14 | #define _WX_WINDOW_H_ | |
15 | ||
16 | // --------------------------------------------------------------------------- | |
17 | // constants | |
18 | // --------------------------------------------------------------------------- | |
19 | ||
20 | // --------------------------------------------------------------------------- | |
21 | // wxWindow declaration for MSW | |
22 | // --------------------------------------------------------------------------- | |
23 | ||
24 | class WXDLLEXPORT wxWindowMSW : public wxWindowBase | |
25 | { | |
26 | friend class wxSpinCtrl; | |
27 | friend class wxSlider; | |
28 | friend class wxRadioBox; | |
29 | #if defined __VISUALC__ && __VISUALC__ <= 1200 | |
30 | friend class wxWindowMSW; | |
31 | #endif | |
32 | public: | |
33 | wxWindowMSW() { Init(); } | |
34 | ||
35 | wxWindowMSW(wxWindow *parent, | |
36 | wxWindowID id, | |
37 | const wxPoint& pos = wxDefaultPosition, | |
38 | const wxSize& size = wxDefaultSize, | |
39 | long style = 0, | |
40 | const wxString& name = wxPanelNameStr) | |
41 | { | |
42 | Init(); | |
43 | Create(parent, id, pos, size, style, name); | |
44 | } | |
45 | ||
46 | virtual ~wxWindowMSW(); | |
47 | ||
48 | bool Create(wxWindow *parent, | |
49 | wxWindowID id, | |
50 | const wxPoint& pos = wxDefaultPosition, | |
51 | const wxSize& size = wxDefaultSize, | |
52 | long style = 0, | |
53 | const wxString& name = wxPanelNameStr); | |
54 | ||
55 | // implement base class pure virtuals | |
56 | virtual void SetLabel(const wxString& label); | |
57 | virtual wxString GetLabel() const; | |
58 | ||
59 | virtual void Raise(); | |
60 | virtual void Lower(); | |
61 | ||
62 | virtual bool Show(bool show = true); | |
63 | virtual bool ShowWithEffect(wxShowEffect effect, | |
64 | unsigned timeout = 0, | |
65 | wxDirection dir = wxBOTTOM) | |
66 | { | |
67 | return MSWShowWithEffect(true, effect, timeout, dir); | |
68 | } | |
69 | virtual bool HideWithEffect(wxShowEffect effect, | |
70 | unsigned timeout = 0, | |
71 | wxDirection dir = wxBOTTOM) | |
72 | { | |
73 | return MSWShowWithEffect(false, effect, timeout, dir); | |
74 | } | |
75 | ||
76 | virtual void SetFocus(); | |
77 | virtual void SetFocusFromKbd(); | |
78 | ||
79 | virtual bool Reparent(wxWindowBase *newParent); | |
80 | ||
81 | virtual void WarpPointer(int x, int y); | |
82 | ||
83 | virtual void Refresh( bool eraseBackground = true, | |
84 | const wxRect *rect = (const wxRect *) NULL ); | |
85 | virtual void Update(); | |
86 | ||
87 | virtual void SetWindowStyleFlag(long style); | |
88 | virtual void SetExtraStyle(long exStyle); | |
89 | virtual bool SetCursor( const wxCursor &cursor ); | |
90 | virtual bool SetFont( const wxFont &font ); | |
91 | ||
92 | virtual int GetCharHeight() const; | |
93 | virtual int GetCharWidth() const; | |
94 | virtual void GetTextExtent(const wxString& string, | |
95 | int *x, int *y, | |
96 | int *descent = (int *) NULL, | |
97 | int *externalLeading = (int *) NULL, | |
98 | const wxFont *theFont = (const wxFont *) NULL) | |
99 | const; | |
100 | ||
101 | virtual void SetScrollbar( int orient, int pos, int thumbVisible, | |
102 | int range, bool refresh = true ); | |
103 | virtual void SetScrollPos( int orient, int pos, bool refresh = true ); | |
104 | virtual int GetScrollPos( int orient ) const; | |
105 | virtual int GetScrollThumb( int orient ) const; | |
106 | virtual int GetScrollRange( int orient ) const; | |
107 | virtual void ScrollWindow( int dx, int dy, | |
108 | const wxRect* rect = (wxRect *) NULL ); | |
109 | ||
110 | virtual bool ScrollLines(int lines); | |
111 | virtual bool ScrollPages(int pages); | |
112 | ||
113 | virtual void SetLayoutDirection(wxLayoutDirection dir); | |
114 | virtual wxLayoutDirection GetLayoutDirection() const; | |
115 | virtual wxCoord AdjustForLayoutDirection(wxCoord x, | |
116 | wxCoord width, | |
117 | wxCoord widthTotal) const; | |
118 | ||
119 | #if wxUSE_DRAG_AND_DROP | |
120 | virtual void SetDropTarget( wxDropTarget *dropTarget ); | |
121 | #endif // wxUSE_DRAG_AND_DROP | |
122 | ||
123 | // Accept files for dragging | |
124 | virtual void DragAcceptFiles(bool accept); | |
125 | ||
126 | #ifndef __WXUNIVERSAL__ | |
127 | // Native resource loading (implemented in src/msw/nativdlg.cpp) | |
128 | // FIXME: should they really be all virtual? | |
129 | virtual bool LoadNativeDialog(wxWindow* parent, wxWindowID& id); | |
130 | virtual bool LoadNativeDialog(wxWindow* parent, const wxString& name); | |
131 | wxWindow* GetWindowChild1(wxWindowID id); | |
132 | wxWindow* GetWindowChild(wxWindowID id); | |
133 | #endif // __WXUNIVERSAL__ | |
134 | ||
135 | #if wxUSE_HOTKEY | |
136 | // install and deinstall a system wide hotkey | |
137 | virtual bool RegisterHotKey(int hotkeyId, int modifiers, int keycode); | |
138 | virtual bool UnregisterHotKey(int hotkeyId); | |
139 | #endif // wxUSE_HOTKEY | |
140 | ||
141 | #ifdef __POCKETPC__ | |
142 | bool IsContextMenuEnabled() const { return m_contextMenuEnabled; } | |
143 | void EnableContextMenu(bool enable = true) { m_contextMenuEnabled = enable; } | |
144 | #endif | |
145 | ||
146 | // window handle stuff | |
147 | // ------------------- | |
148 | ||
149 | WXHWND GetHWND() const { return m_hWnd; } | |
150 | void SetHWND(WXHWND hWnd) { m_hWnd = hWnd; } | |
151 | virtual WXWidget GetHandle() const { return GetHWND(); } | |
152 | ||
153 | void AssociateHandle(WXWidget handle); | |
154 | void DissociateHandle(); | |
155 | ||
156 | // does this window have deferred position and/or size? | |
157 | bool IsSizeDeferred() const; | |
158 | ||
159 | // these functions allow to register a global handler for the given Windows | |
160 | // message: it will be called from MSWWindowProc() of any window which gets | |
161 | // this event if it's not processed before (i.e. unlike a hook procedure it | |
162 | // does not override the normal processing) | |
163 | // | |
164 | // notice that if you want to process a message for a given window only you | |
165 | // should override its MSWWindowProc() instead | |
166 | ||
167 | // type of the handler: it is called with the message parameters (except | |
168 | // that the window object is passed instead of window handle) and should | |
169 | // return true if it handled the message or false if it should be passed to | |
170 | // DefWindowProc() | |
171 | typedef bool (*MSWMessageHandler)(wxWindowMSW *win, | |
172 | WXUINT nMsg, | |
173 | WXWPARAM wParam, | |
174 | WXLPARAM lParam); | |
175 | ||
176 | // install a handler, shouldn't be called more than one for the same message | |
177 | static bool MSWRegisterMessageHandler(int msg, MSWMessageHandler handler); | |
178 | ||
179 | // unregister a previously registered handler | |
180 | static void MSWUnregisterMessageHandler(int msg, MSWMessageHandler handler); | |
181 | ||
182 | ||
183 | // implementation from now on | |
184 | // ========================== | |
185 | ||
186 | // event handlers | |
187 | // -------------- | |
188 | ||
189 | void OnPaint(wxPaintEvent& event); | |
190 | void OnEraseBackground(wxEraseEvent& event); | |
191 | #ifdef __WXWINCE__ | |
192 | void OnInitDialog(wxInitDialogEvent& event); | |
193 | #endif | |
194 | ||
195 | public: | |
196 | // Windows subclassing | |
197 | void SubclassWin(WXHWND hWnd); | |
198 | void UnsubclassWin(); | |
199 | ||
200 | WXFARPROC MSWGetOldWndProc() const { return m_oldWndProc; } | |
201 | void MSWSetOldWndProc(WXFARPROC proc) { m_oldWndProc = proc; } | |
202 | ||
203 | // return true if the window is of a standard (i.e. not wxWidgets') class | |
204 | // | |
205 | // to understand why does it work, look at SubclassWin() code and comments | |
206 | bool IsOfStandardClass() const { return m_oldWndProc != NULL; } | |
207 | ||
208 | wxWindow *FindItem(long id) const; | |
209 | wxWindow *FindItemByHWND(WXHWND hWnd, bool controlOnly = false) const; | |
210 | ||
211 | // MSW only: true if this control is part of the main control | |
212 | virtual bool ContainsHWND(WXHWND WXUNUSED(hWnd)) const { return false; } | |
213 | ||
214 | #if wxUSE_TOOLTIPS | |
215 | // MSW only: true if this window or any of its children have a tooltip | |
216 | virtual bool HasToolTips() const { return GetToolTip() != NULL; } | |
217 | #endif // wxUSE_TOOLTIPS | |
218 | ||
219 | // translate wxWidgets style flags for this control into the Windows style | |
220 | // and optional extended style for the corresponding native control | |
221 | // | |
222 | // this is the function that should be overridden in the derived classes, | |
223 | // but you will mostly use MSWGetCreateWindowFlags() below | |
224 | virtual WXDWORD MSWGetStyle(long flags, WXDWORD *exstyle = NULL) const ; | |
225 | ||
226 | // get the MSW window flags corresponding to wxWidgets ones | |
227 | // | |
228 | // the functions returns the flags (WS_XXX) directly and puts the ext | |
229 | // (WS_EX_XXX) flags into the provided pointer if not NULL | |
230 | WXDWORD MSWGetCreateWindowFlags(WXDWORD *exflags = NULL) const | |
231 | { return MSWGetStyle(GetWindowStyle(), exflags); } | |
232 | ||
233 | // update the real underlying window style flags to correspond to the | |
234 | // current wxWindow object style (safe to call even if window isn't fully | |
235 | // created yet) | |
236 | void MSWUpdateStyle(long flagsOld, long exflagsOld); | |
237 | ||
238 | // translate wxWidgets coords into Windows ones suitable to be passed to | |
239 | // ::CreateWindow() | |
240 | // | |
241 | // returns true if non default coords are returned, false otherwise | |
242 | bool MSWGetCreateWindowCoords(const wxPoint& pos, | |
243 | const wxSize& size, | |
244 | int& x, int& y, | |
245 | int& w, int& h) const; | |
246 | ||
247 | // get the HWND to be used as parent of this window with CreateWindow() | |
248 | virtual WXHWND MSWGetParent() const; | |
249 | ||
250 | // creates the window of specified Windows class with given style, extended | |
251 | // style, title and geometry (default values | |
252 | // | |
253 | // returns true if the window has been created, false if creation failed | |
254 | bool MSWCreate(const wxChar *wclass, | |
255 | const wxChar *title = NULL, | |
256 | const wxPoint& pos = wxDefaultPosition, | |
257 | const wxSize& size = wxDefaultSize, | |
258 | WXDWORD style = 0, | |
259 | WXDWORD exendedStyle = 0); | |
260 | ||
261 | virtual bool MSWCommand(WXUINT param, WXWORD id); | |
262 | ||
263 | #ifndef __WXUNIVERSAL__ | |
264 | // Create an appropriate wxWindow from a HWND | |
265 | virtual wxWindow* CreateWindowFromHWND(wxWindow* parent, WXHWND hWnd); | |
266 | ||
267 | // Make sure the window style reflects the HWND style (roughly) | |
268 | virtual void AdoptAttributesFromHWND(); | |
269 | #endif // __WXUNIVERSAL__ | |
270 | ||
271 | // Setup background and foreground colours correctly | |
272 | virtual void SetupColours(); | |
273 | ||
274 | // ------------------------------------------------------------------------ | |
275 | // helpers for message handlers: these perform the same function as the | |
276 | // message crackers from <windowsx.h> - they unpack WPARAM and LPARAM into | |
277 | // the correct parameters | |
278 | // ------------------------------------------------------------------------ | |
279 | ||
280 | void UnpackCommand(WXWPARAM wParam, WXLPARAM lParam, | |
281 | WXWORD *id, WXHWND *hwnd, WXWORD *cmd); | |
282 | void UnpackActivate(WXWPARAM wParam, WXLPARAM lParam, | |
283 | WXWORD *state, WXWORD *minimized, WXHWND *hwnd); | |
284 | void UnpackScroll(WXWPARAM wParam, WXLPARAM lParam, | |
285 | WXWORD *code, WXWORD *pos, WXHWND *hwnd); | |
286 | void UnpackCtlColor(WXWPARAM wParam, WXLPARAM lParam, | |
287 | WXHDC *hdc, WXHWND *hwnd); | |
288 | void UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam, | |
289 | WXWORD *item, WXWORD *flags, WXHMENU *hmenu); | |
290 | ||
291 | // ------------------------------------------------------------------------ | |
292 | // internal handlers for MSW messages: all handlers return a boolean value: | |
293 | // true means that the handler processed the event and false that it didn't | |
294 | // ------------------------------------------------------------------------ | |
295 | ||
296 | // there are several cases where we have virtual functions for Windows | |
297 | // message processing: this is because these messages often require to be | |
298 | // processed in a different manner in the derived classes. For all other | |
299 | // messages, however, we do *not* have corresponding MSWOnXXX() function | |
300 | // and if the derived class wants to process them, it should override | |
301 | // MSWWindowProc() directly. | |
302 | ||
303 | // scroll event (both horizontal and vertical) | |
304 | virtual bool MSWOnScroll(int orientation, WXWORD nSBCode, | |
305 | WXWORD pos, WXHWND control); | |
306 | ||
307 | // child control notifications | |
308 | virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result); | |
309 | ||
310 | // owner-drawn controls need to process these messages | |
311 | virtual bool MSWOnDrawItem(int id, WXDRAWITEMSTRUCT *item); | |
312 | virtual bool MSWOnMeasureItem(int id, WXMEASUREITEMSTRUCT *item); | |
313 | ||
314 | // the rest are not virtual | |
315 | bool HandleCreate(WXLPCREATESTRUCT cs, bool *mayCreate); | |
316 | bool HandleInitDialog(WXHWND hWndFocus); | |
317 | bool HandleDestroy(); | |
318 | ||
319 | bool HandlePaint(); | |
320 | bool HandlePrintClient(WXHDC hDC); | |
321 | bool HandleEraseBkgnd(WXHDC hDC); | |
322 | ||
323 | bool HandleMinimize(); | |
324 | bool HandleMaximize(); | |
325 | bool HandleSize(int x, int y, WXUINT flag); | |
326 | bool HandleSizing(wxRect& rect); | |
327 | bool HandleGetMinMaxInfo(void *mmInfo); | |
328 | bool HandleEnterSizeMove(); | |
329 | bool HandleExitSizeMove(); | |
330 | ||
331 | bool HandleShow(bool show, int status); | |
332 | bool HandleActivate(int flag, bool minimized, WXHWND activate); | |
333 | ||
334 | bool HandleCommand(WXWORD id, WXWORD cmd, WXHWND control); | |
335 | ||
336 | bool HandleCtlColor(WXHBRUSH *hBrush, WXHDC hdc, WXHWND hWnd); | |
337 | ||
338 | bool HandlePaletteChanged(WXHWND hWndPalChange); | |
339 | bool HandleQueryNewPalette(); | |
340 | bool HandleSysColorChange(); | |
341 | bool HandleDisplayChange(); | |
342 | bool HandleCaptureChanged(WXHWND gainedCapture); | |
343 | virtual bool HandleSettingChange(WXWPARAM wParam, WXLPARAM lParam); | |
344 | ||
345 | bool HandleQueryEndSession(long logOff, bool *mayEnd); | |
346 | bool HandleEndSession(bool endSession, long logOff); | |
347 | ||
348 | bool HandleSetFocus(WXHWND wnd); | |
349 | bool HandleKillFocus(WXHWND wnd); | |
350 | ||
351 | bool HandleDropFiles(WXWPARAM wParam); | |
352 | ||
353 | bool HandleMouseEvent(WXUINT msg, int x, int y, WXUINT flags); | |
354 | bool HandleMouseMove(int x, int y, WXUINT flags); | |
355 | bool HandleMouseWheel(WXWPARAM wParam, WXLPARAM lParam); | |
356 | ||
357 | bool HandleChar(WXWPARAM wParam, WXLPARAM lParam, bool isASCII = false); | |
358 | bool HandleKeyDown(WXWPARAM wParam, WXLPARAM lParam); | |
359 | bool HandleKeyUp(WXWPARAM wParam, WXLPARAM lParam); | |
360 | #if wxUSE_ACCEL | |
361 | bool HandleHotKey(WXWPARAM wParam, WXLPARAM lParam); | |
362 | #endif | |
363 | #ifdef __WIN32__ | |
364 | int HandleMenuChar(int chAccel, WXLPARAM lParam); | |
365 | #endif | |
366 | // Create and process a clipboard event specified by type. | |
367 | bool HandleClipboardEvent( WXUINT nMsg ); | |
368 | ||
369 | bool HandleQueryDragIcon(WXHICON *hIcon); | |
370 | ||
371 | bool HandleSetCursor(WXHWND hWnd, short nHitTest, int mouseMsg); | |
372 | ||
373 | bool HandlePower(WXWPARAM wParam, WXLPARAM lParam, bool *vetoed); | |
374 | ||
375 | ||
376 | // Window procedure | |
377 | virtual WXLRESULT MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam); | |
378 | ||
379 | // Calls an appropriate default window procedure | |
380 | virtual WXLRESULT MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam); | |
381 | ||
382 | // message processing helpers | |
383 | ||
384 | // return false if the message shouldn't be translated/preprocessed but | |
385 | // dispatched normally | |
386 | virtual bool MSWShouldPreProcessMessage(WXMSG* pMsg); | |
387 | ||
388 | // return true if the message was preprocessed and shouldn't be dispatched | |
389 | virtual bool MSWProcessMessage(WXMSG* pMsg); | |
390 | ||
391 | // return true if the message was translated and shouldn't be dispatched | |
392 | virtual bool MSWTranslateMessage(WXMSG* pMsg); | |
393 | ||
394 | // called when the window is about to be destroyed | |
395 | virtual void MSWDestroyWindow(); | |
396 | ||
397 | ||
398 | // this function should return the brush to paint the children controls | |
399 | // background or 0 if this window doesn't impose any particular background | |
400 | // on its children | |
401 | // | |
402 | // the base class version returns a solid brush if we have a non default | |
403 | // background colour or 0 otherwise | |
404 | virtual WXHBRUSH MSWGetBgBrushForChild(WXHDC hDC, WXHWND hWnd); | |
405 | ||
406 | // return the background brush to use for painting the given window by | |
407 | // quering the parent windows via their MSWGetBgBrushForChild() recursively | |
408 | // | |
409 | // hWndToPaint is normally NULL meaning this window itself, but it can also | |
410 | // be a child of this window which is used by the static box and could be | |
411 | // potentially useful for other transparent controls | |
412 | WXHBRUSH MSWGetBgBrush(WXHDC hDC, WXHWND hWndToPaint = NULL); | |
413 | ||
414 | // gives the parent the possibility to draw its children background, e.g. | |
415 | // this is used by wxNotebook to do it using DrawThemeBackground() | |
416 | // | |
417 | // return true if background was drawn, false otherwise | |
418 | virtual bool MSWPrintChild(WXHDC WXUNUSED(hDC), wxWindow * WXUNUSED(child)) | |
419 | { | |
420 | return false; | |
421 | } | |
422 | ||
423 | // some controls (e.g. wxListBox) need to set the return value themselves | |
424 | // | |
425 | // return true to let parent handle it if we don't, false otherwise | |
426 | virtual bool MSWShouldPropagatePrintChild() | |
427 | { | |
428 | return true; | |
429 | } | |
430 | ||
431 | // common part of Show/HideWithEffect() | |
432 | bool MSWShowWithEffect(bool show, | |
433 | wxShowEffect effect, | |
434 | unsigned timeout, | |
435 | wxDirection dir); | |
436 | ||
437 | // Responds to colour changes: passes event on to children. | |
438 | void OnSysColourChanged(wxSysColourChangedEvent& event); | |
439 | ||
440 | // initialize various fields of wxMouseEvent (common part of MSWOnMouseXXX) | |
441 | void InitMouseEvent(wxMouseEvent& event, int x, int y, WXUINT flags); | |
442 | ||
443 | // check if mouse is in the window | |
444 | bool IsMouseInWindow() const; | |
445 | ||
446 | // check if a native double-buffering applies for this window | |
447 | virtual bool IsDoubleBuffered() const; | |
448 | ||
449 | // synthesize a wxEVT_LEAVE_WINDOW event and set m_mouseInWindow to false | |
450 | void GenerateMouseLeave(); | |
451 | ||
452 | // virtual function for implementing internal idle | |
453 | // behaviour | |
454 | virtual void OnInternalIdle(); | |
455 | ||
456 | protected: | |
457 | // this allows you to implement standard control borders without | |
458 | // repeating the code in different classes that are not derived from | |
459 | // wxControl | |
460 | virtual wxBorder GetDefaultBorderForControl() const; | |
461 | ||
462 | // choose the default border for this window | |
463 | virtual wxBorder GetDefaultBorder() const; | |
464 | ||
465 | // Translate wxBORDER_THEME (and other border styles if necessary to the value | |
466 | // that makes most sense for this Windows environment | |
467 | virtual wxBorder TranslateBorder(wxBorder border) const; | |
468 | ||
469 | #if wxUSE_MENUS_NATIVE | |
470 | virtual bool DoPopupMenu( wxMenu *menu, int x, int y ); | |
471 | #endif // wxUSE_MENUS_NATIVE | |
472 | ||
473 | // the window handle | |
474 | WXHWND m_hWnd; | |
475 | ||
476 | // the old window proc (we subclass all windows) | |
477 | WXFARPROC m_oldWndProc; | |
478 | ||
479 | // additional (MSW specific) flags | |
480 | bool m_mouseInWindow:1; | |
481 | bool m_lastKeydownProcessed:1; | |
482 | ||
483 | // the size of one page for scrolling | |
484 | int m_xThumbSize; | |
485 | int m_yThumbSize; | |
486 | ||
487 | // implement the base class pure virtuals | |
488 | virtual void DoClientToScreen( int *x, int *y ) const; | |
489 | virtual void DoScreenToClient( int *x, int *y ) const; | |
490 | virtual void DoGetPosition( int *x, int *y ) const; | |
491 | virtual void DoGetSize( int *width, int *height ) const; | |
492 | virtual void DoGetClientSize( int *width, int *height ) const; | |
493 | virtual void DoSetSize(int x, int y, | |
494 | int width, int height, | |
495 | int sizeFlags = wxSIZE_AUTO); | |
496 | virtual void DoSetClientSize(int width, int height); | |
497 | ||
498 | virtual void DoCaptureMouse(); | |
499 | virtual void DoReleaseMouse(); | |
500 | ||
501 | virtual void DoEnable(bool enable); | |
502 | ||
503 | virtual void DoFreeze(); | |
504 | virtual void DoThaw(); | |
505 | ||
506 | // this simply moves/resizes the given HWND which is supposed to be our | |
507 | // sibling (this is useful for controls which are composite at MSW level | |
508 | // and for which DoMoveWindow() is not enough) | |
509 | // | |
510 | // returns true if the window move was deferred, false if it was moved | |
511 | // immediately (no error return) | |
512 | bool DoMoveSibling(WXHWND hwnd, int x, int y, int width, int height); | |
513 | ||
514 | // move the window to the specified location and resize it: this is called | |
515 | // from both DoSetSize() and DoSetClientSize() and would usually just call | |
516 | // ::MoveWindow() except for composite controls which will want to arrange | |
517 | // themselves inside the given rectangle | |
518 | virtual void DoMoveWindow(int x, int y, int width, int height); | |
519 | ||
520 | #if wxUSE_TOOLTIPS | |
521 | virtual void DoSetToolTip( wxToolTip *tip ); | |
522 | ||
523 | // process TTN_NEEDTEXT message properly (i.e. fixing the bugs in | |
524 | // comctl32.dll in our code -- see the function body for more info) | |
525 | bool HandleTooltipNotify(WXUINT code, | |
526 | WXLPARAM lParam, | |
527 | const wxString& ttip); | |
528 | #endif // wxUSE_TOOLTIPS | |
529 | ||
530 | // the helper functions used by HandleChar/KeyXXX methods | |
531 | wxKeyEvent CreateKeyEvent(wxEventType evType, int id, | |
532 | WXLPARAM lParam = 0, WXWPARAM wParam = 0) const; | |
533 | ||
534 | ||
535 | // default OnEraseBackground() implementation, return true if we did erase | |
536 | // the background, false otherwise (i.e. the system should erase it) | |
537 | bool DoEraseBackground(WXHDC hDC); | |
538 | ||
539 | // generate WM_CHANGEUISTATE if it's needed for the OS we're running under | |
540 | // | |
541 | // action should be one of the UIS_XXX constants | |
542 | // state should be one or more of the UISF_XXX constants | |
543 | // if action == UIS_INITIALIZE then it doesn't seem to matter what we use | |
544 | // for state as the system will decide for us what needs to be set | |
545 | void MSWUpdateUIState(int action, int state = 0); | |
546 | ||
547 | private: | |
548 | // common part of all ctors | |
549 | void Init(); | |
550 | ||
551 | // the (non-virtual) handlers for the events | |
552 | bool HandleMove(int x, int y); | |
553 | bool HandleMoving(wxRect& rect); | |
554 | bool HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags); | |
555 | bool HandleNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result); | |
556 | ||
557 | ||
558 | // current defer window position operation handle (may be NULL) | |
559 | WXHANDLE m_hDWP; | |
560 | ||
561 | protected: | |
562 | // When deferred positioning is done these hold the pending changes, and | |
563 | // are used for the default values if another size/pos changes is done on | |
564 | // this window before the group of deferred changes is completed. | |
565 | wxPoint m_pendingPosition; | |
566 | wxSize m_pendingSize; | |
567 | ||
568 | private: | |
569 | #ifdef __POCKETPC__ | |
570 | bool m_contextMenuEnabled; | |
571 | #endif | |
572 | ||
573 | DECLARE_DYNAMIC_CLASS(wxWindowMSW) | |
574 | DECLARE_NO_COPY_CLASS(wxWindowMSW) | |
575 | DECLARE_EVENT_TABLE() | |
576 | }; | |
577 | ||
578 | // ---------------------------------------------------------------------------- | |
579 | // inline functions | |
580 | // ---------------------------------------------------------------------------- | |
581 | ||
582 | // --------------------------------------------------------------------------- | |
583 | // global functions | |
584 | // --------------------------------------------------------------------------- | |
585 | ||
586 | // kbd code translation | |
587 | WXDLLEXPORT int wxCharCodeMSWToWX(int keySym, WXLPARAM lParam = 0); | |
588 | WXDLLEXPORT WXWORD wxCharCodeWXToMSW(int id, bool *IsVirtual = NULL); | |
589 | ||
590 | // window creation helper class: before creating a new HWND, instantiate an | |
591 | // object of this class on stack - this allows to process the messages sent to | |
592 | // the window even before CreateWindow() returns | |
593 | class wxWindowCreationHook | |
594 | { | |
595 | public: | |
596 | wxWindowCreationHook(wxWindowMSW *winBeingCreated); | |
597 | ~wxWindowCreationHook(); | |
598 | }; | |
599 | ||
600 | // ---------------------------------------------------------------------------- | |
601 | // global objects | |
602 | // ---------------------------------------------------------------------------- | |
603 | ||
604 | // notice that this hash must be defined after wxWindow declaration as it | |
605 | // needs to "see" its dtor and not just forward declaration | |
606 | #include "wx/hash.h" | |
607 | ||
608 | // pseudo-template HWND <-> wxWindow hash table | |
609 | WX_DECLARE_HASH(wxWindowMSW, wxWindowList, wxWinHashTable); | |
610 | ||
611 | extern wxWinHashTable *wxWinHandleHash; | |
612 | ||
613 | #endif // _WX_WINDOW_H_ |