X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/e71c530e030e5aee15f6cc925c8cd477aa351d13..28dd9a9d035b5435897d626d1b57b4308daa0371:/include/wx/window.h diff --git a/include/wx/window.h b/include/wx/window.h index 8f76c9e7e7..33d33ce50d 100644 --- a/include/wx/window.h +++ b/include/wx/window.h @@ -25,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,25 +49,37 @@ #define wxUSE_MENUS_NATIVE wxUSE_MENUS #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 // ---------------------------------------------------------------------------- @@ -102,6 +115,16 @@ enum wxWindowVariant #define wxWINDOW_DEFAULT_VARIANT wxT("window-default-variant") #endif +// valid values for Show/HideWithEffect() +enum wxShowEffect +{ + wxSHOW_EFFECT_ROLL, + wxSHOW_EFFECT_SLIDE, + wxSHOW_EFFECT_BLEND, + wxSHOW_EFFECT_EXPAND, + wxSHOW_EFFECT_MAX +}; + // ---------------------------------------------------------------------------- // (pseudo)template list classes // ---------------------------------------------------------------------------- @@ -180,9 +203,24 @@ public: 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 ; } + // 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 @@ -190,15 +228,22 @@ public: 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 // --------------- @@ -310,6 +355,10 @@ 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" in // most situations) @@ -328,31 +377,28 @@ public: *h = s.y; } + 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; } - // 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( GetBestSize() ); - return wxSize( wxMax( s.x, GetMinWidth() ), wxMax( s.y, GetMinHeight() ) ); - } // 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. - wxSize GetBestFittingSize() const; + 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 SetBestFittingSize(const wxSize& size=wxDefaultSize); + 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 @@ -370,46 +416,63 @@ public: // set virtual size to satisfy children virtual void FitInside(); - // set min/max size of the window + + // 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 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); - } + { 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); - } + { DoSetSizeHints(minSize.x, minSize.y, maxSize.x, maxSize.y, incSize.x, incSize.y); } - virtual void DoSetSizeHints(int minW, int minH, - int maxW = wxDefaultCoord, int maxH = wxDefaultCoord, - int incW = wxDefaultCoord, int incH = wxDefaultCoord ); - virtual void SetVirtualSizeHints( int minW, int minH, - int maxW = wxDefaultCoord, int maxH = wxDefaultCoord ); - void SetVirtualSizeHints( const wxSize& minSize, - const wxSize& maxSize=wxDefaultSize) - { - SetVirtualSizeHints(minSize.x, minSize.y, maxSize.x, maxSize.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 + - 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; } + // 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) { m_minWidth = minSize.x; m_minHeight = minSize.y; } + virtual void SetMaxSize(const wxSize& maxSize) { m_maxWidth = maxSize.x; m_maxHeight = maxSize.y; } - // Override this method to control the values given to Sizers etc. - virtual wxSize GetMaxSize() const { return wxSize( m_maxWidth, m_maxHeight ); } - virtual wxSize GetMinSize() const { return wxSize( m_minWidth, m_minHeight ); } + // 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; } - void SetMinSize(const wxSize& minSize) { SetSizeHints(minSize); } - void SetMaxSize(const wxSize& maxSize) { SetSizeHints(GetMinSize(), maxSize); } // Methods for accessing the virtual size of a window. For most // windows this is just the client area of the window, but for @@ -449,6 +512,19 @@ 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; } + // window state // ------------ @@ -457,12 +533,59 @@ 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 + // + // direction is only used with wxSHOW_EFFECT_ROLL and SLIDE values + virtual bool ShowWithEffect(wxShowEffect effect, + unsigned timeout = 0, + wxDirection dir = wxBOTTOM) + { + wxUnusedVar(effect); + wxUnusedVar(timeout); + wxUnusedVar(dir); + + return Show(); + } + + virtual bool HideWithEffect(wxShowEffect effect, + unsigned timeout = 0, + wxDirection dir = wxBOTTOM) + { + wxUnusedVar(effect); + wxUnusedVar(timeout); + wxUnusedVar(dir); + + return Hide(); + } + // returns true if window was enabled/disabled, false if nothing done virtual bool Enable( bool enable = true ); bool Disable() { return Enable(false); } virtual bool IsShown() const { return m_isShown; } - virtual bool IsEnabled() const { return m_isEnabled; } + // 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) @@ -473,14 +596,21 @@ public: 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); @@ -506,23 +636,73 @@ public: 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(); } - // navigates in the specified direction by sending a wxNavigationKeyEvent - virtual bool Navigate(int flags = wxNavigationKeyEvent::IsForward); + + // this is mostly a helper for the various functions using it below + bool CanBeFocused() const { return IsShown() && IsEnabled(); } + + // 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, MoveBefore); } + { DoMoveInTabOrder(win, OrderBefore); } void MoveAfterInTabOrder(wxWindow *win) - { DoMoveInTabOrder(win, MoveAfter); } + { DoMoveInTabOrder(win, OrderAfter); } // parent/children relations @@ -535,6 +715,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; @@ -552,6 +737,11 @@ 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 // ------------------- @@ -589,6 +779,13 @@ public: // be there) bool RemoveEventHandler(wxEvtHandler *handler); + // 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; + // validators // ---------- @@ -691,14 +888,26 @@ public: virtual void ClearBackground(); // freeze the window: don't redraw it until it is thawed - virtual void Freeze() { } + void Freeze() { if ( !m_freezeCount++ ) DoFreeze(); } // thaw the window: redraw it after it had been frozen - virtual void Thaw() { } + void Thaw() + { + wxASSERT_MSG( m_freezeCount, "Thaw() without matching Freeze()" ); + + if ( !--m_freezeCount ) + DoThaw(); + } + + // 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; } @@ -709,13 +918,17 @@ 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 // -------------------------- @@ -808,6 +1021,13 @@ public: const wxFont *theFont = (const wxFont *) NULL) const = 0; + wxSize GetTextExtent(const wxString& string) const + { + wxCoord w, h; + GetTextExtent(string, &w, &h); + return wxSize(w, h); + } + // client <-> screen coords // ------------------------ @@ -859,10 +1079,18 @@ public: virtual void DoUpdateWindowUI(wxUpdateUIEvent& event) ; #if wxUSE_MENUS + // show popup menu at the given position, generate events for the items + // selected in it bool PopupMenu(wxMenu *menu, const wxPoint& pos = wxDefaultPosition) - { return DoPopupMenu(menu, pos.x, pos.y); } - bool PopupMenu(wxMenu *menu, int x, int y) - { return DoPopupMenu(menu, x, y); } + { 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 @@ -906,6 +1134,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 // ---------------------- @@ -1021,12 +1263,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 // -------------- @@ -1082,18 +1330,33 @@ public: // 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; } + protected: // event handling specific to wxWindow virtual bool TryValidator(wxEvent& event); virtual bool TryParent(wxEvent& event); - // common part of MoveBefore/AfterInTabOrder() - enum MoveKind + enum WindowOrder { - MoveBefore, // insert before the given window - MoveAfter // insert after the given window + OrderBefore, // insert before the given window + OrderAfter // insert after the given window }; - virtual void DoMoveInTabOrder(wxWindow *win, MoveKind move); + + // 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 @@ -1109,9 +1372,21 @@ protected: virtual wxWindow *GetMainWindowOfCompositeControl() { return (wxWindow*)this; } + // 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 wxID_ANY - wxWindowID m_windowId; + wxWindowIDRef m_windowId; // the parent window of this window (or NULL) and the list of the children // of this window @@ -1213,10 +1488,7 @@ protected: // 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 ; @@ -1224,6 +1496,11 @@ protected: // specified) border for the window class virtual wxBorder GetDefaultBorder() const; + // 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; } @@ -1234,18 +1511,8 @@ protected: // recalculated each time the value is needed. wxSize m_bestSizeCache; - // keep the old name for compatibility, at least until all the internal - // usages of it are changed to SetBestFittingSize - void SetBestSize(const wxSize& size) { SetBestFittingSize(size); } - - // set the initial window size if none is given (i.e. at least one of the - // components of the size passed to ctor/Create() is wxDefaultCoord) - // - // normally just calls SetBestSize() for controls, but can be overridden - // not to do it for the controls which have to do some additional - // initialization (e.g. add strings to list box) before their best size - // can be accurately calculated - virtual void SetInitialBestSize(const wxSize& WXUNUSED(size)) {} + wxDEPRECATED( void SetBestSize(const wxSize& size) ); // use SetInitialSize + wxDEPRECATED( virtual void SetInitialBestSize(const wxSize& size) ); // use SetInitialSize @@ -1282,14 +1549,6 @@ protected: // same size as it would have after a call to Fit() virtual wxSize DoGetBestSize() const; - // called from DoGetBestSize() to convert best virtual size (returned by - // the window sizer) to the best size for the window itself; this is - // overridden at wxScrolledWindow level to clump down virtual size to real - virtual wxSize GetWindowSizeForVirtualSize(const wxSize& size) const - { - return size; - } - // 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 @@ -1300,10 +1559,18 @@ 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 ); + // 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 @@ -1328,18 +1595,74 @@ protected: // 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: - // contains the last id generated by NewControlId - static int ms_lastControlId; + // 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 handler used by GetPopupMenuSelectionFromUser() + void InternalOnPopupMenu(wxCommandEvent& event); + + // implementation of the public GetPopupMenuSelectionFromUser() method + int DoGetPopupMenuSelectionFromUser(wxMenu& menu, int x, int y); +#endif // wxUSE_MENUS // 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) 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 // ---------------------------------------------------------------------------- @@ -1383,12 +1706,11 @@ 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 @@ -1451,8 +1773,8 @@ WXDLLEXPORT wxWindow* wxGetTopLevelParent(wxWindow *win); #if WXWIN_COMPATIBILITY_2_6 // deprecated (doesn't start with 'wx' prefix), use wxWindow::NewControlId() - wxDEPRECATED( int NewControlId() ); - inline int NewControlId() { return wxWindowBase::NewControlId(); } + wxDEPRECATED( wxWindowID NewControlId() ); + inline wxWindowID NewControlId() { return wxWindowBase::NewControlId(); } #endif // WXWIN_COMPATIBILITY_2_6 #if wxUSE_ACCESSIBILITY @@ -1537,6 +1859,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: @@ -1546,6 +1869,7 @@ 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