X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/6463b9f5399b8670a0c74f2f8666bc2c9f37a406..5eedcd5eee0c114f457e7549020b1b0e203ca2f0:/include/wx/window.h diff --git a/include/wx/window.h b/include/wx/window.h index f1eed002ac..6c7930a209 100644 --- a/include/wx/window.h +++ b/include/wx/window.h @@ -5,17 +5,13 @@ // Modified by: Ron Lee // Created: 01/02/97 // RCS-ID: $Id$ -// Copyright: (c) wxWindows team +// Copyright: (c) Vadim Zeitlin // Licence: wxWindows licence /////////////////////////////////////////////////////////////////////////////// #ifndef _WX_WINDOW_H_BASE_ #define _WX_WINDOW_H_BASE_ -#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) - #pragma interface "windowbase.h" -#endif - // ---------------------------------------------------------------------------- // headers which we must include here // ---------------------------------------------------------------------------- @@ -29,6 +25,7 @@ #include "wx/colour.h" #include "wx/region.h" #include "wx/utils.h" +#include "wx/intl.h" #include "wx/validate.h" // for wxDefaultValidator (always include it) @@ -48,42 +45,113 @@ // compiled in - it should only be used when building real wxFoo #ifdef __WXUNIVERSAL__ #define wxUSE_MENUS_NATIVE 0 -#else // __WXMSW__ +#else // !__WXUNIVERSAL__ #define wxUSE_MENUS_NATIVE wxUSE_MENUS -#endif // __WXUNIVERSAL__/__WXMSW__ +#endif // __WXUNIVERSAL__/!__WXUNIVERSAL__ + + +// Define this macro if the corresponding operating system handles the state +// of children windows automatically when the parent is enabled/disabled. +// Otherwise wx itself must ensure that when the parent is disabled its +// children are disabled too, and their initial state is restored when the +// parent is enabled back. +#if defined(__WXMSW__) || defined(__WXPM__) + // must do everything ourselves + #undef wxHAS_NATIVE_ENABLED_MANAGEMENT +#else + #define wxHAS_NATIVE_ENABLED_MANAGEMENT +#endif // ---------------------------------------------------------------------------- // forward declarations // ---------------------------------------------------------------------------- -class WXDLLEXPORT wxCaret; -class WXDLLEXPORT wxControl; -class WXDLLEXPORT wxCursor; -class WXDLLEXPORT wxDC; -class WXDLLEXPORT wxDropTarget; -class WXDLLEXPORT wxItemResource; -class WXDLLEXPORT wxLayoutConstraints; -class WXDLLEXPORT wxResourceTable; -class WXDLLEXPORT wxSizer; -class WXDLLEXPORT wxToolTip; -class WXDLLEXPORT wxWindowBase; -class WXDLLEXPORT wxWindow; +class WXDLLIMPEXP_FWD_CORE wxCaret; +class WXDLLIMPEXP_FWD_CORE wxControl; +class WXDLLIMPEXP_FWD_CORE wxCursor; +class WXDLLIMPEXP_FWD_CORE wxDC; +class WXDLLIMPEXP_FWD_CORE wxDropTarget; +class WXDLLIMPEXP_FWD_CORE wxLayoutConstraints; +class WXDLLIMPEXP_FWD_CORE wxSizer; +class WXDLLIMPEXP_FWD_CORE wxToolTip; +class WXDLLIMPEXP_FWD_CORE wxWindowBase; +class WXDLLIMPEXP_FWD_CORE wxWindow; +class WXDLLIMPEXP_FWD_CORE wxScrollHelper; #if wxUSE_ACCESSIBILITY -class WXDLLEXPORT wxAccessible; +class WXDLLIMPEXP_FWD_CORE wxAccessible; #endif +// ---------------------------------------------------------------------------- +// helper stuff used by wxWindow +// ---------------------------------------------------------------------------- + +// struct containing all the visual attributes of a control +struct WXDLLIMPEXP_CORE wxVisualAttributes +{ + // the font used for control label/text inside it + wxFont font; + + // the foreground colour + wxColour colFg; + + // the background colour, may be wxNullColour if the controls background + // colour is not solid + wxColour colBg; +}; + +// different window variants, on platforms like eg mac uses different +// rendering sizes +enum wxWindowVariant +{ + wxWINDOW_VARIANT_NORMAL, // Normal size + wxWINDOW_VARIANT_SMALL, // Smaller size (about 25 % smaller than normal) + wxWINDOW_VARIANT_MINI, // Mini size (about 33 % smaller than normal) + wxWINDOW_VARIANT_LARGE, // Large size (about 25 % larger than normal) + wxWINDOW_VARIANT_MAX +}; + +#if wxUSE_SYSTEM_OPTIONS + #define wxWINDOW_DEFAULT_VARIANT wxT("window-default-variant") +#endif + +// valid values for Show/HideWithEffect() +enum wxShowEffect +{ + wxSHOW_EFFECT_NONE, + wxSHOW_EFFECT_ROLL_TO_LEFT, + wxSHOW_EFFECT_ROLL_TO_RIGHT, + wxSHOW_EFFECT_ROLL_TO_TOP, + wxSHOW_EFFECT_ROLL_TO_BOTTOM, + wxSHOW_EFFECT_SLIDE_TO_LEFT, + wxSHOW_EFFECT_SLIDE_TO_RIGHT, + wxSHOW_EFFECT_SLIDE_TO_TOP, + wxSHOW_EFFECT_SLIDE_TO_BOTTOM, + wxSHOW_EFFECT_BLEND, + wxSHOW_EFFECT_EXPAND, + wxSHOW_EFFECT_MAX +}; + +// flags for SendSizeEvent() +enum +{ + wxSEND_EVENT_POST = 1 +}; + // ---------------------------------------------------------------------------- // (pseudo)template list classes // ---------------------------------------------------------------------------- -WX_DECLARE_LIST_3(wxWindow, wxWindowBase, wxWindowList, wxWindowListNode, class WXDLLEXPORT); +WX_DECLARE_LIST_3(wxWindow, wxWindowBase, wxWindowList, wxWindowListNode, class WXDLLIMPEXP_CORE); // ---------------------------------------------------------------------------- // global variables // ---------------------------------------------------------------------------- -WXDLLEXPORT_DATA(extern wxWindowList) wxTopLevelWindows; +extern WXDLLIMPEXP_DATA_CORE(wxWindowList) wxTopLevelWindows; + +// declared here for compatibility only, main declaration is in wx/app.h +extern WXDLLIMPEXP_DATA_BASE(wxList) wxPendingDelete; // ---------------------------------------------------------------------------- // wxWindowBase is the base class for all GUI controls/widgets, this is the public @@ -96,7 +164,7 @@ WXDLLEXPORT_DATA(extern wxWindowList) wxTopLevelWindows; // temporarily switches event handlers). // ---------------------------------------------------------------------------- -class WXDLLEXPORT wxWindowBase : public wxEvtHandler +class WXDLLIMPEXP_CORE wxWindowBase : public wxEvtHandler { public: // creating the window @@ -106,15 +174,6 @@ public: // Create() wxWindowBase() ; - // pseudo ctor (can't be virtual, called from ctor) - bool CreateBase(wxWindowBase *parent, - wxWindowID winid, - const wxPoint& pos = wxDefaultPosition, - const wxSize& size = wxDefaultSize, - long style = 0, - const wxValidator& validator = wxDefaultValidator, - const wxString& name = wxPanelNameStr); - virtual ~wxWindowBase(); // deleting the window @@ -134,44 +193,63 @@ public: bool DestroyChildren(); // is the window being deleted? - bool IsBeingDeleted() const { return m_isBeingDeleted; } + bool IsBeingDeleted() const; // window attributes // ----------------- - // NB: in future versions of wxWindows Set/GetTitle() will only work - // with the top level windows (such as dialogs and frames) and - // Set/GetLabel() only with the other ones (i.e. all controls). - - // the title (or label, see below) of the window: the text which the - // window shows - virtual void SetTitle( const wxString& WXUNUSED(title) ) {} - virtual wxString GetTitle() const { return wxEmptyString; } - // label is just the same as the title (but for, e.g., buttons it - // makes more sense to speak about labels) - virtual void SetLabel(const wxString& label) { SetTitle(label); } - virtual wxString GetLabel() const { return GetTitle(); } + // makes more sense to speak about labels), title access + // is available from wxTLW classes only (frames, dialogs) + virtual void SetLabel(const wxString& label) = 0; + virtual wxString GetLabel() const = 0; // the window name is used for ressource setting in X, it is not the // same as the window title/label virtual void SetName( const wxString &name ) { m_windowName = name; } virtual wxString GetName() const { return m_windowName; } + // sets the window variant, calls internally DoSetVariant if variant + // has changed + void SetWindowVariant(wxWindowVariant variant); + wxWindowVariant GetWindowVariant() const { return m_windowVariant; } + + + // get or change the layout direction (LTR or RTL) for this window, + // wxLayout_Default is returned if layout direction is not supported + virtual wxLayoutDirection GetLayoutDirection() const + { return wxLayout_Default; } + virtual void SetLayoutDirection(wxLayoutDirection WXUNUSED(dir)) + { } + + // mirror coordinates for RTL layout if this window uses it and if the + // mirroring is not done automatically like Win32 + virtual wxCoord AdjustForLayoutDirection(wxCoord x, + wxCoord width, + wxCoord widthTotal) const; + + // window id uniquely identifies the window among its siblings unless - // it is -1 which means "don't care" + // it is wxID_ANY which means "don't care" void SetId( wxWindowID winid ) { m_windowId = winid; } wxWindowID GetId() const { return m_windowId; } - // generate a control id for the controls which were not given one by - // user - static int NewControlId() { return --ms_lastControlId; } - // get the id of the control following the one with the given - // (autogenerated) id - static int NextControlId(int winid) { return winid - 1; } - // get the id of the control preceding the one with the given - // (autogenerated) id - static int PrevControlId(int winid) { return winid + 1; } + // generate a unique id (or count of them consecutively), returns a + // valid id in the auto-id range or wxID_NONE if failed. If using + // autoid management, it will mark the id as reserved until it is + // used (by assigning it to a wxWindowIDRef) or unreserved. + static wxWindowID NewControlId(int count = 1) + { + return wxIdManager::ReserveId(count); + } + + // If an ID generated from NewControlId is not assigned to a wxWindowIDRef, + // it must be unreserved + static void UnreserveControlId(wxWindowID id, int count = 1) + { + wxIdManager::UnreserveId(id, count); + } + // moving/resizing // --------------- @@ -182,7 +260,7 @@ public: { DoSetSize(x, y, width, height, sizeFlags); } void SetSize( int width, int height ) - { DoSetSize( -1, -1, width, height, wxSIZE_USE_EXISTING ); } + { DoSetSize( wxDefaultCoord, wxDefaultCoord, width, height, wxSIZE_USE_EXISTING ); } void SetSize( const wxSize& size ) { SetSize( size.x, size.y); } @@ -191,11 +269,13 @@ public: { DoSetSize(rect.x, rect.y, rect.width, rect.height, sizeFlags); } void Move(int x, int y, int flags = wxSIZE_USE_EXISTING) - { DoSetSize(x, y, -1, -1, flags); } + { DoSetSize(x, y, wxDefaultCoord, wxDefaultCoord, flags); } void Move(const wxPoint& pt, int flags = wxSIZE_USE_EXISTING) { Move(pt.x, pt.y, flags); } + void SetPosition(const wxPoint& pt) { Move(pt); } + // Z-order virtual void Raise() = 0; virtual void Lower() = 0; @@ -210,18 +290,30 @@ public: void SetClientSize(const wxRect& rect) { SetClientSize( rect.width, rect.height ); } - // get the window position and/or size (pointers may be NULL) + // get the window position (pointers may be NULL): notice that it is in + // client coordinates for child windows and screen coordinates for the + // top level ones, use GetScreenPosition() if you need screen + // coordinates for all kinds of windows void GetPosition( int *x, int *y ) const { DoGetPosition(x, y); } wxPoint GetPosition() const { - int w, h; - DoGetPosition(&w, &h); + int x, y; + DoGetPosition(&x, &y); - return wxPoint(w, h); + return wxPoint(x, y); } - void SetPosition( const wxPoint& pt ) { Move( pt ) ; } + // get the window position in screen coordinates + void GetScreenPosition(int *x, int *y) const { DoGetScreenPosition(x, y); } + wxPoint GetScreenPosition() const + { + int x, y; + DoGetScreenPosition(&x, &y); + + return wxPoint(x, y); + } + // get the window size (pointers may be NULL) void GetSize( int *w, int *h ) const { DoGetSize(w, h); } wxSize GetSize() const { @@ -230,22 +322,32 @@ public: return wxSize(w, h); } + void GetClientSize( int *w, int *h ) const { DoGetClientSize(w, h); } + wxSize GetClientSize() const + { + int w, h; + DoGetClientSize(&w, &h); + + return wxSize(w, h); + } + + // get the position and size at once wxRect GetRect() const { int x, y, w, h; - GetPosition(& x, & y); - GetSize(& w, & h); + GetPosition(&x, &y); + GetSize(&w, &h); return wxRect(x, y, w, h); } - void GetClientSize( int *w, int *h ) const { DoGetClientSize(w, h); } - wxSize GetClientSize() const + wxRect GetScreenRect() const { - int w, h; - DoGetClientSize(& w, & h); + int x, y, w, h; + GetScreenPosition(&x, &y); + GetSize(&w, &h); - return wxSize(w, h); + return wxRect(x, y, w, h); } // get the origin of the client area of the window relative to the @@ -259,41 +361,55 @@ public: return wxRect(GetClientAreaOrigin(), GetClientSize()); } + // client<->window size conversion + virtual wxSize ClientToWindowSize(const wxSize& size) const; + virtual wxSize WindowToClientSize(const wxSize& size) const; + // get the size best suited for the window (in fact, minimal - // acceptable size using which it will still look "nice") - wxSize GetBestSize() const { return DoGetBestSize(); } + // acceptable size using which it will still look "nice" in + // most situations) + wxSize GetBestSize() const; + void GetBestSize(int *w, int *h) const { - wxSize s = DoGetBestSize(); + wxSize s = GetBestSize(); if ( w ) *w = s.x; if ( h ) *h = s.y; } - // There are times (and windows) where 'Best' size and 'Min' size - // are vastly out of sync. This should be remedied somehow, but in - // the meantime, this method will return the larger of BestSize - // (the window's smallest legible size), and any user specified - // MinSize hint. - wxSize GetAdjustedBestSize() const - { - wxSize s( DoGetBestSize() ); - return wxSize( wxMax( s.x, GetMinWidth() ), wxMax( s.y, GetMinHeight() ) ); - } + void SetScrollHelper( wxScrollHelper *sh ) { m_scrollHelper = sh; } + wxScrollHelper *GetScrollHelper() { return m_scrollHelper; } + + // reset the cached best size value so it will be recalculated the + // next time it is needed. + void InvalidateBestSize(); + void CacheBestSize(const wxSize& size) const + { wxConstCast(this, wxWindowBase)->m_bestSizeCache = size; } + + + // This function will merge the window's best size into the window's + // minimum size, giving priority to the min size components, and + // returns the results. + virtual wxSize GetEffectiveMinSize() const; + wxDEPRECATED( wxSize GetBestFittingSize() const ); // replaced by GetEffectiveMinSize + wxDEPRECATED( wxSize GetAdjustedMinSize() const ); // replaced by GetEffectiveMinSize + + // A 'Smart' SetSize that will fill in default size values with 'best' + // size. Sets the minsize to what was passed in. + void SetInitialSize(const wxSize& size=wxDefaultSize); + wxDEPRECATED( void SetBestFittingSize(const wxSize& size=wxDefaultSize) ); // replaced by SetInitialSize + // the generic centre function - centers the window on parent by` // default or on screen if it doesn't have parent or // wxCENTER_ON_SCREEN flag is given - void Centre( int direction = wxBOTH ); - void Center( int direction = wxBOTH ) { Centre(direction); } - - // centre on screen (only works for top level windows) - void CentreOnScreen(int dir = wxBOTH) { Centre(dir | wxCENTER_ON_SCREEN); } - void CenterOnScreen(int dir = wxBOTH) { CentreOnScreen(dir); } + void Centre(int dir = wxBOTH) { DoCentre(dir); } + void Center(int dir = wxBOTH) { DoCentre(dir); } // centre with respect to the the parent window - void CentreOnParent(int dir = wxBOTH) { Centre(dir | wxCENTER_FRAME); } + void CentreOnParent(int dir = wxBOTH) { DoCentre(dir); } void CenterOnParent(int dir = wxBOTH) { CentreOnParent(dir); } // set window size to wrap around its children @@ -302,21 +418,63 @@ public: // set virtual size to satisfy children virtual void FitInside(); - // set min/max size of the window - virtual void SetSizeHints( int minW, int minH, - int maxW = -1, int maxH = -1, - int incW = -1, int incH = -1 ); - virtual void SetVirtualSizeHints( int minW, int minH, - int maxW = -1, int maxH = -1 ); + // SetSizeHints is actually for setting the size hints + // for the wxTLW for a Window Manager - hence the name - + // and it is therefore overridden in wxTLW to do that. + // In wxWindow(Base), it has (unfortunately) been abused + // to mean the same as SetMinSize() and SetMaxSize(). - virtual int GetMinWidth() const { return m_minWidth; } - virtual int GetMinHeight() const { return m_minHeight; } - int GetMaxWidth() const { return m_maxWidth; } - int GetMaxHeight() const { return m_maxHeight; } + virtual void SetSizeHints( int minW, int minH, + int maxW = wxDefaultCoord, int maxH = wxDefaultCoord, + int incW = wxDefaultCoord, int incH = wxDefaultCoord ) + { DoSetSizeHints(minW, minH, maxW, maxH, incW, incH); } + + void SetSizeHints( const wxSize& minSize, + const wxSize& maxSize=wxDefaultSize, + const wxSize& incSize=wxDefaultSize) + { DoSetSizeHints(minSize.x, minSize.y, maxSize.x, maxSize.y, incSize.x, incSize.y); } + + +#if WXWIN_COMPATIBILITY_2_8 + // these are useless and do nothing since wxWidgets 2.9 + wxDEPRECATED( virtual void SetVirtualSizeHints( int minW, int minH, + int maxW = wxDefaultCoord, int maxH = wxDefaultCoord ) ); + wxDEPRECATED( void SetVirtualSizeHints( const wxSize& minSize, + const wxSize& maxSize=wxDefaultSize) ); +#endif // WXWIN_COMPATIBILITY_2_8 + + + // Call these to override what GetBestSize() returns. This + // method is only virtual because it is overriden in wxTLW + // as a different API for SetSizeHints(). + virtual void SetMinSize(const wxSize& minSize); + virtual void SetMaxSize(const wxSize& maxSize); + + // Like Set*Size, but for client, not window, size + virtual void SetMinClientSize(const wxSize& size) + { SetMinSize(ClientToWindowSize(size)); } + virtual void SetMaxClientSize(const wxSize& size) + { SetMaxSize(ClientToWindowSize(size)); } + + // Override these methods to impose restrictions on min/max size. + // The easier way is to call SetMinSize() and SetMaxSize() which + // will have the same effect. Doing both is non-sense. + virtual wxSize GetMinSize() const { return wxSize(m_minWidth, m_minHeight); } + virtual wxSize GetMaxSize() const { return wxSize(m_maxWidth, m_maxHeight); } + + // Like Get*Size, but for client, not window, size + virtual wxSize GetMinClientSize() const + { return WindowToClientSize(GetMinSize()); } + virtual wxSize GetMaxClientSize() const + { return WindowToClientSize(GetMaxSize()); } + + // Get the min and max values one by one + int GetMinWidth() const { return GetMinSize().x; } + int GetMinHeight() const { return GetMinSize().y; } + int GetMaxWidth() const { return GetMaxSize().x; } + int GetMaxHeight() const { return GetMaxSize().y; } - // Override this method to control the values given to Sizers etc. - virtual wxSize GetMaxSize() const { return wxSize( m_maxWidth, m_maxHeight ); } // Methods for accessing the virtual size of a window. For most // windows this is just the client area of the window, but for @@ -340,10 +498,10 @@ public: // Override these methods for windows that have a virtual size // independent of their client size. eg. the virtual area of a - // wxScrolledWindow. Default is to alias VirtualSize to ClientSize. + // wxScrolledWindow. virtual void DoSetVirtualSize( int x, int y ); - virtual wxSize DoGetVirtualSize() const; // { return m_virtualSize; } + virtual wxSize DoGetVirtualSize() const; // Return the largest of ClientSize and BestSize (as determined // by a sizer, interior children, or other means) @@ -356,6 +514,46 @@ public: return wxSize( wxMax( client.x, best.x ), wxMax( client.y, best.y ) ); } + // return the size of the left/right and top/bottom borders in x and y + // components of the result respectively + virtual wxSize GetWindowBorderSize() const; + + // wxSizer and friends use this to give a chance to a component to recalc + // its min size once one of the final size components is known. Override + // this function when that is useful (such as for wxStaticText which can + // stretch over several lines). Parameter availableOtherDir + // tells the item how much more space there is available in the opposite + // direction (-1 if unknown). + virtual bool + InformFirstDirection(int WXUNUSED(direction), + int WXUNUSED(size), + int WXUNUSED(availableOtherDir)) + { + return false; + } + + // sends a size event to the window using its current size -- this has an + // effect of refreshing the window layout + // + // by default the event is sent, i.e. processed immediately, but if flags + // value includes wxSEND_EVENT_POST then it's posted, i.e. only schedule + // for later processing + virtual void SendSizeEvent(int flags = 0); + + // this is a safe wrapper for GetParent()->SendSizeEvent(): it checks that + // we have a parent window and it's not in process of being deleted + // + // this is used by controls such as tool/status bars changes to which must + // also result in parent re-layout + void SendSizeEventToParent(int flags = 0); + + // this is a more readable synonym for SendSizeEvent(wxSEND_EVENT_POST) + void PostSizeEvent() { SendSizeEvent(wxSEND_EVENT_POST); } + + // this is the same as SendSizeEventToParent() but using PostSizeEvent() + void PostSizeEventToParent() { SendSizeEventToParent(wxSEND_EVENT_POST); } + + // window state // ------------ @@ -364,40 +562,82 @@ public: virtual bool Show( bool show = true ); bool Hide() { return Show(false); } + // show or hide the window with a special effect, not implemented on + // most platforms (where it is the same as Show()/Hide() respectively) + // + // timeout specifies how long the animation should take, in ms, the + // default value of 0 means to use the default (system-dependent) value + virtual bool ShowWithEffect(wxShowEffect WXUNUSED(effect), + unsigned WXUNUSED(timeout) = 0) + { + return Show(); + } + + virtual bool HideWithEffect(wxShowEffect WXUNUSED(effect), + unsigned WXUNUSED(timeout) = 0) + { + return Hide(); + } + // returns true if window was enabled/disabled, false if nothing done virtual bool Enable( bool enable = true ); bool Disable() { return Enable(false); } - bool IsShown() const { return m_isShown; } - bool IsEnabled() const { return m_isEnabled; } + virtual bool IsShown() const { return m_isShown; } + // returns true if the window is really enabled and false otherwise, + // whether because it had been explicitly disabled itself or because + // its parent is currently disabled -- then this method returns false + // whatever is the intrinsic state of this window, use IsThisEnabled(0 + // to retrieve it. In other words, this relation always holds: + // + // IsEnabled() == IsThisEnabled() && parent.IsEnabled() + // + bool IsEnabled() const; + + // returns the internal window state independently of the parent(s) + // state, i.e. the state in which the window would be if all its + // parents were enabled (use IsEnabled() above to get the effective + // window state) + bool IsThisEnabled() const { return m_isEnabled; } + + // returns true if the window is visible, i.e. IsShown() returns true + // if called on it and all its parents up to the first TLW + virtual bool IsShownOnScreen() const; // get/set window style (setting style won't update the window and so // is only useful for internal usage) virtual void SetWindowStyleFlag( long style ) { m_windowStyle = style; } virtual long GetWindowStyleFlag() const { return m_windowStyle; } - // just some (somewhat shorter) synonims + // just some (somewhat shorter) synonyms void SetWindowStyle( long style ) { SetWindowStyleFlag(style); } long GetWindowStyle() const { return GetWindowStyleFlag(); } + // check if the flag is set bool HasFlag(int flag) const { return (m_windowStyle & flag) != 0; } virtual bool IsRetained() const { return HasFlag(wxRETAINED); } + // turn the flag on if it had been turned off before and vice versa, + // return true if the flag is currently turned on + bool ToggleWindowStyle(int flag); + // extra style: the less often used style bits which can't be set with // SetWindowStyleFlag() virtual void SetExtraStyle(long exStyle) { m_exStyle = exStyle; } long GetExtraStyle() const { return m_exStyle; } + bool HasExtraStyle(int exFlag) const { return (m_exStyle & exFlag) != 0; } + // make the window modal (all other windows unresponsive) virtual void MakeModal(bool modal = true); + + // (primitive) theming support + // --------------------------- + virtual void SetThemeEnabled(bool enableTheme) { m_themeEnabled = enableTheme; } virtual bool GetThemeEnabled() const { return m_themeEnabled; } - // returns true if this window should inherit its parent colours on - // creation - virtual bool ShouldInheritColours() const { return false; } - // focus and keyboard handling // --------------------------- @@ -409,29 +649,78 @@ public: virtual void SetFocusFromKbd() { SetFocus(); } // return the window which currently has the focus or NULL - static wxWindow *FindFocus() /* = 0: implement in derived classes */; + static wxWindow *FindFocus(); + + static wxWindow *DoFindFocus() /* = 0: implement in derived classes */; - // can this window have focus? - virtual bool AcceptsFocus() const { return IsShown() && IsEnabled(); } + // return true if the window has focus (handles composite windows + // correctly - returns true if GetMainWindowOfCompositeControl() + // has focus) + virtual bool HasFocus() const; + + // can this window have focus in principle? + // + // the difference between AcceptsFocus[FromKeyboard]() and CanAcceptFocus + // [FromKeyboard]() is that the former functions are meant to be + // overridden in the derived classes to simply return false if the + // control can't have focus, while the latter are meant to be used by + // this class clients and take into account the current window state + virtual bool AcceptsFocus() const { return true; } + + // can this window or one of its children accept focus? + // + // usually it's the same as AcceptsFocus() but is overridden for + // container windows + virtual bool AcceptsFocusRecursively() const { return AcceptsFocus(); } // can this window be given focus by keyboard navigation? if not, the // only way to give it focus (provided it accepts it at all) is to // click it virtual bool AcceptsFocusFromKeyboard() const { return AcceptsFocus(); } - // NB: these methods really don't belong here but with the current - // class hierarchy there is no other place for them :-( - // get the default child of this parent, i.e. the one which is - // activated by pressing - virtual wxWindow *GetDefaultItem() const { return NULL; } + // this is mostly a helper for the various functions using it below + bool CanBeFocused() const { return IsShown() && IsEnabled(); } - // set this child as default, return the old default - virtual wxWindow *SetDefaultItem(wxWindow * WXUNUSED(child)) - { return NULL; } + // can this window itself have focus? + bool IsFocusable() const { return AcceptsFocus() && CanBeFocused(); } + + // can this window have focus right now? + // + // if this method returns true, it means that calling SetFocus() will + // put focus either to this window or one of its children, if you need + // to know whether this window accepts focus itself, use IsFocusable() + bool CanAcceptFocus() const + { return AcceptsFocusRecursively() && CanBeFocused(); } + + // can this window be assigned focus from keyboard right now? + bool CanAcceptFocusFromKeyboard() const + { return AcceptsFocusFromKeyboard() && CanBeFocused(); } + + // call this when the return value of AcceptsFocus() changes + virtual void SetCanFocus(bool WXUNUSED(canFocus)) { } + + // navigates inside this window + bool NavigateIn(int flags = wxNavigationKeyEvent::IsForward) + { return DoNavigateIn(flags); } + + // navigates in the specified direction from this window, this is + // equivalent to GetParent()->NavigateIn() + bool Navigate(int flags = wxNavigationKeyEvent::IsForward) + { return m_parent && ((wxWindowBase *)m_parent)->DoNavigateIn(flags); } + + // this function will generate the appropriate call to Navigate() if the + // key event is one normally used for keyboard navigation and return true + // in this case + bool HandleAsNavigationKey(const wxKeyEvent& event); + + // move this window just before/after the specified one in tab order + // (the other window must be our sibling!) + void MoveBeforeInTabOrder(wxWindow *win) + { DoMoveInTabOrder(win, OrderBefore); } + void MoveAfterInTabOrder(wxWindow *win) + { DoMoveInTabOrder(win, OrderAfter); } - // set this child as temporary default - virtual void SetTmpDefaultItem(wxWindow * WXUNUSED(win)) { } // parent/children relations // ------------------------- @@ -443,6 +732,11 @@ public: // needed just for extended runtime const wxWindowList& GetWindowChildren() const { return GetChildren() ; } + // get the window before/after this one in the parents children list, + // returns NULL if this is the first/last window + wxWindow *GetPrevSibling() const { return DoGetSibling(OrderBefore); } + wxWindow *GetNextSibling() const { return DoGetSibling(OrderAfter); } + // get the parent or the parent of the parent wxWindow *GetParent() const { return m_parent; } inline wxWindow *GetGrandParent() const; @@ -450,7 +744,7 @@ public: // is this window a top level one? virtual bool IsTopLevel() const; - // it doesn't really change parent, use ReParent() instead + // it doesn't really change parent, use Reparent() instead void SetParent( wxWindowBase *parent ) { m_parent = (wxWindow *)parent; } // change the real parent of this window, return true if the parent // was changed, false otherwise (error or newParent == oldParent) @@ -460,13 +754,18 @@ public: virtual void AddChild( wxWindowBase *child ); virtual void RemoveChild( wxWindowBase *child ); + // returns true if the child is in the client area of the window, i.e. is + // not scrollbar, toolbar etc. + virtual bool IsClientAreaChild(const wxWindow *WXUNUSED(child)) const + { return true; } + // looking for windows // ------------------- // find window among the descendants of this one either by id or by // name (return NULL if not found) - wxWindow *FindWindow( long winid ); - wxWindow *FindWindow( const wxString& name ); + wxWindow *FindWindow(long winid) const; + wxWindow *FindWindow(const wxString& name) const; // Find a window among any window (all return NULL if not found) static wxWindow *FindWindowById( long winid, const wxWindow *parent = NULL ); @@ -483,7 +782,7 @@ public: // replace the event handler (allows to completely subclass the // window) - void SetEventHandler( wxEvtHandler *handler ) { m_eventHandler = handler; } + void SetEventHandler( wxEvtHandler *handler ); // push/pop event handler: allows to chain a custom event handler to // alreasy existing ones @@ -497,6 +796,59 @@ public: // be there) bool RemoveEventHandler(wxEvtHandler *handler); + // Process an event by calling GetEventHandler()->ProcessEvent(): this + // is a straightforward replacement for ProcessEvent() itself which + // shouldn't be used directly with windows as it doesn't take into + // account any event handlers associated with the window + bool ProcessWindowEvent(wxEvent& event) + { return GetEventHandler()->ProcessEvent(event); } + + // Call GetEventHandler()->ProcessEventLocally(): this should be used + // instead of calling ProcessEventLocally() directly on the window + // itself as this wouldn't take any pushed event handlers into account + // correctly + bool ProcessWindowEventLocally(wxEvent& event) + { return GetEventHandler()->ProcessEventLocally(event); } + + // Process an event by calling GetEventHandler()->ProcessEvent() and + // handling any exceptions thrown by event handlers. It's mostly useful + // when processing wx events when called from C code (e.g. in GTK+ + // callback) when the exception wouldn't correctly propagate to + // wxEventLoop. + bool HandleWindowEvent(wxEvent& event) const; + + // disable wxEvtHandler double-linked list mechanism: + virtual void SetNextHandler(wxEvtHandler *handler); + virtual void SetPreviousHandler(wxEvtHandler *handler); + + + // Watcom doesn't allow reducing access with using access declaration, see + // #10749 +#ifndef __WATCOMC__ +protected: + + // NOTE: we change the access specifier of the following wxEvtHandler functions + // so that the user won't be able to call them directly. + // Calling wxWindow::ProcessEvent in fact only works when there are NO + // event handlers pushed on the window. + // To ensure correct operation, instead of wxWindow::ProcessEvent + // you must always call wxWindow::GetEventHandler()->ProcessEvent() + // or HandleWindowEvent(). + // The same holds for all other wxEvtHandler functions. + + using wxEvtHandler::ProcessEvent; + using wxEvtHandler::ProcessEventLocally; +#if wxUSE_THREADS + using wxEvtHandler::ProcessThreadEvent; +#endif + using wxEvtHandler::SafelyProcessEvent; + using wxEvtHandler::ProcessPendingEvents; + using wxEvtHandler::AddPendingEvent; + using wxEvtHandler::QueueEvent; +#endif // __WATCOMC__ + +public: + // validators // ---------- @@ -542,16 +894,16 @@ public: // dialog units translations // ------------------------- - wxPoint ConvertPixelsToDialog( const wxPoint& pt ); - wxPoint ConvertDialogToPixels( const wxPoint& pt ); - wxSize ConvertPixelsToDialog( const wxSize& sz ) + wxPoint ConvertPixelsToDialog( const wxPoint& pt ) const; + wxPoint ConvertDialogToPixels( const wxPoint& pt ) const; + wxSize ConvertPixelsToDialog( const wxSize& sz ) const { wxPoint pt(ConvertPixelsToDialog(wxPoint(sz.x, sz.y))); return wxSize(pt.x, pt.y); } - wxSize ConvertDialogToPixels( const wxSize& sz ) + wxSize ConvertDialogToPixels( const wxSize& sz ) const { wxPoint pt(ConvertDialogToPixels(wxPoint(sz.x, sz.y))); @@ -587,7 +939,10 @@ public: const wxRect *rect = (const wxRect *) NULL ) = 0; // a less awkward wrapper for Refresh - void RefreshRect(const wxRect& rect) { Refresh(true, &rect); } + void RefreshRect(const wxRect& rect, bool eraseBackground = true) + { + Refresh(eraseBackground, &rect); + } // repaint all invalid areas of the window immediately virtual void Update() { } @@ -596,14 +951,20 @@ public: virtual void ClearBackground(); // freeze the window: don't redraw it until it is thawed - virtual void Freeze() { } + void Freeze(); // thaw the window: redraw it after it had been frozen - virtual void Thaw() { } + void Thaw(); + + // return true if window had been frozen and not unthawed yet + bool IsFrozen() const { return m_freezeCount != 0; } // adjust DC for drawing on this window virtual void PrepareDC( wxDC & WXUNUSED(dc) ) { } + // return true if the window contents is double buffered by the system + virtual bool IsDoubleBuffered() const { return false; } + // the update region of the window contains the areas which must be // repainted by the program const wxRegion& GetUpdateRegion() const { return m_updateRegion; } @@ -614,36 +975,89 @@ public: // these functions verify whether the given point/rectangle belongs to // (or at least intersects with) the update region - bool IsExposed( int x, int y ) const; - bool IsExposed( int x, int y, int w, int h ) const; + virtual bool DoIsExposed( int x, int y ) const; + virtual bool DoIsExposed( int x, int y, int w, int h ) const; + bool IsExposed( int x, int y ) const + { return DoIsExposed(x, y); } + bool IsExposed( int x, int y, int w, int h ) const + { return DoIsExposed(x, y, w, h); } bool IsExposed( const wxPoint& pt ) const - { return IsExposed(pt.x, pt.y); } + { return DoIsExposed(pt.x, pt.y); } bool IsExposed( const wxRect& rect ) const - { return IsExposed(rect.x, rect.y, rect.width, rect.height); } + { return DoIsExposed(rect.x, rect.y, rect.width, rect.height); } // colours, fonts and cursors // -------------------------- + // get the default attributes for the controls of this class: we + // provide a virtual function which can be used to query the default + // attributes of an existing control and a static function which can + // be used even when no existing object of the given class is + // available, but which won't return any styles specific to this + // particular control, of course (e.g. "Ok" button might have + // different -- bold for example -- font) + virtual wxVisualAttributes GetDefaultAttributes() const + { + return GetClassDefaultAttributes(GetWindowVariant()); + } + + static wxVisualAttributes + GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL); + // set/retrieve the window colours (system defaults are used by - // default): Set functions return true if colour was changed - virtual bool SetBackgroundColour( const wxColour &colour ); - virtual bool SetForegroundColour( const wxColour &colour ); + // default): SetXXX() functions return true if colour was changed, + // SetDefaultXXX() reset the "m_inheritXXX" flag after setting the + // value to prevent it from being inherited by our children + virtual bool SetBackgroundColour(const wxColour& colour); + void SetOwnBackgroundColour(const wxColour& colour) + { + if ( SetBackgroundColour(colour) ) + m_inheritBgCol = false; + } + wxColour GetBackgroundColour() const; + bool InheritsBackgroundColour() const + { + return m_inheritBgCol; + } + bool UseBgCol() const + { + return m_hasBgCol; + } + + virtual bool SetForegroundColour(const wxColour& colour); + void SetOwnForegroundColour(const wxColour& colour) + { + if ( SetForegroundColour(colour) ) + m_inheritFgCol = false; + } + wxColour GetForegroundColour() const; + + // Set/get the background style. + virtual bool SetBackgroundStyle(wxBackgroundStyle style) + { m_backgroundStyle = style; return true; } + wxBackgroundStyle GetBackgroundStyle() const + { return m_backgroundStyle; } - wxColour GetBackgroundColour() const { return m_backgroundColour; } - wxColour GetForegroundColour() const { return m_foregroundColour; } + // returns true if the control has "transparent" areas such as a + // wxStaticText and wxCheckBox and the background should be adapted + // from a parent window + virtual bool HasTransparentBackground() { return false; } + + // set/retrieve the font for the window (SetFont() returns true if the + // font really changed) + virtual bool SetFont(const wxFont& font) = 0; + void SetOwnFont(const wxFont& font) + { + if ( SetFont(font) ) + m_inheritFont = false; + } + wxFont GetFont() const; // set/retrieve the cursor for this window (SetCursor() returns true // if the cursor was really changed) virtual bool SetCursor( const wxCursor &cursor ); const wxCursor& GetCursor() const { return m_cursor; } - wxCursor& GetCursor() { return m_cursor; } - - // set/retrieve the font for the window (SetFont() returns true if the - // font really changed) - virtual bool SetFont( const wxFont &font ) = 0; - const wxFont& GetFont() const { return m_font; } - wxFont& GetFont() { return m_font; } #if wxUSE_CARET // associate a caret with the window @@ -658,12 +1072,21 @@ public: // get the width/height/... of the text using current or specified // font - virtual void GetTextExtent(const wxString& string, - int *x, int *y, - int *descent = (int *) NULL, - int *externalLeading = (int *) NULL, - const wxFont *theFont = (const wxFont *) NULL) - const = 0; + void GetTextExtent(const wxString& string, + int *x, int *y, + int *descent = NULL, + int *externalLeading = NULL, + const wxFont *font = NULL) const + { + DoGetTextExtent(string, x, y, descent, externalLeading, font); + } + + wxSize GetTextExtent(const wxString& string) const + { + wxCoord w, h; + GetTextExtent(string, &w, &h); + return wxSize(w, h); + } // client <-> screen coords // ------------------------ @@ -716,22 +1139,37 @@ public: virtual void DoUpdateWindowUI(wxUpdateUIEvent& event) ; #if wxUSE_MENUS - bool PopupMenu( wxMenu *menu, const wxPoint& pos ) - { return DoPopupMenu(menu, pos.x, pos.y); } - bool PopupMenu( wxMenu *menu, int x, int y ) - { return DoPopupMenu(menu, x, y); } + // show popup menu at the given position, generate events for the items + // selected in it + bool PopupMenu(wxMenu *menu, const wxPoint& pos = wxDefaultPosition) + { return PopupMenu(menu, pos.x, pos.y); } + bool PopupMenu(wxMenu *menu, int x, int y); + + // simply return the id of the selected item or wxID_NONE without + // generating any events + int GetPopupMenuSelectionFromUser(wxMenu& menu, const wxPoint& pos) + { return DoGetPopupMenuSelectionFromUser(menu, pos.x, pos.y); } + int GetPopupMenuSelectionFromUser(wxMenu& menu, int x, int y) + { return DoGetPopupMenuSelectionFromUser(menu, x, y); } #endif // wxUSE_MENUS + // override this method to return true for controls having multiple pages + virtual bool HasMultiplePages() const { return false; } + + // scrollbars // ---------- - // does the window have the scrollbar for this orientation? - bool HasScrollbar(int orient) const + // can the window have the scrollbar in this orientation? + bool CanScroll(int orient) const { return (m_windowStyle & (orient == wxHORIZONTAL ? wxHSCROLL : wxVSCROLL)) != 0; } + // does the window have the scrollbar in this orientation? + bool HasScrollbar(int orient) const; + // configure the window scrollbars virtual void SetScrollbar( int orient, int pos, @@ -745,7 +1183,7 @@ public: // scroll window to the specified position virtual void ScrollWindow( int dx, int dy, - const wxRect* rect = (wxRect *) NULL ) = 0; + const wxRect* rect = NULL ) = 0; // scrolls window by line/page: note that not all controls support this // @@ -759,6 +1197,20 @@ public: bool PageUp() { return ScrollPages(-1); } bool PageDown() { return ScrollPages(1); } + // call this to always show one or both scrollbars, even if the window + // is big enough to not require them + virtual void AlwaysShowScrollbars(bool WXUNUSED(horz) = true, + bool WXUNUSED(vert) = true) + { + } + + // return true if AlwaysShowScrollbars() had been called before for the + // corresponding orientation + virtual bool IsScrollbarAlwaysShown(int WXUNUSED(orient)) const + { + return false; + } + // context-sensitive help // ---------------------- @@ -767,11 +1219,29 @@ public: #if wxUSE_HELP // associate this help text with this window void SetHelpText(const wxString& text); - // associate this help text with all windows with the same id as this - // one - void SetHelpTextForId(const wxString& text); - // get the help string associated with this window (may be empty) - wxString GetHelpText() const; + +#if WXWIN_COMPATIBILITY_2_8 + // Associate this help text with all windows with the same id as this one. + // Don't use this, do wxHelpProvider::Get()->AddHelp(id, text); + wxDEPRECATED( void SetHelpTextForId(const wxString& text) ); +#endif // WXWIN_COMPATIBILITY_2_8 + + // get the help string associated with the given position in this window + // + // notice that pt may be invalid if event origin is keyboard or unknown + // and this method should return the global window help text then + virtual wxString GetHelpTextAtPoint(const wxPoint& pt, + wxHelpEvent::Origin origin) const; + // returns the position-independent help text + wxString GetHelpText() const + { + return GetHelpTextAtPoint(wxDefaultPosition, wxHelpEvent::Origin_Unknown); + } + +#else // !wxUSE_HELP + // silently ignore SetHelpText() calls + void SetHelpText(const wxString& WXUNUSED(text)) { } + void SetHelpTextForId(const wxString& WXUNUSED(text)) { } #endif // wxUSE_HELP // tooltips @@ -780,12 +1250,20 @@ public: #if wxUSE_TOOLTIPS // the easiest way to set a tooltip for a window is to use this method void SetToolTip( const wxString &tip ); - // attach a tooltip to the window + // attach a tooltip to the window, pointer can be NULL to remove + // existing tooltip void SetToolTip( wxToolTip *tip ) { DoSetToolTip(tip); } + // more readable synonym for SetToolTip(NULL) + void UnsetToolTip() { SetToolTip(NULL); } // get the associated tooltip or NULL if none wxToolTip* GetToolTip() const { return m_tooltip; } - wxString GetToolTipText() const ; -#endif // wxUSE_TOOLTIPS + wxString GetToolTipText() const; +#else // !wxUSE_TOOLTIPS + // make it much easier to compile apps in an environment + // that doesn't support tooltips, such as PocketPC + void SetToolTip(const wxString & WXUNUSED(tip)) { } + void UnsetToolTip() { } +#endif // wxUSE_TOOLTIPS/!wxUSE_TOOLTIPS // drag and drop // ------------- @@ -794,6 +1272,16 @@ public: // NULL; it's owned by the window and will be deleted by it) virtual void SetDropTarget( wxDropTarget *dropTarget ) = 0; virtual wxDropTarget *GetDropTarget() const { return m_dropTarget; } + + // Accept files for dragging + virtual void DragAcceptFiles(bool accept) +#ifdef __WXMSW__ + // it does have common implementation but not for MSW which has its own + // native version of it + = 0 +#endif // __WXMSW__ + ; + #endif // wxUSE_DRAG_AND_DROP // constraints and sizers @@ -812,7 +1300,7 @@ public: void DeleteRelatedConstraints(); void ResetConstraints(); - // these methods may be overriden for special layout algorithms + // these methods may be overridden for special layout algorithms virtual void SetConstraintSizes(bool recurse = true); virtual bool LayoutPhase1(int *noChanges); virtual bool LayoutPhase2(int *noChanges); @@ -843,17 +1331,7 @@ public: wxSizer *GetSizer() const { return m_windowSizer; } // Track if this window is a member of a sizer - void SetContainingSizer(wxSizer* sizer) - { - // adding a window to a sizer twice is going to result in fatal and - // hard to debug problems later because when deleting the second - // associated wxSizerItem we're going to dereference a dangling - // pointer; so try to detect this as early as possible - wxASSERT_MSG( !sizer || m_containingSizer != sizer, - _T("Adding a window to the same sizer twice?") ); - - m_containingSizer = sizer; - } + void SetContainingSizer(wxSizer* sizer); wxSizer *GetContainingSizer() const { return m_containingSizer; } // accessibility @@ -866,12 +1344,18 @@ public: void SetAccessible(wxAccessible* accessible) ; // Returns the accessible object. - wxAccessible* GetAccessible() { return m_accessible; }; + wxAccessible* GetAccessible() { return m_accessible; } // Returns the accessible object, creating if necessary. wxAccessible* GetOrCreateAccessible() ; #endif + + // Set window transparency if the platform supports it + virtual bool SetTransparent(wxByte WXUNUSED(alpha)) { return false; } + virtual bool CanSetTransparent() { return false; } + + // implementation // -------------- @@ -894,6 +1378,10 @@ public: // is only used for wxWin itself or for user code which wants to call // platform-specific APIs virtual WXWidget GetHandle() const = 0; + // associate the window with a new native handle + virtual void AssociateHandle(WXWidget WXUNUSED(handle)) { } + // dissociate the current native handle from the window + virtual void DissociateHandle() { } #if wxUSE_PALETTE // Store the palette used by DCs in wxWindow so that the dcs can share @@ -911,23 +1399,94 @@ public: wxWindow *GetAncestorWithCustomPalette() const; #endif // wxUSE_PALETTE + // inherit the parents visual attributes if they had been explicitly set + // by the user (i.e. we don't inherit default attributes) and if we don't + // have our own explicitly set + virtual void InheritAttributes(); + + // returns false from here if this window doesn't want to inherit the + // parents colours even if InheritAttributes() would normally do it + // + // this just provides a simple way to customize InheritAttributes() + // behaviour in the most common case + virtual bool ShouldInheritColours() const { return false; } + + // returns true if the window can be positioned outside of parent's client + // area (normal windows can't, but e.g. menubar or statusbar can): + virtual bool CanBeOutsideClientArea() const { return false; } + + // returns true if the platform should explicitly apply a theme border. Currently + // used only by Windows + virtual bool CanApplyThemeBorder() const { return true; } + + // returns the main window of composite control; this is the window + // that FindFocus returns if the focus is in one of composite control's + // windows + virtual wxWindow *GetMainWindowOfCompositeControl() + { return (wxWindow*)this; } + protected: + // helper for the derived class Create() methods: the first overload, with + // validator parameter, should be used for child windows while the second + // one is used for top level ones + bool CreateBase(wxWindowBase *parent, + wxWindowID winid, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = 0, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = wxPanelNameStr); + + bool CreateBase(wxWindowBase *parent, + wxWindowID winid, + const wxPoint& pos, + const wxSize& size, + long style, + const wxString& name); + // event handling specific to wxWindow - virtual bool TryValidator(wxEvent& event); - virtual bool TryParent(wxEvent& event); + virtual bool TryBefore(wxEvent& event); + virtual bool TryAfter(wxEvent& event); + + enum WindowOrder + { + OrderBefore, // insert before the given window + OrderAfter // insert after the given window + }; + + // common part of GetPrev/NextSibling() + wxWindow *DoGetSibling(WindowOrder order) const; + // common part of MoveBefore/AfterInTabOrder() + virtual void DoMoveInTabOrder(wxWindow *win, WindowOrder move); + + // implementation of Navigate() and NavigateIn() + virtual bool DoNavigateIn(int flags); #if wxUSE_CONSTRAINTS // satisfy the constraints for the windows but don't set the window sizes void SatisfyConstraints(); #endif // wxUSE_CONSTRAINTS - // Send the wxWindowDestroyEvent + // Send the wxWindowDestroyEvent if not done yet and sets m_isBeingDeleted + // to true void SendDestroyEvent(); + // this method should be implemented to use operating system specific code + // to really enable/disable the widget, it will only be called when we + // really need to enable/disable window and so no additional checks on the + // widgets state are necessary + virtual void DoEnable(bool WXUNUSED(enable)) { } + + // called when the on-screen widget state changes and provides an + // an opportunity for the widget to update its visual state (colours, + // fonts, anything else) as necessary + virtual void OnEnabled(bool WXUNUSED(enabled)) { } + + // the window id - a number which uniquely identifies a window among - // its siblings unless it is -1 - wxWindowID m_windowId; + // its siblings unless it is wxID_ANY + wxWindowIDRef m_windowId; // the parent window of this window (or NULL) and the list of the children // of this window @@ -935,7 +1494,7 @@ protected: wxWindowList m_children; // the minimal allowed size for the window (no minimal size if variable(s) - // contain(s) -1) + // contain(s) wxDefaultCoord) int m_minWidth, m_minHeight, m_maxWidth, @@ -956,8 +1515,9 @@ protected: // visual window attributes wxCursor m_cursor; - wxFont m_font; - wxColour m_backgroundColour, m_foregroundColour; + wxFont m_font; // see m_hasFont + wxColour m_backgroundColour, // m_hasBgCol + m_foregroundColour; // m_hasFgCol #if wxUSE_CARET wxCaret *m_caret; @@ -1005,12 +1565,17 @@ protected: bool m_hasFgCol:1; bool m_hasFont:1; + // and should it be inherited by children? + bool m_inheritBgCol:1; + bool m_inheritFgCol:1; + bool m_inheritFont:1; + // window attributes long m_windowStyle, m_exStyle; wxString m_windowName; bool m_themeEnabled; - + wxBackgroundStyle m_backgroundStyle; #if wxUSE_PALETTE wxPalette m_palette; bool m_hasCustomPalette; @@ -1019,47 +1584,37 @@ protected: #if wxUSE_ACCESSIBILITY wxAccessible* m_accessible; #endif + // Virtual size (scrolling) wxSize m_virtualSize; - int m_minVirtualWidth; // VirtualSizeHints - int m_minVirtualHeight; - int m_maxVirtualWidth; - int m_maxVirtualHeight; + wxScrollHelper *m_scrollHelper; + + wxWindowVariant m_windowVariant ; // override this to change the default (i.e. used when no style is // specified) border for the window class virtual wxBorder GetDefaultBorder() const; - // get the default size for the new window if no explicit size given - // FIXME why 20 and not 30, 10 or ...? - static int WidthDefault(int w) { return w == -1 ? 20 : w; } - static int HeightDefault(int h) { return h == -1 ? 20 : h; } + // this allows you to implement standard control borders without + // repeating the code in different classes that are not derived from + // wxControl + virtual wxBorder GetDefaultBorderForControl() const { return wxBORDER_THEME; } + + // Get the default size for the new window if no explicit size given. TLWs + // have their own default size so this is just for non top-level windows. + static int WidthDefault(int w) { return w == wxDefaultCoord ? 20 : w; } + static int HeightDefault(int h) { return h == wxDefaultCoord ? 20 : h; } + + + // Used to save the results of DoGetBestSize so it doesn't need to be + // recalculated each time the value is needed. + wxSize m_bestSizeCache; + + wxDEPRECATED( void SetBestSize(const wxSize& size) ); // use SetInitialSize + wxDEPRECATED( virtual void SetInitialBestSize(const wxSize& size) ); // use SetInitialSize + - // set the best size for the control if the default size was given: - // replaces the fields of size == -1 with the best values for them and - // calls SetSize() if needed - // - // This function is rather unfortunately named.. it's really just a - // smarter SetSize / convenience function for expanding wxDefaultSize. - // Note that it does not influence the value returned by GetBestSize - // at all. - void SetBestSize(const wxSize& size) - { - // the size only needs to be changed if the current size is incomplete, - // i.e. one of the components was specified as default -- so if both - // were given, simply don't do anything - if ( size.x == -1 || size.y == -1 ) - { - wxSize sizeBest = DoGetBestSize(); - if ( size.x != -1 ) - sizeBest.x = size.x; - if ( size.y != -1 ) - sizeBest.y = size.y; - - SetSize(sizeBest); - } - } // more pure virtual functions // --------------------------- @@ -1073,6 +1628,13 @@ protected: // overloaded Something()s in terms of DoSomething() which will be the // only one to be virtual. + // text extent + virtual void DoGetTextExtent(const wxString& string, + int *x, int *y, + int *descent = NULL, + int *externalLeading = NULL, + const wxFont *font = NULL) const = 0; + // coordinates translation virtual void DoClientToScreen( int *x, int *y ) const = 0; virtual void DoScreenToClient( int *x, int *y ) const = 0; @@ -1084,15 +1646,21 @@ protected: virtual void DoReleaseMouse() = 0; // retrieve the position/size of the window - virtual void DoGetPosition( int *x, int *y ) const = 0; - virtual void DoGetSize( int *width, int *height ) const = 0; - virtual void DoGetClientSize( int *width, int *height ) const = 0; + virtual void DoGetPosition(int *x, int *y) const = 0; + virtual void DoGetScreenPosition(int *x, int *y) const; + virtual void DoGetSize(int *width, int *height) const = 0; + virtual void DoGetClientSize(int *width, int *height) const = 0; // get the size which best suits the window: for a control, it would be // the minimal size which doesn't truncate the control, for a panel - the // same size as it would have after a call to Fit() virtual wxSize DoGetBestSize() const; + // this method can be overridden instead of DoGetBestSize() if it computes + // the best size of the client area of the window only, excluding borders + // (GetBorderSize() will be used to add them) + virtual wxSize DoGetBestClientSize() const { return wxDefaultSize; } + // this is the virtual function to be overriden in any derived class which // wants to change how SetSize() or Move() works - it is called by all // versions of these functions in the base class @@ -1103,18 +1671,40 @@ protected: // same as DoSetSize() for the client size virtual void DoSetClientSize(int width, int height) = 0; + virtual void DoSetSizeHints( int minW, int minH, + int maxW, int maxH, + int incW, int incH ); + + // return the total size of the window borders, i.e. the sum of the widths + // of the left and the right border in the x component of the returned size + // and the sum of the heights of the top and bottom borders in the y one + // + // NB: this is currently only implemented properly for wxMSW, wxGTK and + // wxUniv and doesn't behave correctly in the presence of scrollbars in + // the other ports + virtual wxSize DoGetBorderSize() const; + // move the window to the specified location and resize it: this is called // from both DoSetSize() and DoSetClientSize() and would usually just // reposition this window except for composite controls which will want to // arrange themselves inside the given rectangle + // + // Important note: the coordinates passed to this method are in parent's + // *window* coordinates and not parent's client coordinates (as the values + // passed to DoSetSize and returned by DoGetPosition are)! virtual void DoMoveWindow(int x, int y, int width, int height) = 0; + // centre the window in the specified direction on parent, note that + // wxCENTRE_ON_SCREEN shouldn't be specified here, it only makes sense for + // TLWs + virtual void DoCentre(int dir); + #if wxUSE_TOOLTIPS virtual void DoSetToolTip( wxToolTip *tip ); #endif // wxUSE_TOOLTIPS #if wxUSE_MENUS - virtual bool DoPopupMenu( wxMenu *menu, int x, int y ) = 0; + virtual bool DoPopupMenu(wxMenu *menu, int x, int y) = 0; #endif // wxUSE_MENUS // Makes an adjustment to the window position to make it relative to the @@ -1123,26 +1713,98 @@ protected: virtual void AdjustForParentClientOrigin(int& x, int& y, int sizeFlags = 0) const; + // implements the window variants + virtual void DoSetWindowVariant( wxWindowVariant variant ) ; + + + // really freeze/thaw the window (should have port-specific implementation) + virtual void DoFreeze() { } + virtual void DoThaw() { } + + + // Must be called when mouse capture is lost to send + // wxMouseCaptureLostEvent to windows on capture stack. + static void NotifyCaptureLost(); private: + // recursively call our own and our children OnEnabled() when the + // enabled/disabled status changed because a parent window had been + // enabled/disabled + void NotifyWindowOnEnableChange(bool enabled); + +#if wxUSE_MENUS + // temporary event handlers used by GetPopupMenuSelectionFromUser() + void InternalOnPopupMenu(wxCommandEvent& event); + void InternalOnPopupMenuUpdate(wxUpdateUIEvent& event); + + // implementation of the public GetPopupMenuSelectionFromUser() method + int DoGetPopupMenuSelectionFromUser(wxMenu& menu, int x, int y); +#endif // wxUSE_MENUS + + // layout the window children when its size changes unless this was + // explicitly disabled with SetAutoLayout(false) + void InternalOnSize(wxSizeEvent& event); - // contains the last id generated by NewControlId - static int ms_lastControlId; + // base for dialog unit conversion, i.e. average character size + wxSize GetDlgUnitBase() const; // the stack of windows which have captured the mouse - static struct WXDLLEXPORT wxWindowNext *ms_winCaptureNext; + static struct WXDLLIMPEXP_FWD_CORE wxWindowNext *ms_winCaptureNext; + + // the window that currently has mouse capture + static wxWindow *ms_winCaptureCurrent; + + // indicates if execution is inside CaptureMouse/ReleaseMouse + static bool ms_winCaptureChanging; + + + // number of Freeze() calls minus the number of Thaw() calls: we're frozen + // (i.e. not being updated) if it is positive + unsigned int m_freezeCount; + DECLARE_ABSTRACT_CLASS(wxWindowBase) - DECLARE_NO_COPY_CLASS(wxWindowBase) + wxDECLARE_NO_COPY_CLASS(wxWindowBase); DECLARE_EVENT_TABLE() }; + + +// Inlines for some deprecated methods +inline wxSize wxWindowBase::GetBestFittingSize() const +{ + return GetEffectiveMinSize(); +} + +inline void wxWindowBase::SetBestFittingSize(const wxSize& size) +{ + SetInitialSize(size); +} + +inline void wxWindowBase::SetBestSize(const wxSize& size) +{ + SetInitialSize(size); +} + +inline void wxWindowBase::SetInitialBestSize(const wxSize& size) +{ + SetInitialSize(size); +} + + // ---------------------------------------------------------------------------- // now include the declaration of wxWindow class // ---------------------------------------------------------------------------- // include the declaration of the platform-specific class -#if defined(__WXMSW__) +#if defined(__WXPALMOS__) + #ifdef __WXUNIVERSAL__ + #define wxWindowNative wxWindowPalm + #else // !wxUniv + #define wxWindowPalm wxWindow + #endif // wxUniv/!wxUniv + #include "wx/palmos/window.h" +#elif defined(__WXMSW__) #ifdef __WXUNIVERSAL__ #define wxWindowNative wxWindowMSW #else // !wxUniv @@ -1151,13 +1813,20 @@ private: #include "wx/msw/window.h" #elif defined(__WXMOTIF__) #include "wx/motif/window.h" -#elif defined(__WXGTK__) +#elif defined(__WXGTK20__) #ifdef __WXUNIVERSAL__ #define wxWindowNative wxWindowGTK #else // !wxUniv #define wxWindowGTK wxWindow #endif // wxUniv #include "wx/gtk/window.h" +#elif defined(__WXGTK__) + #ifdef __WXUNIVERSAL__ + #define wxWindowNative wxWindowGTK + #else // !wxUniv + #define wxWindowGTK wxWindow + #endif // wxUniv + #include "wx/gtk1/window.h" #elif defined(__WXX11__) #ifdef __WXUNIVERSAL__ #define wxWindowNative wxWindowX11 @@ -1166,19 +1835,18 @@ private: #endif // wxUniv #include "wx/x11/window.h" #elif defined(__WXMGL__) - #ifdef __WXUNIVERSAL__ - #define wxWindowNative wxWindowMGL - #else // !wxUniv - #define wxWindowMGL wxWindow - #endif // wxUniv + #define wxWindowNative wxWindowMGL #include "wx/mgl/window.h" +#elif defined(__WXDFB__) + #define wxWindowNative wxWindowDFB + #include "wx/dfb/window.h" #elif defined(__WXMAC__) #ifdef __WXUNIVERSAL__ #define wxWindowNative wxWindowMac #else // !wxUniv #define wxWindowMac wxWindow #endif // wxUniv - #include "wx/mac/window.h" + #include "wx/osx/window.h" #elif defined(__WXCOCOA__) #ifdef __WXUNIVERSAL__ #define wxWindowNative wxWindowCocoa @@ -1212,7 +1880,7 @@ private: inline wxWindow *wxWindowBase::GetGrandParent() const { - return m_parent ? m_parent->GetParent() : (wxWindow *)NULL; + return m_parent ? m_parent->GetParent() : NULL; } // ---------------------------------------------------------------------------- @@ -1221,30 +1889,33 @@ inline wxWindow *wxWindowBase::GetGrandParent() const // Find the wxWindow at the current mouse position, also returning the mouse // position. -WXDLLEXPORT extern wxWindow* wxFindWindowAtPointer(wxPoint& pt); +extern WXDLLIMPEXP_CORE wxWindow* wxFindWindowAtPointer(wxPoint& pt); // Get the current mouse position. -WXDLLEXPORT extern wxPoint wxGetMousePosition(); +extern WXDLLIMPEXP_CORE wxPoint wxGetMousePosition(); // get the currently active window of this application or NULL -WXDLLEXPORT extern wxWindow *wxGetActiveWindow(); +extern WXDLLIMPEXP_CORE wxWindow *wxGetActiveWindow(); // get the (first) top level parent window -WXDLLEXPORT wxWindow* wxGetTopLevelParent(wxWindow *win); +WXDLLIMPEXP_CORE wxWindow* wxGetTopLevelParent(wxWindow *win); -// deprecated (doesn't start with 'wx' prefix), use wxWindow::NewControlId() -inline int NewControlId() { return wxWindowBase::NewControlId(); } +#if WXWIN_COMPATIBILITY_2_6 + // deprecated (doesn't start with 'wx' prefix), use wxWindow::NewControlId() + wxDEPRECATED( wxWindowID NewControlId() ); + inline wxWindowID NewControlId() { return wxWindowBase::NewControlId(); } +#endif // WXWIN_COMPATIBILITY_2_6 #if wxUSE_ACCESSIBILITY // ---------------------------------------------------------------------------- // accessible object for windows // ---------------------------------------------------------------------------- -class WXDLLEXPORT wxWindowAccessible: public wxAccessible +class WXDLLIMPEXP_CORE wxWindowAccessible: public wxAccessible { public: wxWindowAccessible(wxWindow* win): wxAccessible(win) { if (win) win->SetAccessible(this); } - virtual ~wxWindowAccessible() {}; + virtual ~wxWindowAccessible() {} // Overridables @@ -1317,6 +1988,7 @@ public: // If this object has the focus, child should be 'this'. virtual wxAccStatus GetFocus(int* childId, wxAccessible** child); +#if wxUSE_VARIANT // Gets a variant representing the selected children // of this object. // Acceptable values: @@ -1326,11 +1998,10 @@ public: // or 0 if this object is selected (GetType() == wxT("long") // - a "void*" pointer to a wxAccessible child object virtual wxAccStatus GetSelections(wxVariant* selections); +#endif // wxUSE_VARIANT }; #endif // wxUSE_ACCESSIBILITY -#endif - // _WX_WINDOW_H_BASE_ - +#endif // _WX_WINDOW_H_BASE_