1/////////////////////////////////////////////////////////////////////////////// 2// Name: wx/window.h 3// Purpose: wxWindowBase class - the interface of wxWindow 4// Author: Vadim Zeitlin 5// Modified by: Ron Lee 6// Created: 01/02/97 7// RCS-ID: $Id: window.h 56758 2008-11-13 22:32:21Z VS $ 8// Copyright: (c) Vadim Zeitlin 9// Licence: wxWindows licence 10/////////////////////////////////////////////////////////////////////////////// 11 12#ifndef _WX_WINDOW_H_BASE_ 13#define _WX_WINDOW_H_BASE_ 14 15// ---------------------------------------------------------------------------- 16// headers which we must include here 17// ---------------------------------------------------------------------------- 18 19#include "wx/event.h" // the base class 20 21#include "wx/list.h" // defines wxWindowList 22 23#include "wx/cursor.h" // we have member variables of these classes 24#include "wx/font.h" // so we can't do without them 25#include "wx/colour.h" 26#include "wx/region.h" 27#include "wx/utils.h" 28#include "wx/intl.h" 29 30#include "wx/validate.h" // for wxDefaultValidator (always include it) 31 32#if wxUSE_PALETTE 33 #include "wx/palette.h" 34#endif // wxUSE_PALETTE 35 36#if wxUSE_ACCEL 37 #include "wx/accel.h" 38#endif // wxUSE_ACCEL 39 40#if wxUSE_ACCESSIBILITY 41#include "wx/access.h" 42#endif 43 44// when building wxUniv/Foo we don't want the code for native menu use to be 45// compiled in - it should only be used when building real wxFoo 46#ifdef __WXUNIVERSAL__ 47 #define wxUSE_MENUS_NATIVE 0 48#else // !__WXUNIVERSAL__ 49 #define wxUSE_MENUS_NATIVE wxUSE_MENUS 50#endif // __WXUNIVERSAL__/!__WXUNIVERSAL__ 51 52// ---------------------------------------------------------------------------- 53// forward declarations 54// ---------------------------------------------------------------------------- 55 56class WXDLLIMPEXP_FWD_CORE wxCaret; 57class WXDLLIMPEXP_FWD_CORE wxControl; 58class WXDLLIMPEXP_FWD_CORE wxCursor; 59class WXDLLIMPEXP_FWD_CORE wxDC; 60class WXDLLIMPEXP_FWD_CORE wxDropTarget; 61class WXDLLIMPEXP_FWD_CORE wxItemResource; 62class WXDLLIMPEXP_FWD_CORE wxLayoutConstraints; 63class WXDLLIMPEXP_FWD_CORE wxResourceTable; 64class WXDLLIMPEXP_FWD_CORE wxSizer; 65class WXDLLIMPEXP_FWD_CORE wxToolTip; 66class WXDLLIMPEXP_FWD_CORE wxWindowBase; 67class WXDLLIMPEXP_FWD_CORE wxWindow; 68class WXDLLIMPEXP_FWD_CORE wxScrollHelper; 69 70#if wxUSE_ACCESSIBILITY 71class WXDLLIMPEXP_FWD_CORE wxAccessible; 72#endif 73 74// ---------------------------------------------------------------------------- 75// helper stuff used by wxWindow 76// ---------------------------------------------------------------------------- 77 78// struct containing all the visual attributes of a control 79struct WXDLLEXPORT wxVisualAttributes 80{ 81 // the font used for control label/text inside it 82 wxFont font; 83 84 // the foreground colour 85 wxColour colFg; 86 87 // the background colour, may be wxNullColour if the controls background 88 // colour is not solid 89 wxColour colBg; 90}; 91 92// different window variants, on platforms like eg mac uses different 93// rendering sizes 94enum wxWindowVariant 95{ 96 wxWINDOW_VARIANT_NORMAL, // Normal size 97 wxWINDOW_VARIANT_SMALL, // Smaller size (about 25 % smaller than normal) 98 wxWINDOW_VARIANT_MINI, // Mini size (about 33 % smaller than normal) 99 wxWINDOW_VARIANT_LARGE, // Large size (about 25 % larger than normal) 100 wxWINDOW_VARIANT_MAX 101}; 102 103#if wxUSE_SYSTEM_OPTIONS 104 #define wxWINDOW_DEFAULT_VARIANT wxT("window-default-variant") 105#endif 106 107// ---------------------------------------------------------------------------- 108// (pseudo)template list classes 109// ---------------------------------------------------------------------------- 110 111WX_DECLARE_LIST_3(wxWindow, wxWindowBase, wxWindowList, wxWindowListNode, class WXDLLEXPORT); 112 113// ---------------------------------------------------------------------------- 114// global variables 115// ---------------------------------------------------------------------------- 116 117extern WXDLLEXPORT_DATA(wxWindowList) wxTopLevelWindows; 118extern WXDLLIMPEXP_DATA_CORE(wxList) wxPendingDelete; 119 120// ---------------------------------------------------------------------------- 121// wxWindowBase is the base class for all GUI controls/widgets, this is the public 122// interface of this class. 123// 124// Event handler: windows have themselves as their event handlers by default, 125// but their event handlers could be set to another object entirely. This 126// separation can reduce the amount of derivation required, and allow 127// alteration of a window's functionality (e.g. by a resource editor that 128// temporarily switches event handlers). 129// ---------------------------------------------------------------------------- 130 131class WXDLLEXPORT wxWindowBase : public wxEvtHandler 132{ 133public: 134 // creating the window 135 // ------------------- 136 137 // default ctor, initializes everything which can be initialized before 138 // Create() 139 wxWindowBase() ; 140 141 // pseudo ctor (can't be virtual, called from ctor) 142 bool CreateBase(wxWindowBase *parent, 143 wxWindowID winid, 144 const wxPoint& pos = wxDefaultPosition, 145 const wxSize& size = wxDefaultSize, 146 long style = 0, 147 const wxValidator& validator = wxDefaultValidator, 148 const wxString& name = wxPanelNameStr); 149 150 virtual ~wxWindowBase(); 151 152 // deleting the window 153 // ------------------- 154 155 // ask the window to close itself, return true if the event handler 156 // honoured our request 157 bool Close( bool force = false ); 158 159 // the following functions delete the C++ objects (the window itself 160 // or its children) as well as the GUI windows and normally should 161 // never be used directly 162 163 // delete window unconditionally (dangerous!), returns true if ok 164 virtual bool Destroy(); 165 // delete all children of this window, returns true if ok 166 bool DestroyChildren(); 167 168 // is the window being deleted? 169 bool IsBeingDeleted() const { return m_isBeingDeleted; } 170 171 // window attributes 172 // ----------------- 173 174 // label is just the same as the title (but for, e.g., buttons it 175 // makes more sense to speak about labels), title access 176 // is available from wxTLW classes only (frames, dialogs) 177 virtual void SetLabel(const wxString& label) = 0; 178 virtual wxString GetLabel() const = 0; 179 180 // the window name is used for ressource setting in X, it is not the 181 // same as the window title/label 182 virtual void SetName( const wxString &name ) { m_windowName = name; } 183 virtual wxString GetName() const { return m_windowName; } 184 185 // sets the window variant, calls internally DoSetVariant if variant 186 // has changed 187 void SetWindowVariant(wxWindowVariant variant); 188 wxWindowVariant GetWindowVariant() const { return m_windowVariant; } 189 190 191 // window id uniquely identifies the window among its siblings unless 192 // it is wxID_ANY which means "don't care" 193 void SetId( wxWindowID winid ) { m_windowId = winid; } 194 wxWindowID GetId() const { return m_windowId; } 195 196 // get or change the layout direction (LTR or RTL) for this window, 197 // wxLayout_Default is returned if layout direction is not supported 198 virtual wxLayoutDirection GetLayoutDirection() const 199 { return wxLayout_Default; } 200 virtual void SetLayoutDirection(wxLayoutDirection WXUNUSED(dir)) 201 { } 202 203 // mirror coordinates for RTL layout if this window uses it and if the 204 // mirroring is not done automatically like Win32 205 virtual wxCoord AdjustForLayoutDirection(wxCoord x, 206 wxCoord width, 207 wxCoord widthTotal) const; 208 209 // generate a control id for the controls which were not given one by 210 // user 211 static int NewControlId() { return --ms_lastControlId; } 212 // get the id of the control following the one with the given 213 // (autogenerated) id 214 static int NextControlId(int winid) { return winid - 1; } 215 // get the id of the control preceding the one with the given 216 // (autogenerated) id 217 static int PrevControlId(int winid) { return winid + 1; } 218 219 // moving/resizing 220 // --------------- 221 222 // set the window size and/or position 223 void SetSize( int x, int y, int width, int height, 224 int sizeFlags = wxSIZE_AUTO ) 225 { DoSetSize(x, y, width, height, sizeFlags); } 226 227 void SetSize( int width, int height ) 228 { DoSetSize( wxDefaultCoord, wxDefaultCoord, width, height, wxSIZE_USE_EXISTING ); } 229 230 void SetSize( const wxSize& size ) 231 { SetSize( size.x, size.y); } 232 233 void SetSize(const wxRect& rect, int sizeFlags = wxSIZE_AUTO) 234 { DoSetSize(rect.x, rect.y, rect.width, rect.height, sizeFlags); } 235 236 void Move(int x, int y, int flags = wxSIZE_USE_EXISTING) 237 { DoSetSize(x, y, wxDefaultCoord, wxDefaultCoord, flags); } 238 239 void Move(const wxPoint& pt, int flags = wxSIZE_USE_EXISTING) 240 { Move(pt.x, pt.y, flags); } 241 242 void SetPosition(const wxPoint& pt) { Move(pt); } 243 244 // Z-order 245 virtual void Raise() = 0; 246 virtual void Lower() = 0; 247 248 // client size is the size of area available for subwindows 249 void SetClientSize( int width, int height ) 250 { DoSetClientSize(width, height); } 251 252 void SetClientSize( const wxSize& size ) 253 { DoSetClientSize(size.x, size.y); } 254 255 void SetClientSize(const wxRect& rect) 256 { SetClientSize( rect.width, rect.height ); } 257 258 // get the window position (pointers may be NULL): notice that it is in 259 // client coordinates for child windows and screen coordinates for the 260 // top level ones, use GetScreenPosition() if you need screen 261 // coordinates for all kinds of windows 262 void GetPosition( int *x, int *y ) const { DoGetPosition(x, y); } 263 wxPoint GetPosition() const 264 { 265 int x, y; 266 DoGetPosition(&x, &y); 267 268 return wxPoint(x, y); 269 } 270 271 // get the window position in screen coordinates 272 void GetScreenPosition(int *x, int *y) const { DoGetScreenPosition(x, y); } 273 wxPoint GetScreenPosition() const 274 { 275 int x, y; 276 DoGetScreenPosition(&x, &y); 277 278 return wxPoint(x, y); 279 } 280 281 // get the window size (pointers may be NULL) 282 void GetSize( int *w, int *h ) const { DoGetSize(w, h); } 283 wxSize GetSize() const 284 { 285 int w, h; 286 DoGetSize(& w, & h); 287 return wxSize(w, h); 288 } 289 290 void GetClientSize( int *w, int *h ) const { DoGetClientSize(w, h); } 291 wxSize GetClientSize() const 292 { 293 int w, h; 294 DoGetClientSize(&w, &h); 295 296 return wxSize(w, h); 297 } 298 299 // get the position and size at once 300 wxRect GetRect() const 301 { 302 int x, y, w, h; 303 GetPosition(&x, &y); 304 GetSize(&w, &h); 305 306 return wxRect(x, y, w, h); 307 } 308 309 wxRect GetScreenRect() const 310 { 311 int x, y, w, h; 312 GetScreenPosition(&x, &y); 313 GetSize(&w, &h); 314 315 return wxRect(x, y, w, h); 316 } 317 318 // get the origin of the client area of the window relative to the 319 // window top left corner (the client area may be shifted because of 320 // the borders, scrollbars, other decorations...) 321 virtual wxPoint GetClientAreaOrigin() const; 322 323 // get the client rectangle in window (i.e. client) coordinates 324 wxRect GetClientRect() const 325 { 326 return wxRect(GetClientAreaOrigin(), GetClientSize()); 327 } 328 329#if wxABI_VERSION >= 20808 330 // client<->window size conversion 331 wxSize ClientToWindowSize(const wxSize& size) const; 332 wxSize WindowToClientSize(const wxSize& size) const; 333#endif 334 335 // get the size best suited for the window (in fact, minimal 336 // acceptable size using which it will still look "nice" in 337 // most situations) 338 wxSize GetBestSize() const 339 { 340 if (m_bestSizeCache.IsFullySpecified()) 341 return m_bestSizeCache; 342 return DoGetBestSize(); 343 } 344 void GetBestSize(int *w, int *h) const 345 { 346 wxSize s = GetBestSize(); 347 if ( w ) 348 *w = s.x; 349 if ( h ) 350 *h = s.y; 351 } 352 353 void SetScrollHelper( wxScrollHelper *sh ) { m_scrollHelper = sh; } 354 wxScrollHelper *GetScrollHelper() { return m_scrollHelper; } 355 356 // reset the cached best size value so it will be recalculated the 357 // next time it is needed. 358 void InvalidateBestSize(); 359 void CacheBestSize(const wxSize& size) const 360 { wxConstCast(this, wxWindowBase)->m_bestSizeCache = size; } 361 362 363 // This function will merge the window's best size into the window's 364 // minimum size, giving priority to the min size components, and 365 // returns the results. 366 wxSize GetEffectiveMinSize() const; 367 wxDEPRECATED( wxSize GetBestFittingSize() const ); // replaced by GetEffectiveMinSize 368 wxDEPRECATED( wxSize GetAdjustedMinSize() const ); // replaced by GetEffectiveMinSize 369 370 // A 'Smart' SetSize that will fill in default size values with 'best' 371 // size. Sets the minsize to what was passed in. 372 void SetInitialSize(const wxSize& size=wxDefaultSize); 373 wxDEPRECATED( void SetBestFittingSize(const wxSize& size=wxDefaultSize) ); // replaced by SetInitialSize 374 375 376 // the generic centre function - centers the window on parent by` 377 // default or on screen if it doesn't have parent or 378 // wxCENTER_ON_SCREEN flag is given 379 void Centre(int dir = wxBOTH) { DoCentre(dir); } 380 void Center(int dir = wxBOTH) { DoCentre(dir); } 381 382 // centre with respect to the the parent window 383 void CentreOnParent(int dir = wxBOTH) { DoCentre(dir); } 384 void CenterOnParent(int dir = wxBOTH) { CentreOnParent(dir); } 385 386 // set window size to wrap around its children 387 virtual void Fit(); 388 389 // set virtual size to satisfy children 390 virtual void FitInside(); 391 392 393 // SetSizeHints is actually for setting the size hints 394 // for the wxTLW for a Window Manager - hence the name - 395 // and it is therefore overridden in wxTLW to do that. 396 // In wxWindow(Base), it has (unfortunately) been abused 397 // to mean the same as SetMinSize() and SetMaxSize(). 398 399 virtual void SetSizeHints( int minW, int minH, 400 int maxW = wxDefaultCoord, int maxH = wxDefaultCoord, 401 int incW = wxDefaultCoord, int incH = wxDefaultCoord ) 402 { DoSetSizeHints(minW, minH, maxW, maxH, incW, incH); } 403 404 void SetSizeHints( const wxSize& minSize, 405 const wxSize& maxSize=wxDefaultSize, 406 const wxSize& incSize=wxDefaultSize) 407 { DoSetSizeHints(minSize.x, minSize.y, maxSize.x, maxSize.y, incSize.x, incSize.y); } 408 409 virtual void DoSetSizeHints( int minW, int minH, 410 int maxW, int maxH, 411 int incW, int incH ); 412 413 // Methods for setting virtual size hints 414 // FIXME: What are virtual size hints? 415 416 virtual void SetVirtualSizeHints( int minW, int minH, 417 int maxW = wxDefaultCoord, int maxH = wxDefaultCoord ); 418 void SetVirtualSizeHints( const wxSize& minSize, 419 const wxSize& maxSize=wxDefaultSize) 420 { 421 SetVirtualSizeHints(minSize.x, minSize.y, maxSize.x, maxSize.y); 422 } 423 424 425 // Call these to override what GetBestSize() returns. This 426 // method is only virtual because it is overriden in wxTLW 427 // as a different API for SetSizeHints(). 428 virtual void SetMinSize(const wxSize& minSize) { m_minWidth = minSize.x; m_minHeight = minSize.y; } 429 virtual void SetMaxSize(const wxSize& maxSize) { m_maxWidth = maxSize.x; m_maxHeight = maxSize.y; } 430 431 // Override these methods to impose restrictions on min/max size. 432 // The easier way is to call SetMinSize() and SetMaxSize() which 433 // will have the same effect. Doing both is non-sense. 434 virtual wxSize GetMinSize() const { return wxSize(m_minWidth, m_minHeight); } 435 virtual wxSize GetMaxSize() const { return wxSize(m_maxWidth, m_maxHeight); } 436 437 // Get the min and max values one by one 438 int GetMinWidth() const { return GetMinSize().x; } 439 int GetMinHeight() const { return GetMinSize().y; } 440 int GetMaxWidth() const { return GetMaxSize().x; } 441 int GetMaxHeight() const { return GetMaxSize().y; } 442 443 444 // Methods for accessing the virtual size of a window. For most 445 // windows this is just the client area of the window, but for 446 // some like scrolled windows it is more or less independent of 447 // the screen window size. You may override the DoXXXVirtual 448 // methods below for classes where that is is the case. 449 450 void SetVirtualSize( const wxSize &size ) { DoSetVirtualSize( size.x, size.y ); } 451 void SetVirtualSize( int x, int y ) { DoSetVirtualSize( x, y ); } 452 453 wxSize GetVirtualSize() const { return DoGetVirtualSize(); } 454 void GetVirtualSize( int *x, int *y ) const 455 { 456 wxSize s( DoGetVirtualSize() ); 457 458 if( x ) 459 *x = s.GetWidth(); 460 if( y ) 461 *y = s.GetHeight(); 462 } 463 464 // Override these methods for windows that have a virtual size 465 // independent of their client size. eg. the virtual area of a 466 // wxScrolledWindow. 467 468 virtual void DoSetVirtualSize( int x, int y ); 469 virtual wxSize DoGetVirtualSize() const; 470 471 // Return the largest of ClientSize and BestSize (as determined 472 // by a sizer, interior children, or other means) 473 474 virtual wxSize GetBestVirtualSize() const 475 { 476 wxSize client( GetClientSize() ); 477 wxSize best( GetBestSize() ); 478 479 return wxSize( wxMax( client.x, best.x ), wxMax( client.y, best.y ) ); 480 } 481 482 // return the size of the left/right and top/bottom borders in x and y 483 // components of the result respectively 484 virtual wxSize GetWindowBorderSize() const; 485 486 487 // window state 488 // ------------ 489 490 // returns true if window was shown/hidden, false if the nothing was 491 // done (window was already shown/hidden) 492 virtual bool Show( bool show = true ); 493 bool Hide() { return Show(false); } 494 495 // returns true if window was enabled/disabled, false if nothing done 496 virtual bool Enable( bool enable = true ); 497 bool Disable() { return Enable(false); } 498 499 virtual bool IsShown() const { return m_isShown; } 500 virtual bool IsEnabled() const { return m_isEnabled; } 501 502 // returns true if the window is visible, i.e. IsShown() returns true 503 // if called on it and all its parents up to the first TLW 504 virtual bool IsShownOnScreen() const; 505 506 // get/set window style (setting style won't update the window and so 507 // is only useful for internal usage) 508 virtual void SetWindowStyleFlag( long style ) { m_windowStyle = style; } 509 virtual long GetWindowStyleFlag() const { return m_windowStyle; } 510 511 // just some (somewhat shorter) synonims 512 void SetWindowStyle( long style ) { SetWindowStyleFlag(style); } 513 long GetWindowStyle() const { return GetWindowStyleFlag(); } 514 515 // check if the flag is set 516 bool HasFlag(int flag) const { return (m_windowStyle & flag) != 0; } 517 virtual bool IsRetained() const { return HasFlag(wxRETAINED); } 518 519 // turn the flag on if it had been turned off before and vice versa, 520 // return true if the flag is currently turned on 521 bool ToggleWindowStyle(int flag); 522 523 // extra style: the less often used style bits which can't be set with 524 // SetWindowStyleFlag() 525 virtual void SetExtraStyle(long exStyle) { m_exStyle = exStyle; } 526 long GetExtraStyle() const { return m_exStyle; } 527 528 // make the window modal (all other windows unresponsive) 529 virtual void MakeModal(bool modal = true); 530 531 532 // (primitive) theming support 533 // --------------------------- 534 535 virtual void SetThemeEnabled(bool enableTheme) { m_themeEnabled = enableTheme; } 536 virtual bool GetThemeEnabled() const { return m_themeEnabled; } 537 538 539 // focus and keyboard handling 540 // --------------------------- 541 542 // set focus to this window 543 virtual void SetFocus() = 0; 544 545 // set focus to this window as the result of a keyboard action 546 virtual void SetFocusFromKbd() { SetFocus(); } 547 548 // return the window which currently has the focus or NULL 549 static wxWindow *FindFocus(); 550 551 static wxWindow *DoFindFocus() /* = 0: implement in derived classes */; 552 553 // can this window have focus? 554 virtual bool AcceptsFocus() const { return IsShown() && IsEnabled(); } 555 556 // can this window be given focus by keyboard navigation? if not, the 557 // only way to give it focus (provided it accepts it at all) is to 558 // click it 559 virtual bool AcceptsFocusFromKeyboard() const { return AcceptsFocus(); } 560 561 // navigates in the specified direction by sending a wxNavigationKeyEvent 562 virtual bool Navigate(int flags = wxNavigationKeyEvent::IsForward); 563 564 // move this window just before/after the specified one in tab order 565 // (the other window must be our sibling!) 566 void MoveBeforeInTabOrder(wxWindow *win) 567 { DoMoveInTabOrder(win, MoveBefore); } 568 void MoveAfterInTabOrder(wxWindow *win) 569 { DoMoveInTabOrder(win, MoveAfter); } 570 571 572 // parent/children relations 573 // ------------------------- 574 575 // get the list of children 576 const wxWindowList& GetChildren() const { return m_children; } 577 wxWindowList& GetChildren() { return m_children; } 578 579 // needed just for extended runtime 580 const wxWindowList& GetWindowChildren() const { return GetChildren() ; } 581 582#if wxABI_VERSION >= 20808 583 // get the window before/after this one in the parents children list, 584 // returns NULL if this is the first/last window 585 wxWindow *GetPrevSibling() const { return DoGetSibling(MoveBefore); } 586 wxWindow *GetNextSibling() const { return DoGetSibling(MoveAfter); } 587#endif // wx 2.8.8+ 588 589 // get the parent or the parent of the parent 590 wxWindow *GetParent() const { return m_parent; } 591 inline wxWindow *GetGrandParent() const; 592 593 // is this window a top level one? 594 virtual bool IsTopLevel() const; 595 596 // it doesn't really change parent, use Reparent() instead 597 void SetParent( wxWindowBase *parent ) { m_parent = (wxWindow *)parent; } 598 // change the real parent of this window, return true if the parent 599 // was changed, false otherwise (error or newParent == oldParent) 600 virtual bool Reparent( wxWindowBase *newParent ); 601 602 // implementation mostly 603 virtual void AddChild( wxWindowBase *child ); 604 virtual void RemoveChild( wxWindowBase *child ); 605 606 // looking for windows 607 // ------------------- 608 609 // find window among the descendants of this one either by id or by 610 // name (return NULL if not found) 611 wxWindow *FindWindow(long winid) const; 612 wxWindow *FindWindow(const wxString& name) const; 613 614 // Find a window among any window (all return NULL if not found) 615 static wxWindow *FindWindowById( long winid, const wxWindow *parent = NULL ); 616 static wxWindow *FindWindowByName( const wxString& name, 617 const wxWindow *parent = NULL ); 618 static wxWindow *FindWindowByLabel( const wxString& label, 619 const wxWindow *parent = NULL ); 620 621 // event handler stuff 622 // ------------------- 623 624 // get the current event handler 625 wxEvtHandler *GetEventHandler() const { return m_eventHandler; } 626 627 // replace the event handler (allows to completely subclass the 628 // window) 629 void SetEventHandler( wxEvtHandler *handler ) { m_eventHandler = handler; } 630 631 // push/pop event handler: allows to chain a custom event handler to 632 // alreasy existing ones 633 void PushEventHandler( wxEvtHandler *handler ); 634 wxEvtHandler *PopEventHandler( bool deleteHandler = false ); 635 636 // find the given handler in the event handler chain and remove (but 637 // not delete) it from the event handler chain, return true if it was 638 // found and false otherwise (this also results in an assert failure so 639 // this function should only be called when the handler is supposed to 640 // be there) 641 bool RemoveEventHandler(wxEvtHandler *handler); 642 643 // validators 644 // ---------- 645 646#if wxUSE_VALIDATORS 647 // a window may have an associated validator which is used to control 648 // user input 649 virtual void SetValidator( const wxValidator &validator ); 650 virtual wxValidator *GetValidator() { return m_windowValidator; } 651#endif // wxUSE_VALIDATORS 652 653 654 // dialog oriented functions 655 // ------------------------- 656 657 // validate the correctness of input, return true if ok 658 virtual bool Validate(); 659 660 // transfer data between internal and GUI representations 661 virtual bool TransferDataToWindow(); 662 virtual bool TransferDataFromWindow(); 663 664 virtual void InitDialog(); 665 666#if wxUSE_ACCEL 667 // accelerators 668 // ------------ 669 virtual void SetAcceleratorTable( const wxAcceleratorTable& accel ) 670 { m_acceleratorTable = accel; } 671 wxAcceleratorTable *GetAcceleratorTable() 672 { return &m_acceleratorTable; } 673 674#endif // wxUSE_ACCEL 675 676#if wxUSE_HOTKEY 677 // hot keys (system wide accelerators) 678 // ----------------------------------- 679 680 virtual bool RegisterHotKey(int hotkeyId, int modifiers, int keycode); 681 virtual bool UnregisterHotKey(int hotkeyId); 682#endif // wxUSE_HOTKEY 683 684 685 // dialog units translations 686 // ------------------------- 687 688 wxPoint ConvertPixelsToDialog( const wxPoint& pt ); 689 wxPoint ConvertDialogToPixels( const wxPoint& pt ); 690 wxSize ConvertPixelsToDialog( const wxSize& sz ) 691 { 692 wxPoint pt(ConvertPixelsToDialog(wxPoint(sz.x, sz.y))); 693 694 return wxSize(pt.x, pt.y); 695 } 696 697 wxSize ConvertDialogToPixels( const wxSize& sz ) 698 { 699 wxPoint pt(ConvertDialogToPixels(wxPoint(sz.x, sz.y))); 700 701 return wxSize(pt.x, pt.y); 702 } 703 704 // mouse functions 705 // --------------- 706 707 // move the mouse to the specified position 708 virtual void WarpPointer(int x, int y) = 0; 709 710 // start or end mouse capture, these functions maintain the stack of 711 // windows having captured the mouse and after calling ReleaseMouse() 712 // the mouse is not released but returns to the window which had had 713 // captured it previously (if any) 714 void CaptureMouse(); 715 void ReleaseMouse(); 716 717 // get the window which currently captures the mouse or NULL 718 static wxWindow *GetCapture(); 719 720 // does this window have the capture? 721 virtual bool HasCapture() const 722 { return (wxWindow *)this == GetCapture(); } 723 724 // painting the window 725 // ------------------- 726 727 // mark the specified rectangle (or the whole window) as "dirty" so it 728 // will be repainted 729 virtual void Refresh( bool eraseBackground = true, 730 const wxRect *rect = (const wxRect *) NULL ) = 0; 731 732 // a less awkward wrapper for Refresh 733 void RefreshRect(const wxRect& rect, bool eraseBackground = true) 734 { 735 Refresh(eraseBackground, &rect); 736 } 737 738 // repaint all invalid areas of the window immediately 739 virtual void Update() { } 740 741 // clear the window background 742 virtual void ClearBackground(); 743 744 // freeze the window: don't redraw it until it is thawed 745 virtual void Freeze() { } 746 747 // thaw the window: redraw it after it had been frozen 748 virtual void Thaw() { } 749 750 // return true if window had been frozen and not unthawed yet 751 virtual bool IsFrozen() const { return false; } 752 753 // adjust DC for drawing on this window 754 virtual void PrepareDC( wxDC & WXUNUSED(dc) ) { } 755 756 // return true if the window contents is double buffered by the system 757 virtual bool IsDoubleBuffered() const { return false; } 758 759 // the update region of the window contains the areas which must be 760 // repainted by the program 761 const wxRegion& GetUpdateRegion() const { return m_updateRegion; } 762 wxRegion& GetUpdateRegion() { return m_updateRegion; } 763 764 // get the update rectangleregion bounding box in client coords 765 wxRect GetUpdateClientRect() const; 766 767 // these functions verify whether the given point/rectangle belongs to 768 // (or at least intersects with) the update region 769 virtual bool DoIsExposed( int x, int y ) const; 770 virtual bool DoIsExposed( int x, int y, int w, int h ) const; 771 772 bool IsExposed( int x, int y ) const 773 { return DoIsExposed(x, y); } 774 bool IsExposed( int x, int y, int w, int h ) const 775 { return DoIsExposed(x, y, w, h); } 776 bool IsExposed( const wxPoint& pt ) const 777 { return DoIsExposed(pt.x, pt.y); } 778 bool IsExposed( const wxRect& rect ) const 779 { return DoIsExposed(rect.x, rect.y, rect.width, rect.height); } 780 781 // colours, fonts and cursors 782 // -------------------------- 783 784 // get the default attributes for the controls of this class: we 785 // provide a virtual function which can be used to query the default 786 // attributes of an existing control and a static function which can 787 // be used even when no existing object of the given class is 788 // available, but which won't return any styles specific to this 789 // particular control, of course (e.g. "Ok" button might have 790 // different -- bold for example -- font) 791 virtual wxVisualAttributes GetDefaultAttributes() const 792 { 793 return GetClassDefaultAttributes(GetWindowVariant()); 794 } 795 796 static wxVisualAttributes 797 GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL); 798 799 // set/retrieve the window colours (system defaults are used by 800 // default): SetXXX() functions return true if colour was changed, 801 // SetDefaultXXX() reset the "m_inheritXXX" flag after setting the 802 // value to prevent it from being inherited by our children 803 virtual bool SetBackgroundColour(const wxColour& colour); 804 void SetOwnBackgroundColour(const wxColour& colour) 805 { 806 if ( SetBackgroundColour(colour) ) 807 m_inheritBgCol = false; 808 } 809 wxColour GetBackgroundColour() const; 810 bool InheritsBackgroundColour() const 811 { 812 return m_inheritBgCol; 813 } 814 bool UseBgCol() const 815 { 816 return m_hasBgCol; 817 } 818 819 virtual bool SetForegroundColour(const wxColour& colour); 820 void SetOwnForegroundColour(const wxColour& colour) 821 { 822 if ( SetForegroundColour(colour) ) 823 m_inheritFgCol = false; 824 } 825 wxColour GetForegroundColour() const; 826 827 // Set/get the background style. 828 // Pass one of wxBG_STYLE_SYSTEM, wxBG_STYLE_COLOUR, wxBG_STYLE_CUSTOM 829 virtual bool SetBackgroundStyle(wxBackgroundStyle style) { m_backgroundStyle = style; return true; } 830 virtual wxBackgroundStyle GetBackgroundStyle() const { return m_backgroundStyle; } 831 832 // returns true if the control has "transparent" areas such as a 833 // wxStaticText and wxCheckBox and the background should be adapted 834 // from a parent window 835 virtual bool HasTransparentBackground() { return false; } 836 837 // set/retrieve the font for the window (SetFont() returns true if the 838 // font really changed) 839 virtual bool SetFont(const wxFont& font) = 0; 840 void SetOwnFont(const wxFont& font) 841 { 842 if ( SetFont(font) ) 843 m_inheritFont = false; 844 } 845 wxFont GetFont() const; 846 847 // set/retrieve the cursor for this window (SetCursor() returns true 848 // if the cursor was really changed) 849 virtual bool SetCursor( const wxCursor &cursor ); 850 const wxCursor& GetCursor() const { return m_cursor; } 851 852#if wxUSE_CARET 853 // associate a caret with the window 854 void SetCaret(wxCaret *caret); 855 // get the current caret (may be NULL) 856 wxCaret *GetCaret() const { return m_caret; } 857#endif // wxUSE_CARET 858 859 // get the (average) character size for the current font 860 virtual int GetCharHeight() const = 0; 861 virtual int GetCharWidth() const = 0; 862 863 // get the width/height/... of the text using current or specified 864 // font 865 virtual void GetTextExtent(const wxString& string, 866 int *x, int *y, 867 int *descent = (int *) NULL, 868 int *externalLeading = (int *) NULL, 869 const wxFont *theFont = (const wxFont *) NULL) 870 const = 0; 871 872 // client <-> screen coords 873 // ------------------------ 874 875 // translate to/from screen/client coordinates (pointers may be NULL) 876 void ClientToScreen( int *x, int *y ) const 877 { DoClientToScreen(x, y); } 878 void ScreenToClient( int *x, int *y ) const 879 { DoScreenToClient(x, y); } 880 881 // wxPoint interface to do the same thing 882 wxPoint ClientToScreen(const wxPoint& pt) const 883 { 884 int x = pt.x, y = pt.y; 885 DoClientToScreen(&x, &y); 886 887 return wxPoint(x, y); 888 } 889 890 wxPoint ScreenToClient(const wxPoint& pt) const 891 { 892 int x = pt.x, y = pt.y; 893 DoScreenToClient(&x, &y); 894 895 return wxPoint(x, y); 896 } 897 898 // test where the given (in client coords) point lies 899 wxHitTest HitTest(wxCoord x, wxCoord y) const 900 { return DoHitTest(x, y); } 901 902 wxHitTest HitTest(const wxPoint& pt) const 903 { return DoHitTest(pt.x, pt.y); } 904 905 // misc 906 // ---- 907 908 // get the window border style from the given flags: this is different from 909 // simply doing flags & wxBORDER_MASK because it uses GetDefaultBorder() to 910 // translate wxBORDER_DEFAULT to something reasonable 911 wxBorder GetBorder(long flags) const; 912 913 // get border for the flags of this window 914 wxBorder GetBorder() const { return GetBorder(GetWindowStyleFlag()); } 915 916 // send wxUpdateUIEvents to this window, and children if recurse is true 917 virtual void UpdateWindowUI(long flags = wxUPDATE_UI_NONE); 918 919 // do the window-specific processing after processing the update event 920 virtual void DoUpdateWindowUI(wxUpdateUIEvent& event) ; 921 922#if wxUSE_MENUS 923 bool PopupMenu(wxMenu *menu, const wxPoint& pos = wxDefaultPosition) 924 { return DoPopupMenu(menu, pos.x, pos.y); } 925 bool PopupMenu(wxMenu *menu, int x, int y) 926 { return DoPopupMenu(menu, x, y); } 927#endif // wxUSE_MENUS 928 929 // override this method to return true for controls having multiple pages 930 virtual bool HasMultiplePages() const { return false; } 931 932 933 // scrollbars 934 // ---------- 935 936 // does the window have the scrollbar for this orientation? 937 bool HasScrollbar(int orient) const 938 { 939 return (m_windowStyle & 940 (orient == wxHORIZONTAL ? wxHSCROLL : wxVSCROLL)) != 0; 941 } 942 943 // configure the window scrollbars 944 virtual void SetScrollbar( int orient, 945 int pos, 946 int thumbvisible, 947 int range, 948 bool refresh = true ) = 0; 949 virtual void SetScrollPos( int orient, int pos, bool refresh = true ) = 0; 950 virtual int GetScrollPos( int orient ) const = 0; 951 virtual int GetScrollThumb( int orient ) const = 0; 952 virtual int GetScrollRange( int orient ) const = 0; 953 954 // scroll window to the specified position 955 virtual void ScrollWindow( int dx, int dy, 956 const wxRect* rect = (wxRect *) NULL ) = 0; 957 958 // scrolls window by line/page: note that not all controls support this 959 // 960 // return true if the position changed, false otherwise 961 virtual bool ScrollLines(int WXUNUSED(lines)) { return false; } 962 virtual bool ScrollPages(int WXUNUSED(pages)) { return false; } 963 964 // convenient wrappers for ScrollLines/Pages 965 bool LineUp() { return ScrollLines(-1); } 966 bool LineDown() { return ScrollLines(1); } 967 bool PageUp() { return ScrollPages(-1); } 968 bool PageDown() { return ScrollPages(1); } 969 970 // context-sensitive help 971 // ---------------------- 972 973 // these are the convenience functions wrapping wxHelpProvider methods 974 975#if wxUSE_HELP 976 // associate this help text with this window 977 void SetHelpText(const wxString& text); 978 // associate this help text with all windows with the same id as this 979 // one 980 void SetHelpTextForId(const wxString& text); 981 // get the help string associated with the given position in this window 982 // 983 // notice that pt may be invalid if event origin is keyboard or unknown 984 // and this method should return the global window help text then 985 virtual wxString GetHelpTextAtPoint(const wxPoint& pt, 986 wxHelpEvent::Origin origin) const; 987 // returns the position-independent help text 988 wxString GetHelpText() const 989 { 990 return GetHelpTextAtPoint(wxDefaultPosition, wxHelpEvent::Origin_Unknown); 991 } 992 993#else // !wxUSE_HELP 994 // silently ignore SetHelpText() calls 995 void SetHelpText(const wxString& WXUNUSED(text)) { } 996 void SetHelpTextForId(const wxString& WXUNUSED(text)) { } 997#endif // wxUSE_HELP 998 999 // tooltips 1000 // -------- 1001 1002#if wxUSE_TOOLTIPS 1003 // the easiest way to set a tooltip for a window is to use this method 1004 void SetToolTip( const wxString &tip ); 1005 // attach a tooltip to the window 1006 void SetToolTip( wxToolTip *tip ) { DoSetToolTip(tip); } 1007#if wxABI_VERSION >= 20809 1008 // more readable synonym for SetToolTip(NULL) 1009 void UnsetToolTip() { SetToolTip(NULL); } 1010#endif // wxABI_VERSION >= 2.8.9 1011 // get the associated tooltip or NULL if none 1012 wxToolTip* GetToolTip() const { return m_tooltip; } 1013 wxString GetToolTipText() const ; 1014#else // !wxUSE_TOOLTIPS 1015 // make it much easier to compile apps in an environment 1016 // that doesn't support tooltips, such as PocketPC 1017 void SetToolTip( const wxString & WXUNUSED(tip) ) {} 1018#if wxABI_VERSION >= 20809 1019 void UnsetToolTip() { } 1020#endif // wxABI_VERSION >= 2.8.9 1021#endif // wxUSE_TOOLTIPS/!wxUSE_TOOLTIPS 1022 1023 // drag and drop 1024 // ------------- 1025#if wxUSE_DRAG_AND_DROP 1026 // set/retrieve the drop target associated with this window (may be 1027 // NULL; it's owned by the window and will be deleted by it) 1028 virtual void SetDropTarget( wxDropTarget *dropTarget ) = 0; 1029 virtual wxDropTarget *GetDropTarget() const { return m_dropTarget; } 1030 1031#ifndef __WXMSW__ // MSW version is in msw/window.h 1032#if wxABI_VERSION >= 20810 1033 // Accept files for dragging 1034 void DragAcceptFiles(bool accept); 1035#endif // wxABI_VERSION >= 20810 1036#endif // !__WXMSW__ 1037 1038#endif // wxUSE_DRAG_AND_DROP 1039 1040 // constraints and sizers 1041 // ---------------------- 1042#if wxUSE_CONSTRAINTS 1043 // set the constraints for this window or retrieve them (may be NULL) 1044 void SetConstraints( wxLayoutConstraints *constraints ); 1045 wxLayoutConstraints *GetConstraints() const { return m_constraints; } 1046 1047 // implementation only 1048 void UnsetConstraints(wxLayoutConstraints *c); 1049 wxWindowList *GetConstraintsInvolvedIn() const 1050 { return m_constraintsInvolvedIn; } 1051 void AddConstraintReference(wxWindowBase *otherWin); 1052 void RemoveConstraintReference(wxWindowBase *otherWin); 1053 void DeleteRelatedConstraints(); 1054 void ResetConstraints(); 1055 1056 // these methods may be overridden for special layout algorithms 1057 virtual void SetConstraintSizes(bool recurse = true); 1058 virtual bool LayoutPhase1(int *noChanges); 1059 virtual bool LayoutPhase2(int *noChanges); 1060 virtual bool DoPhase(int phase); 1061 1062 // these methods are virtual but normally won't be overridden 1063 virtual void SetSizeConstraint(int x, int y, int w, int h); 1064 virtual void MoveConstraint(int x, int y); 1065 virtual void GetSizeConstraint(int *w, int *h) const ; 1066 virtual void GetClientSizeConstraint(int *w, int *h) const ; 1067 virtual void GetPositionConstraint(int *x, int *y) const ; 1068 1069#endif // wxUSE_CONSTRAINTS 1070 1071 // when using constraints or sizers, it makes sense to update 1072 // children positions automatically whenever the window is resized 1073 // - this is done if autoLayout is on 1074 void SetAutoLayout( bool autoLayout ) { m_autoLayout = autoLayout; } 1075 bool GetAutoLayout() const { return m_autoLayout; } 1076 1077 // lay out the window and its children 1078 virtual bool Layout(); 1079 1080 // sizers 1081 void SetSizer(wxSizer *sizer, bool deleteOld = true ); 1082 void SetSizerAndFit( wxSizer *sizer, bool deleteOld = true ); 1083 1084 wxSizer *GetSizer() const { return m_windowSizer; } 1085 1086 // Track if this window is a member of a sizer 1087 void SetContainingSizer(wxSizer* sizer); 1088 wxSizer *GetContainingSizer() const { return m_containingSizer; } 1089 1090 // accessibility 1091 // ---------------------- 1092#if wxUSE_ACCESSIBILITY 1093 // Override to create a specific accessible object. 1094 virtual wxAccessible* CreateAccessible(); 1095 1096 // Sets the accessible object. 1097 void SetAccessible(wxAccessible* accessible) ; 1098 1099 // Returns the accessible object. 1100 wxAccessible* GetAccessible() { return m_accessible; } 1101 1102 // Returns the accessible object, creating if necessary. 1103 wxAccessible* GetOrCreateAccessible() ; 1104#endif 1105 1106 1107 // Set window transparency if the platform supports it 1108 virtual bool SetTransparent(wxByte WXUNUSED(alpha)) { return false; } 1109 virtual bool CanSetTransparent() { return false; } 1110 1111 1112 // implementation 1113 // -------------- 1114 1115 // event handlers 1116 void OnSysColourChanged( wxSysColourChangedEvent& event ); 1117 void OnInitDialog( wxInitDialogEvent &event ); 1118 void OnMiddleClick( wxMouseEvent& event ); 1119#if wxUSE_HELP 1120 void OnHelp(wxHelpEvent& event); 1121#endif // wxUSE_HELP 1122 1123 // virtual function for implementing internal idle 1124 // behaviour 1125 virtual void OnInternalIdle() {} 1126 1127 // call internal idle recursively 1128// void ProcessInternalIdle() ; 1129 1130 // get the handle of the window for the underlying window system: this 1131 // is only used for wxWin itself or for user code which wants to call 1132 // platform-specific APIs 1133 virtual WXWidget GetHandle() const = 0; 1134 // associate the window with a new native handle 1135 virtual void AssociateHandle(WXWidget WXUNUSED(handle)) { } 1136 // dissociate the current native handle from the window 1137 virtual void DissociateHandle() { } 1138 1139#if wxUSE_PALETTE 1140 // Store the palette used by DCs in wxWindow so that the dcs can share 1141 // a palette. And we can respond to palette messages. 1142 wxPalette GetPalette() const { return m_palette; } 1143 1144 // When palette is changed tell the DC to set the system palette to the 1145 // new one. 1146 void SetPalette(const wxPalette& pal); 1147 1148 // return true if we have a specific palette 1149 bool HasCustomPalette() const { return m_hasCustomPalette; } 1150 1151 // return the first parent window with a custom palette or NULL 1152 wxWindow *GetAncestorWithCustomPalette() const; 1153#endif // wxUSE_PALETTE 1154 1155 // inherit the parents visual attributes if they had been explicitly set 1156 // by the user (i.e. we don't inherit default attributes) and if we don't 1157 // have our own explicitly set 1158 virtual void InheritAttributes(); 1159 1160 // returns false from here if this window doesn't want to inherit the 1161 // parents colours even if InheritAttributes() would normally do it 1162 // 1163 // this just provides a simple way to customize InheritAttributes() 1164 // behaviour in the most common case 1165 virtual bool ShouldInheritColours() const { return false; } 1166 1167protected: 1168 // event handling specific to wxWindow 1169 virtual bool TryValidator(wxEvent& event); 1170 virtual bool TryParent(wxEvent& event); 1171 1172 enum MoveKind 1173 { 1174 MoveBefore, // insert before the given window 1175 MoveAfter // insert after the given window 1176 }; 1177 1178#if wxABI_VERSION >= 20808 1179 // common part of GetPrev/NextSibling() 1180 wxWindow *DoGetSibling(MoveKind order) const; 1181#endif // wx 2.8.8+ 1182 1183 // common part of MoveBefore/AfterInTabOrder() 1184 virtual void DoMoveInTabOrder(wxWindow *win, MoveKind move); 1185 1186#if wxUSE_CONSTRAINTS 1187 // satisfy the constraints for the windows but don't set the window sizes 1188 void SatisfyConstraints(); 1189#endif // wxUSE_CONSTRAINTS 1190 1191 // Send the wxWindowDestroyEvent 1192 void SendDestroyEvent(); 1193 1194 // returns the main window of composite control; this is the window 1195 // that FindFocus returns if the focus is in one of composite control's 1196 // windows 1197 virtual wxWindow *GetMainWindowOfCompositeControl() 1198 { return (wxWindow*)this; } 1199 1200 // the window id - a number which uniquely identifies a window among 1201 // its siblings unless it is wxID_ANY 1202 wxWindowID m_windowId; 1203 1204 // the parent window of this window (or NULL) and the list of the children 1205 // of this window 1206 wxWindow *m_parent; 1207 wxWindowList m_children; 1208 1209 // the minimal allowed size for the window (no minimal size if variable(s) 1210 // contain(s) wxDefaultCoord) 1211 int m_minWidth, 1212 m_minHeight, 1213 m_maxWidth, 1214 m_maxHeight; 1215 1216 // event handler for this window: usually is just 'this' but may be 1217 // changed with SetEventHandler() 1218 wxEvtHandler *m_eventHandler; 1219 1220#if wxUSE_VALIDATORS 1221 // associated validator or NULL if none 1222 wxValidator *m_windowValidator; 1223#endif // wxUSE_VALIDATORS 1224 1225#if wxUSE_DRAG_AND_DROP 1226 wxDropTarget *m_dropTarget; 1227#endif // wxUSE_DRAG_AND_DROP 1228 1229 // visual window attributes 1230 wxCursor m_cursor; 1231 wxFont m_font; // see m_hasFont 1232 wxColour m_backgroundColour, // m_hasBgCol 1233 m_foregroundColour; // m_hasFgCol 1234 1235#if wxUSE_CARET 1236 wxCaret *m_caret; 1237#endif // wxUSE_CARET 1238 1239 // the region which should be repainted in response to paint event 1240 wxRegion m_updateRegion; 1241 1242#if wxUSE_ACCEL 1243 // the accelerator table for the window which translates key strokes into 1244 // command events 1245 wxAcceleratorTable m_acceleratorTable; 1246#endif // wxUSE_ACCEL 1247 1248 // the tooltip for this window (may be NULL) 1249#if wxUSE_TOOLTIPS 1250 wxToolTip *m_tooltip; 1251#endif // wxUSE_TOOLTIPS 1252 1253 // constraints and sizers 1254#if wxUSE_CONSTRAINTS 1255 // the constraints for this window or NULL 1256 wxLayoutConstraints *m_constraints; 1257 1258 // constraints this window is involved in 1259 wxWindowList *m_constraintsInvolvedIn; 1260#endif // wxUSE_CONSTRAINTS 1261 1262 // this window's sizer 1263 wxSizer *m_windowSizer; 1264 1265 // The sizer this window is a member of, if any 1266 wxSizer *m_containingSizer; 1267 1268 // Layout() window automatically when its size changes? 1269 bool m_autoLayout:1; 1270 1271 // window state 1272 bool m_isShown:1; 1273 bool m_isEnabled:1; 1274 bool m_isBeingDeleted:1; 1275 1276 // was the window colours/font explicitly changed by user? 1277 bool m_hasBgCol:1; 1278 bool m_hasFgCol:1; 1279 bool m_hasFont:1; 1280 1281 // and should it be inherited by children? 1282 bool m_inheritBgCol:1; 1283 bool m_inheritFgCol:1; 1284 bool m_inheritFont:1; 1285 1286 // window attributes 1287 long m_windowStyle, 1288 m_exStyle; 1289 wxString m_windowName; 1290 bool m_themeEnabled; 1291 wxBackgroundStyle m_backgroundStyle; 1292#if wxUSE_PALETTE 1293 wxPalette m_palette; 1294 bool m_hasCustomPalette; 1295#endif // wxUSE_PALETTE 1296 1297#if wxUSE_ACCESSIBILITY 1298 wxAccessible* m_accessible; 1299#endif 1300 1301 // Virtual size (scrolling) 1302 wxSize m_virtualSize; 1303 1304 wxScrollHelper *m_scrollHelper; 1305 1306 int m_minVirtualWidth; // VirtualSizeHints 1307 int m_minVirtualHeight; 1308 int m_maxVirtualWidth; 1309 int m_maxVirtualHeight; 1310 1311 wxWindowVariant m_windowVariant ; 1312 1313 // override this to change the default (i.e. used when no style is 1314 // specified) border for the window class 1315 virtual wxBorder GetDefaultBorder() const; 1316 1317 // Get the default size for the new window if no explicit size given. TLWs 1318 // have their own default size so this is just for non top-level windows. 1319 static int WidthDefault(int w) { return w == wxDefaultCoord ? 20 : w; } 1320 static int HeightDefault(int h) { return h == wxDefaultCoord ? 20 : h; } 1321 1322 1323 // Used to save the results of DoGetBestSize so it doesn't need to be 1324 // recalculated each time the value is needed. 1325 wxSize m_bestSizeCache; 1326 1327 wxDEPRECATED( void SetBestSize(const wxSize& size) ); // use SetInitialSize 1328 wxDEPRECATED( virtual void SetInitialBestSize(const wxSize& size) ); // use SetInitialSize 1329 1330 1331 1332 // more pure virtual functions 1333 // --------------------------- 1334 1335 // NB: we must have DoSomething() function when Something() is an overloaded 1336 // method: indeed, we can't just have "virtual Something()" in case when 1337 // the function is overloaded because then we'd have to make virtual all 1338 // the variants (otherwise only the virtual function may be called on a 1339 // pointer to derived class according to C++ rules) which is, in 1340 // general, absolutely not needed. So instead we implement all 1341 // overloaded Something()s in terms of DoSomething() which will be the 1342 // only one to be virtual. 1343 1344 // coordinates translation 1345 virtual void DoClientToScreen( int *x, int *y ) const = 0; 1346 virtual void DoScreenToClient( int *x, int *y ) const = 0; 1347 1348 virtual wxHitTest DoHitTest(wxCoord x, wxCoord y) const; 1349 1350 // capture/release the mouse, used by Capture/ReleaseMouse() 1351 virtual void DoCaptureMouse() = 0; 1352 virtual void DoReleaseMouse() = 0; 1353 1354 // retrieve the position/size of the window 1355 virtual void DoGetPosition(int *x, int *y) const = 0; 1356 virtual void DoGetScreenPosition(int *x, int *y) const; 1357 virtual void DoGetSize(int *width, int *height) const = 0; 1358 virtual void DoGetClientSize(int *width, int *height) const = 0; 1359 1360 // get the size which best suits the window: for a control, it would be 1361 // the minimal size which doesn't truncate the control, for a panel - the 1362 // same size as it would have after a call to Fit() 1363 virtual wxSize DoGetBestSize() const; 1364 1365 // called from DoGetBestSize() to convert best virtual size (returned by 1366 // the window sizer) to the best size for the window itself; this is 1367 // overridden at wxScrolledWindow level to clump down virtual size to real 1368 virtual wxSize GetWindowSizeForVirtualSize(const wxSize& size) const 1369 { 1370 return size; 1371 } 1372 1373 // this is the virtual function to be overriden in any derived class which 1374 // wants to change how SetSize() or Move() works - it is called by all 1375 // versions of these functions in the base class 1376 virtual void DoSetSize(int x, int y, 1377 int width, int height, 1378 int sizeFlags = wxSIZE_AUTO) = 0; 1379 1380 // same as DoSetSize() for the client size 1381 virtual void DoSetClientSize(int width, int height) = 0; 1382 1383 // move the window to the specified location and resize it: this is called 1384 // from both DoSetSize() and DoSetClientSize() and would usually just 1385 // reposition this window except for composite controls which will want to 1386 // arrange themselves inside the given rectangle 1387 // 1388 // Important note: the coordinates passed to this method are in parent's 1389 // *window* coordinates and not parent's client coordinates (as the values 1390 // passed to DoSetSize and returned by DoGetPosition are)! 1391 virtual void DoMoveWindow(int x, int y, int width, int height) = 0; 1392 1393 // centre the window in the specified direction on parent, note that 1394 // wxCENTRE_ON_SCREEN shouldn't be specified here, it only makes sense for 1395 // TLWs 1396 virtual void DoCentre(int dir); 1397 1398#if wxUSE_TOOLTIPS 1399 virtual void DoSetToolTip( wxToolTip *tip ); 1400#endif // wxUSE_TOOLTIPS 1401 1402#if wxUSE_MENUS 1403 virtual bool DoPopupMenu(wxMenu *menu, int x, int y) = 0; 1404#endif // wxUSE_MENUS 1405 1406 // Makes an adjustment to the window position to make it relative to the 1407 // parents client area, e.g. if the parent is a frame with a toolbar, its 1408 // (0, 0) is just below the toolbar 1409 virtual void AdjustForParentClientOrigin(int& x, int& y, 1410 int sizeFlags = 0) const; 1411 1412 // implements the window variants 1413 virtual void DoSetWindowVariant( wxWindowVariant variant ) ; 1414 1415 // Must be called when mouse capture is lost to send 1416 // wxMouseCaptureLostEvent to windows on capture stack. 1417 static void NotifyCaptureLost(); 1418 1419private: 1420 // contains the last id generated by NewControlId 1421 static int ms_lastControlId; 1422 1423 // the stack of windows which have captured the mouse 1424 static struct WXDLLIMPEXP_FWD_CORE wxWindowNext *ms_winCaptureNext; 1425 // the window that currently has mouse capture 1426 static wxWindow *ms_winCaptureCurrent; 1427 // indicates if execution is inside CaptureMouse/ReleaseMouse 1428 static bool ms_winCaptureChanging; 1429 1430 DECLARE_ABSTRACT_CLASS(wxWindowBase) 1431 DECLARE_NO_COPY_CLASS(wxWindowBase) 1432 DECLARE_EVENT_TABLE() 1433}; 1434 1435 1436 1437// Inlines for some deprecated methods 1438inline wxSize wxWindowBase::GetBestFittingSize() const 1439{ 1440 return GetEffectiveMinSize(); 1441} 1442 1443inline void wxWindowBase::SetBestFittingSize(const wxSize& size) 1444{ 1445 SetInitialSize(size); 1446} 1447 1448inline void wxWindowBase::SetBestSize(const wxSize& size) 1449{ 1450 SetInitialSize(size); 1451} 1452 1453inline void wxWindowBase::SetInitialBestSize(const wxSize& size) 1454{ 1455 SetInitialSize(size); 1456} 1457 1458 1459// ---------------------------------------------------------------------------- 1460// now include the declaration of wxWindow class 1461// ---------------------------------------------------------------------------- 1462 1463// include the declaration of the platform-specific class 1464#if defined(__WXPALMOS__) 1465 #ifdef __WXUNIVERSAL__ 1466 #define wxWindowNative wxWindowPalm 1467 #else // !wxUniv 1468 #define wxWindowPalm wxWindow 1469 #endif // wxUniv/!wxUniv 1470 #include "wx/palmos/window.h" 1471#elif defined(__WXMSW__) 1472 #ifdef __WXUNIVERSAL__ 1473 #define wxWindowNative wxWindowMSW 1474 #else // !wxUniv 1475 #define wxWindowMSW wxWindow 1476 #endif // wxUniv/!wxUniv 1477 #include "wx/msw/window.h" 1478#elif defined(__WXMOTIF__) 1479 #include "wx/motif/window.h" 1480#elif defined(__WXGTK20__) 1481 #ifdef __WXUNIVERSAL__ 1482 #define wxWindowNative wxWindowGTK 1483 #else // !wxUniv 1484 #define wxWindowGTK wxWindow 1485 #endif // wxUniv 1486 #include "wx/gtk/window.h" 1487#elif defined(__WXGTK__) 1488 #ifdef __WXUNIVERSAL__ 1489 #define wxWindowNative wxWindowGTK 1490 #else // !wxUniv 1491 #define wxWindowGTK wxWindow 1492 #endif // wxUniv 1493 #include "wx/gtk1/window.h" 1494#elif defined(__WXX11__) 1495 #ifdef __WXUNIVERSAL__ 1496 #define wxWindowNative wxWindowX11 1497 #else // !wxUniv 1498 #define wxWindowX11 wxWindow 1499 #endif // wxUniv 1500 #include "wx/x11/window.h" 1501#elif defined(__WXMGL__) 1502 #define wxWindowNative wxWindowMGL 1503 #include "wx/mgl/window.h" 1504#elif defined(__WXDFB__) 1505 #define wxWindowNative wxWindowDFB 1506 #include "wx/dfb/window.h" 1507#elif defined(__WXMAC__) 1508 #ifdef __WXUNIVERSAL__ 1509 #define wxWindowNative wxWindowMac 1510 #else // !wxUniv 1511 #define wxWindowMac wxWindow 1512 #endif // wxUniv 1513 #include "wx/mac/window.h" 1514#elif defined(__WXCOCOA__) 1515 #ifdef __WXUNIVERSAL__ 1516 #define wxWindowNative wxWindowCocoa 1517 #else // !wxUniv 1518 #define wxWindowCocoa wxWindow 1519 #endif // wxUniv 1520 #include "wx/cocoa/window.h" 1521#elif defined(__WXPM__) 1522 #ifdef __WXUNIVERSAL__ 1523 #define wxWindowNative wxWindowOS2 1524 #else // !wxUniv 1525 #define wxWindowOS2 wxWindow 1526 #endif // wxUniv/!wxUniv 1527 #include "wx/os2/window.h" 1528#endif 1529 1530// for wxUniversal, we now derive the real wxWindow from wxWindow<platform>, 1531// for the native ports we already have defined it above 1532#if defined(__WXUNIVERSAL__) 1533 #ifndef wxWindowNative 1534 #error "wxWindowNative must be defined above!" 1535 #endif 1536 1537 #include "wx/univ/window.h" 1538#endif // wxUniv 1539 1540// ---------------------------------------------------------------------------- 1541// inline functions which couldn't be declared in the class body because of 1542// forward dependencies 1543// ---------------------------------------------------------------------------- 1544 1545inline wxWindow *wxWindowBase::GetGrandParent() const 1546{ 1547 return m_parent ? m_parent->GetParent() : (wxWindow *)NULL; 1548} 1549 1550// ---------------------------------------------------------------------------- 1551// global functions 1552// ---------------------------------------------------------------------------- 1553 1554// Find the wxWindow at the current mouse position, also returning the mouse 1555// position. 1556extern WXDLLEXPORT wxWindow* wxFindWindowAtPointer(wxPoint& pt); 1557 1558// Get the current mouse position. 1559extern WXDLLEXPORT wxPoint wxGetMousePosition(); 1560 1561// get the currently active window of this application or NULL 1562extern WXDLLEXPORT wxWindow *wxGetActiveWindow(); 1563 1564// get the (first) top level parent window 1565WXDLLEXPORT wxWindow* wxGetTopLevelParent(wxWindow *win); 1566 1567#if WXWIN_COMPATIBILITY_2_6 1568 // deprecated (doesn't start with 'wx' prefix), use wxWindow::NewControlId() 1569 wxDEPRECATED( int NewControlId() ); 1570 inline int NewControlId() { return wxWindowBase::NewControlId(); } 1571#endif // WXWIN_COMPATIBILITY_2_6 1572 1573#if wxUSE_ACCESSIBILITY 1574// ---------------------------------------------------------------------------- 1575// accessible object for windows 1576// ---------------------------------------------------------------------------- 1577 1578class WXDLLEXPORT wxWindowAccessible: public wxAccessible 1579{ 1580public: 1581 wxWindowAccessible(wxWindow* win): wxAccessible(win) { if (win) win->SetAccessible(this); } 1582 virtual ~wxWindowAccessible() {} 1583 1584// Overridables 1585 1586 // Can return either a child object, or an integer 1587 // representing the child element, starting from 1. 1588 virtual wxAccStatus HitTest(const wxPoint& pt, int* childId, wxAccessible** childObject); 1589 1590 // Returns the rectangle for this object (id = 0) or a child element (id > 0). 1591 virtual wxAccStatus GetLocation(wxRect& rect, int elementId); 1592 1593 // Navigates from fromId to toId/toObject. 1594 virtual wxAccStatus Navigate(wxNavDir navDir, int fromId, 1595 int* toId, wxAccessible** toObject); 1596 1597 // Gets the name of the specified object. 1598 virtual wxAccStatus GetName(int childId, wxString* name); 1599 1600 // Gets the number of children. 1601 virtual wxAccStatus GetChildCount(int* childCount); 1602 1603 // Gets the specified child (starting from 1). 1604 // If *child is NULL and return value is wxACC_OK, 1605 // this means that the child is a simple element and 1606 // not an accessible object. 1607 virtual wxAccStatus GetChild(int childId, wxAccessible** child); 1608 1609 // Gets the parent, or NULL. 1610 virtual wxAccStatus GetParent(wxAccessible** parent); 1611 1612 // Performs the default action. childId is 0 (the action for this object) 1613 // or > 0 (the action for a child). 1614 // Return wxACC_NOT_SUPPORTED if there is no default action for this 1615 // window (e.g. an edit control). 1616 virtual wxAccStatus DoDefaultAction(int childId); 1617 1618 // Gets the default action for this object (0) or > 0 (the action for a child). 1619 // Return wxACC_OK even if there is no action. actionName is the action, or the empty 1620 // string if there is no action. 1621 // The retrieved string describes the action that is performed on an object, 1622 // not what the object does as a result. For example, a toolbar button that prints 1623 // a document has a default action of "Press" rather than "Prints the current document." 1624 virtual wxAccStatus GetDefaultAction(int childId, wxString* actionName); 1625 1626 // Returns the description for this object or a child. 1627 virtual wxAccStatus GetDescription(int childId, wxString* description); 1628 1629 // Returns help text for this object or a child, similar to tooltip text. 1630 virtual wxAccStatus GetHelpText(int childId, wxString* helpText); 1631 1632 // Returns the keyboard shortcut for this object or child. 1633 // Return e.g. ALT+K 1634 virtual wxAccStatus GetKeyboardShortcut(int childId, wxString* shortcut); 1635 1636 // Returns a role constant. 1637 virtual wxAccStatus GetRole(int childId, wxAccRole* role); 1638 1639 // Returns a state constant. 1640 virtual wxAccStatus GetState(int childId, long* state); 1641 1642 // Returns a localized string representing the value for the object 1643 // or child. 1644 virtual wxAccStatus GetValue(int childId, wxString* strValue); 1645 1646 // Selects the object or child. 1647 virtual wxAccStatus Select(int childId, wxAccSelectionFlags selectFlags); 1648 1649 // Gets the window with the keyboard focus. 1650 // If childId is 0 and child is NULL, no object in 1651 // this subhierarchy has the focus. 1652 // If this object has the focus, child should be 'this'. 1653 virtual wxAccStatus GetFocus(int* childId, wxAccessible** child); 1654 1655#if wxUSE_VARIANT 1656 // Gets a variant representing the selected children 1657 // of this object. 1658 // Acceptable values: 1659 // - a null variant (IsNull() returns true) 1660 // - a list variant (GetType() == wxT("list") 1661 // - an integer representing the selected child element, 1662 // or 0 if this object is selected (GetType() == wxT("long") 1663 // - a "void*" pointer to a wxAccessible child object 1664 virtual wxAccStatus GetSelections(wxVariant* selections); 1665#endif // wxUSE_VARIANT 1666}; 1667 1668#endif // wxUSE_ACCESSIBILITY 1669 1670 1671#endif // _WX_WINDOW_H_BASE_ 1672