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