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