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(), ...
9 // Copyright: (c) Julian Smart
10 // Licence: wxWindows licence
11 /////////////////////////////////////////////////////////////////////////////
16 // ---------------------------------------------------------------------------
18 // ---------------------------------------------------------------------------
20 // ---------------------------------------------------------------------------
21 // wxWindow declaration for MSW
22 // ---------------------------------------------------------------------------
24 class WXDLLEXPORT wxWindowMSW
: public wxWindowBase
26 friend class wxSpinCtrl
;
27 friend class wxSlider
;
28 friend class wxRadioBox
;
29 #if defined __VISUALC__ && __VISUALC__ <= 1200
30 friend class wxWindowMSW
;
33 wxWindowMSW() { Init(); }
35 wxWindowMSW(wxWindow
*parent
,
37 const wxPoint
& pos
= wxDefaultPosition
,
38 const wxSize
& size
= wxDefaultSize
,
40 const wxString
& name
= wxPanelNameStr
)
43 Create(parent
, id
, pos
, size
, style
, name
);
46 virtual ~wxWindowMSW();
48 bool Create(wxWindow
*parent
,
50 const wxPoint
& pos
= wxDefaultPosition
,
51 const wxSize
& size
= wxDefaultSize
,
53 const wxString
& name
= wxPanelNameStr
);
55 // implement base class pure virtuals
56 virtual void SetLabel(const wxString
& label
);
57 virtual wxString
GetLabel() const;
62 virtual bool Show( bool show
= true );
64 virtual void SetFocus();
65 virtual void SetFocusFromKbd();
67 virtual bool Reparent(wxWindowBase
*newParent
);
69 virtual void WarpPointer(int x
, int y
);
71 virtual void Refresh( bool eraseBackground
= true,
72 const wxRect
*rect
= (const wxRect
*) NULL
);
73 virtual void Update();
74 virtual void Freeze();
76 virtual bool IsFrozen() const { return m_frozenness
> 0; }
78 virtual void SetWindowStyleFlag(long style
);
79 virtual void SetExtraStyle(long exStyle
);
80 virtual bool SetCursor( const wxCursor
&cursor
);
81 virtual bool SetFont( const wxFont
&font
);
83 virtual int GetCharHeight() const;
84 virtual int GetCharWidth() const;
85 virtual void GetTextExtent(const wxString
& string
,
87 int *descent
= (int *) NULL
,
88 int *externalLeading
= (int *) NULL
,
89 const wxFont
*theFont
= (const wxFont
*) NULL
)
92 virtual void SetScrollbar( int orient
, int pos
, int thumbVisible
,
93 int range
, bool refresh
= true );
94 virtual void SetScrollPos( int orient
, int pos
, bool refresh
= true );
95 virtual int GetScrollPos( int orient
) const;
96 virtual int GetScrollThumb( int orient
) const;
97 virtual int GetScrollRange( int orient
) const;
98 virtual void ScrollWindow( int dx
, int dy
,
99 const wxRect
* rect
= (wxRect
*) NULL
);
101 virtual bool ScrollLines(int lines
);
102 virtual bool ScrollPages(int pages
);
104 virtual void SetLayoutDirection(wxLayoutDirection dir
);
105 virtual wxLayoutDirection
GetLayoutDirection() const;
106 virtual wxCoord
AdjustForLayoutDirection(wxCoord x
,
108 wxCoord widthTotal
) const;
110 #if wxUSE_DRAG_AND_DROP
111 virtual void SetDropTarget( wxDropTarget
*dropTarget
);
112 #endif // wxUSE_DRAG_AND_DROP
114 // Accept files for dragging
115 virtual void DragAcceptFiles(bool accept
);
117 #ifndef __WXUNIVERSAL__
118 // Native resource loading (implemented in src/msw/nativdlg.cpp)
119 // FIXME: should they really be all virtual?
120 virtual bool LoadNativeDialog(wxWindow
* parent
, wxWindowID
& id
);
121 virtual bool LoadNativeDialog(wxWindow
* parent
, const wxString
& name
);
122 wxWindow
* GetWindowChild1(wxWindowID id
);
123 wxWindow
* GetWindowChild(wxWindowID id
);
124 #endif // __WXUNIVERSAL__
127 // install and deinstall a system wide hotkey
128 virtual bool RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
);
129 virtual bool UnregisterHotKey(int hotkeyId
);
130 #endif // wxUSE_HOTKEY
133 bool IsContextMenuEnabled() const { return m_contextMenuEnabled
; }
134 void EnableContextMenu(bool enable
= true) { m_contextMenuEnabled
= enable
; }
137 // window handle stuff
138 // -------------------
140 WXHWND
GetHWND() const { return m_hWnd
; }
141 void SetHWND(WXHWND hWnd
) { m_hWnd
= hWnd
; }
142 virtual WXWidget
GetHandle() const { return GetHWND(); }
144 void AssociateHandle(WXWidget handle
);
145 void DissociateHandle();
147 // does this window have deferred position and/or size?
148 bool IsSizeDeferred() const;
150 // these functions allow to register a global handler for the given Windows
151 // message: it will be called from MSWWindowProc() of any window which gets
152 // this event if it's not processed before (i.e. unlike a hook procedure it
153 // does not override the normal processing)
155 // notice that if you want to process a message for a given window only you
156 // should override its MSWWindowProc() instead
158 // type of the handler: it is called with the message parameters (except
159 // that the window object is passed instead of window handle) and should
160 // return true if it handled the message or false if it should be passed to
162 typedef bool (*MSWMessageHandler
)(wxWindowMSW
*win
,
167 // install a handler, shouldn't be called more than one for the same message
168 static bool MSWRegisterMessageHandler(int msg
, MSWMessageHandler handler
);
170 // unregister a previously registered handler
171 static void MSWUnregisterMessageHandler(int msg
, MSWMessageHandler handler
);
174 // implementation from now on
175 // ==========================
180 void OnPaint(wxPaintEvent
& event
);
181 void OnEraseBackground(wxEraseEvent
& event
);
183 void OnInitDialog(wxInitDialogEvent
& event
);
187 // Windows subclassing
188 void SubclassWin(WXHWND hWnd
);
189 void UnsubclassWin();
191 WXFARPROC
MSWGetOldWndProc() const { return m_oldWndProc
; }
192 void MSWSetOldWndProc(WXFARPROC proc
) { m_oldWndProc
= proc
; }
194 // return true if the window is of a standard (i.e. not wxWidgets') class
196 // to understand why does it work, look at SubclassWin() code and comments
197 bool IsOfStandardClass() const { return m_oldWndProc
!= NULL
; }
199 wxWindow
*FindItem(long id
) const;
200 wxWindow
*FindItemByHWND(WXHWND hWnd
, bool controlOnly
= false) const;
202 // MSW only: true if this control is part of the main control
203 virtual bool ContainsHWND(WXHWND
WXUNUSED(hWnd
)) const { return false; }
206 // MSW only: true if this window or any of its children have a tooltip
207 virtual bool HasToolTips() const { return GetToolTip() != NULL
; }
208 #endif // wxUSE_TOOLTIPS
210 // translate wxWidgets style flags for this control into the Windows style
211 // and optional extended style for the corresponding native control
213 // this is the function that should be overridden in the derived classes,
214 // but you will mostly use MSWGetCreateWindowFlags() below
215 virtual WXDWORD
MSWGetStyle(long flags
, WXDWORD
*exstyle
= NULL
) const ;
217 // get the MSW window flags corresponding to wxWidgets ones
219 // the functions returns the flags (WS_XXX) directly and puts the ext
220 // (WS_EX_XXX) flags into the provided pointer if not NULL
221 WXDWORD
MSWGetCreateWindowFlags(WXDWORD
*exflags
= NULL
) const
222 { return MSWGetStyle(GetWindowStyle(), exflags
); }
224 // update the real underlying window style flags to correspond to the
225 // current wxWindow object style (safe to call even if window isn't fully
227 void MSWUpdateStyle(long flagsOld
, long exflagsOld
);
229 // translate wxWidgets coords into Windows ones suitable to be passed to
232 // returns true if non default coords are returned, false otherwise
233 bool MSWGetCreateWindowCoords(const wxPoint
& pos
,
236 int& w
, int& h
) const;
238 // get the HWND to be used as parent of this window with CreateWindow()
239 virtual WXHWND
MSWGetParent() const;
241 // creates the window of specified Windows class with given style, extended
242 // style, title and geometry (default values
244 // returns true if the window has been created, false if creation failed
245 bool MSWCreate(const wxChar
*wclass
,
246 const wxChar
*title
= NULL
,
247 const wxPoint
& pos
= wxDefaultPosition
,
248 const wxSize
& size
= wxDefaultSize
,
250 WXDWORD exendedStyle
= 0);
252 virtual bool MSWCommand(WXUINT param
, WXWORD id
);
254 #ifndef __WXUNIVERSAL__
255 // Create an appropriate wxWindow from a HWND
256 virtual wxWindow
* CreateWindowFromHWND(wxWindow
* parent
, WXHWND hWnd
);
258 // Make sure the window style reflects the HWND style (roughly)
259 virtual void AdoptAttributesFromHWND();
260 #endif // __WXUNIVERSAL__
262 // Setup background and foreground colours correctly
263 virtual void SetupColours();
265 // ------------------------------------------------------------------------
266 // helpers for message handlers: these perform the same function as the
267 // message crackers from <windowsx.h> - they unpack WPARAM and LPARAM into
268 // the correct parameters
269 // ------------------------------------------------------------------------
271 void UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
272 WXWORD
*id
, WXHWND
*hwnd
, WXWORD
*cmd
);
273 void UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
274 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
);
275 void UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
276 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
);
277 void UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
278 WXHDC
*hdc
, WXHWND
*hwnd
);
279 void UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
280 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
);
282 // ------------------------------------------------------------------------
283 // internal handlers for MSW messages: all handlers return a boolean value:
284 // true means that the handler processed the event and false that it didn't
285 // ------------------------------------------------------------------------
287 // there are several cases where we have virtual functions for Windows
288 // message processing: this is because these messages often require to be
289 // processed in a different manner in the derived classes. For all other
290 // messages, however, we do *not* have corresponding MSWOnXXX() function
291 // and if the derived class wants to process them, it should override
292 // MSWWindowProc() directly.
294 // scroll event (both horizontal and vertical)
295 virtual bool MSWOnScroll(int orientation
, WXWORD nSBCode
,
296 WXWORD pos
, WXHWND control
);
298 // child control notifications
299 virtual bool MSWOnNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
);
301 // owner-drawn controls need to process these messages
302 virtual bool MSWOnDrawItem(int id
, WXDRAWITEMSTRUCT
*item
);
303 virtual bool MSWOnMeasureItem(int id
, WXMEASUREITEMSTRUCT
*item
);
305 // the rest are not virtual
306 bool HandleCreate(WXLPCREATESTRUCT cs
, bool *mayCreate
);
307 bool HandleInitDialog(WXHWND hWndFocus
);
308 bool HandleDestroy();
311 bool HandlePrintClient(WXHDC hDC
);
312 bool HandleEraseBkgnd(WXHDC hDC
);
314 bool HandleMinimize();
315 bool HandleMaximize();
316 bool HandleSize(int x
, int y
, WXUINT flag
);
317 bool HandleSizing(wxRect
& rect
);
318 bool HandleGetMinMaxInfo(void *mmInfo
);
319 bool HandleEnterSizeMove();
320 bool HandleExitSizeMove();
322 bool HandleShow(bool show
, int status
);
323 bool HandleActivate(int flag
, bool minimized
, WXHWND activate
);
325 bool HandleCommand(WXWORD id
, WXWORD cmd
, WXHWND control
);
327 bool HandleCtlColor(WXHBRUSH
*hBrush
, WXHDC hdc
, WXHWND hWnd
);
329 bool HandlePaletteChanged(WXHWND hWndPalChange
);
330 bool HandleQueryNewPalette();
331 bool HandleSysColorChange();
332 bool HandleDisplayChange();
333 bool HandleCaptureChanged(WXHWND gainedCapture
);
334 virtual bool HandleSettingChange(WXWPARAM wParam
, WXLPARAM lParam
);
336 bool HandleQueryEndSession(long logOff
, bool *mayEnd
);
337 bool HandleEndSession(bool endSession
, long logOff
);
339 bool HandleSetFocus(WXHWND wnd
);
340 bool HandleKillFocus(WXHWND wnd
);
342 bool HandleDropFiles(WXWPARAM wParam
);
344 bool HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
);
345 bool HandleMouseMove(int x
, int y
, WXUINT flags
);
346 bool HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
);
348 bool HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
= false);
349 bool HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
);
350 bool HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
);
352 bool HandleHotKey(WXWPARAM wParam
, WXLPARAM lParam
);
355 int HandleMenuChar(int chAccel
, WXLPARAM lParam
);
357 // Create and process a clipboard event specified by type.
358 bool HandleClipboardEvent( WXUINT nMsg
);
360 bool HandleQueryDragIcon(WXHICON
*hIcon
);
362 bool HandleSetCursor(WXHWND hWnd
, short nHitTest
, int mouseMsg
);
364 bool HandlePower(WXWPARAM wParam
, WXLPARAM lParam
, bool *vetoed
);
368 virtual WXLRESULT
MSWWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
);
370 // Calls an appropriate default window procedure
371 virtual WXLRESULT
MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
);
373 // message processing helpers
375 // return false if the message shouldn't be translated/preprocessed but
376 // dispatched normally
377 virtual bool MSWShouldPreProcessMessage(WXMSG
* pMsg
);
379 // return true if the message was preprocessed and shouldn't be dispatched
380 virtual bool MSWProcessMessage(WXMSG
* pMsg
);
382 // return true if the message was translated and shouldn't be dispatched
383 virtual bool MSWTranslateMessage(WXMSG
* pMsg
);
385 // called when the window is about to be destroyed
386 virtual void MSWDestroyWindow();
389 // this function should return the brush to paint the children controls
390 // background or 0 if this window doesn't impose any particular background
393 // the base class version returns a solid brush if we have a non default
394 // background colour or 0 otherwise
395 virtual WXHBRUSH
MSWGetBgBrushForChild(WXHDC hDC
, WXHWND hWnd
);
397 // return the background brush to use for painting the given window by
398 // quering the parent windows via their MSWGetBgBrushForChild() recursively
400 // hWndToPaint is normally NULL meaning this window itself, but it can also
401 // be a child of this window which is used by the static box and could be
402 // potentially useful for other transparent controls
403 WXHBRUSH
MSWGetBgBrush(WXHDC hDC
, WXHWND hWndToPaint
= NULL
);
405 // gives the parent the possibility to draw its children background, e.g.
406 // this is used by wxNotebook to do it using DrawThemeBackground()
408 // return true if background was drawn, false otherwise
409 virtual bool MSWPrintChild(WXHDC
WXUNUSED(hDC
), wxWindow
* WXUNUSED(child
))
414 // some controls (e.g. wxListBox) need to set the return value themselves
416 // return true to let parent handle it if we don't, false otherwise
417 virtual bool MSWShouldPropagatePrintChild()
423 // Responds to colour changes: passes event on to children.
424 void OnSysColourChanged(wxSysColourChangedEvent
& event
);
426 // initialize various fields of wxMouseEvent (common part of MSWOnMouseXXX)
427 void InitMouseEvent(wxMouseEvent
& event
, int x
, int y
, WXUINT flags
);
429 // check if mouse is in the window
430 bool IsMouseInWindow() const;
432 // check if a native double-buffering applies for this window
433 virtual bool IsDoubleBuffered() const;
435 // synthesize a wxEVT_LEAVE_WINDOW event and set m_mouseInWindow to false
436 void GenerateMouseLeave();
438 // virtual function for implementing internal idle
440 virtual void OnInternalIdle();
443 // this allows you to implement standard control borders without
444 // repeating the code in different classes that are not derived from
446 virtual wxBorder
GetDefaultBorderForControl() const;
448 // choose the default border for this window
449 virtual wxBorder
GetDefaultBorder() const;
451 // Translate wxBORDER_THEME (and other border styles if necessary to the value
452 // that makes most sense for this Windows environment
453 virtual wxBorder
TranslateBorder(wxBorder border
) const;
455 #if wxUSE_MENUS_NATIVE
456 virtual bool DoPopupMenu( wxMenu
*menu
, int x
, int y
);
457 #endif // wxUSE_MENUS_NATIVE
462 // the old window proc (we subclass all windows)
463 WXFARPROC m_oldWndProc
;
465 // additional (MSW specific) flags
466 bool m_mouseInWindow
:1;
467 bool m_lastKeydownProcessed
:1;
469 // the size of one page for scrolling
473 // implement the base class pure virtuals
474 virtual void DoClientToScreen( int *x
, int *y
) const;
475 virtual void DoScreenToClient( int *x
, int *y
) const;
476 virtual void DoGetPosition( int *x
, int *y
) const;
477 virtual void DoGetSize( int *width
, int *height
) const;
478 virtual void DoGetClientSize( int *width
, int *height
) const;
479 virtual void DoSetSize(int x
, int y
,
480 int width
, int height
,
481 int sizeFlags
= wxSIZE_AUTO
);
482 virtual void DoSetClientSize(int width
, int height
);
484 virtual void DoCaptureMouse();
485 virtual void DoReleaseMouse();
487 virtual void DoEnable(bool enable
);
489 // this simply moves/resizes the given HWND which is supposed to be our
490 // sibling (this is useful for controls which are composite at MSW level
491 // and for which DoMoveWindow() is not enough)
493 // returns true if the window move was deferred, false if it was moved
494 // immediately (no error return)
495 bool DoMoveSibling(WXHWND hwnd
, int x
, int y
, int width
, int height
);
497 // move the window to the specified location and resize it: this is called
498 // from both DoSetSize() and DoSetClientSize() and would usually just call
499 // ::MoveWindow() except for composite controls which will want to arrange
500 // themselves inside the given rectangle
501 virtual void DoMoveWindow(int x
, int y
, int width
, int height
);
504 virtual void DoSetToolTip( wxToolTip
*tip
);
506 // process TTN_NEEDTEXT message properly (i.e. fixing the bugs in
507 // comctl32.dll in our code -- see the function body for more info)
508 bool HandleTooltipNotify(WXUINT code
,
510 const wxString
& ttip
);
511 #endif // wxUSE_TOOLTIPS
513 // the helper functions used by HandleChar/KeyXXX methods
514 wxKeyEvent
CreateKeyEvent(wxEventType evType
, int id
,
515 WXLPARAM lParam
= 0, WXWPARAM wParam
= 0) const;
518 // default OnEraseBackground() implementation, return true if we did erase
519 // the background, false otherwise (i.e. the system should erase it)
520 bool DoEraseBackground(WXHDC hDC
);
522 // generate WM_CHANGEUISTATE if it's needed for the OS we're running under
524 // action should be one of the UIS_XXX constants
525 // state should be one or more of the UISF_XXX constants
526 // if action == UIS_INITIALIZE then it doesn't seem to matter what we use
527 // for state as the system will decide for us what needs to be set
528 void MSWUpdateUIState(int action
, int state
= 0);
531 // common part of all ctors
534 // the (non-virtual) handlers for the events
535 bool HandleMove(int x
, int y
);
536 bool HandleMoving(wxRect
& rect
);
537 bool HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
);
538 bool HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
);
541 // number of calls to Freeze() minus number of calls to Thaw()
542 unsigned int m_frozenness
;
544 // current defer window position operation handle (may be NULL)
548 // When deferred positioning is done these hold the pending changes, and
549 // are used for the default values if another size/pos changes is done on
550 // this window before the group of deferred changes is completed.
551 wxPoint m_pendingPosition
;
552 wxSize m_pendingSize
;
556 bool m_contextMenuEnabled
;
559 DECLARE_DYNAMIC_CLASS(wxWindowMSW
)
560 DECLARE_NO_COPY_CLASS(wxWindowMSW
)
561 DECLARE_EVENT_TABLE()
564 // ----------------------------------------------------------------------------
566 // ----------------------------------------------------------------------------
568 // ---------------------------------------------------------------------------
570 // ---------------------------------------------------------------------------
572 // kbd code translation
573 WXDLLEXPORT
int wxCharCodeMSWToWX(int keySym
, WXLPARAM lParam
= 0);
574 WXDLLEXPORT WXWORD
wxCharCodeWXToMSW(int id
, bool *IsVirtual
= NULL
);
576 // window creation helper class: before creating a new HWND, instantiate an
577 // object of this class on stack - this allows to process the messages sent to
578 // the window even before CreateWindow() returns
579 class wxWindowCreationHook
582 wxWindowCreationHook(wxWindowMSW
*winBeingCreated
);
583 ~wxWindowCreationHook();
586 // ----------------------------------------------------------------------------
588 // ----------------------------------------------------------------------------
590 // notice that this hash must be defined after wxWindow declaration as it
591 // needs to "see" its dtor and not just forward declaration
594 // pseudo-template HWND <-> wxWindow hash table
595 WX_DECLARE_HASH(wxWindowMSW
, wxWindowList
, wxWinHashTable
);
597 extern wxWinHashTable
*wxWinHandleHash
;
599 #endif // _WX_WINDOW_H_