fixing cases for mac / quickdraw

[wxWidgets.git] / include / wx / window.h

diff --git a/include/wx/window.h b/include/wx/window.h
index 58d24c8201e7b05889b1080861ec2fd5bd8b0b62..334df3c2b19be829e7098e0fbb48ebc0c5c1fef4 100644 (file)
--- a/include/wx/window.h
+++ b/include/wx/window.h
@@ -49,26 +49,39 @@
     #define wxUSE_MENUS_NATIVE wxUSE_MENUS
 #endif // __WXUNIVERSAL__/!__WXUNIVERSAL__
 
     #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
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // 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 WXDLLEXPORT wxScrollHelper;
+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 wxItemResource;
+class WXDLLIMPEXP_FWD_CORE wxLayoutConstraints;
+class WXDLLIMPEXP_FWD_CORE wxResourceTable;
+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
 
 #if wxUSE_ACCESSIBILITY

-class WXDLLEXPORT wxAccessible;
+class WXDLLIMPEXP_FWD_CORE wxAccessible;

 #endif
 
 // ----------------------------------------------------------------------------
 #endif
 
 // ----------------------------------------------------------------------------


@@ -104,6 +117,16 @@ enum wxWindowVariant
     #define wxWINDOW_DEFAULT_VARIANT wxT("window-default-variant")
 #endif
 
     #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
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // (pseudo)template list classes
 // ----------------------------------------------------------------------------


@@ -188,11 +211,6 @@ public:
     wxWindowVariant GetWindowVariant() const { return m_windowVariant; }
 
 
     wxWindowVariant GetWindowVariant() const { return m_windowVariant; }
 
 

-        // window id uniquely identifies the window among its siblings unless
-        // it is wxID_ANY which means "don't care"
-    void SetId( wxWindowID winid ) { m_windowId = winid; }
-    wxWindowID GetId() const { return m_windowId; }
-

         // 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
         // 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


@@ -206,15 +224,24 @@ public:
                                              wxCoord width,
                                              wxCoord widthTotal) const;
 
                                              wxCoord width,
                                              wxCoord widthTotal) const;
 

-        // 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; }
+
+        // window id uniquely identifies the window among its siblings unless
+        // it is wxID_ANY which means "don't care"
+    void SetId( wxWindowID winid ) { m_windowId = winid; }
+    wxWindowID GetId() const { return m_windowId; }
+
+        // returns true if this id value belong to the range reserved for the
+        // auto-generated (by NewControlId()) ids (they're always negative)
+    static bool IsAutoGeneratedId(wxWindowID id);
+
+        // generate a unique id (or count of them consecutively), returns a
+        // valid id in IsAutoGeneratedId() range or wxID_NONE if failed
+    static wxWindowID NewControlId(int count = 1);
+
+        // mark an id previously returned by NewControlId() as being unused any
+        // more so that it can be reused again for another control later
+    static void ReleaseControlId(wxWindowID id);
+

 
     // moving/resizing
     // ---------------
 
     // moving/resizing
     // ---------------


@@ -353,25 +380,19 @@ public:
     void CacheBestSize(const wxSize& size) const
         { wxConstCast(this, wxWindowBase)->m_bestSizeCache = size; }
 
     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.
 
         // 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.
 
         // 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
 
         // the generic centre function - centers the window on parent by`
         // default or on screen if it doesn't have parent or


@@ -390,9 +411,12 @@ public:
     virtual void FitInside();
 
 
     virtual void FitInside();
 
 

-        // Methods for setting size hints. This is only used
-        // for toplevel windows.
-        
+        // 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 )
     virtual void SetSizeHints( int minW, int minH,
                                int maxW = wxDefaultCoord, int maxH = wxDefaultCoord,
                                int incW = wxDefaultCoord, int incH = wxDefaultCoord )


@@ -403,10 +427,6 @@ public:
                        const wxSize& incSize=wxDefaultSize)
     { DoSetSizeHints(minSize.x, minSize.y, maxSize.x, maxSize.y, incSize.x, incSize.y); }
 
                        const wxSize& incSize=wxDefaultSize)
     { 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 ) { }
-

         // Methods for setting virtual size hints
         // FIXME: What are virtual size hints?
 
         // Methods for setting virtual size hints
         // FIXME: What are virtual size hints?
 


@@ -419,18 +439,23 @@ public:
     }
 
 
     }
 
 

-        // 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 ); }
+        // 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 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); }

 
 

-        // If a class doesn't override GetMinSize() or GetMaxSize()
-        // these values will be returned
-    int GetMinWidth() const { return m_minWidth; }
-    int GetMinHeight() const { return m_minHeight; }
-    int GetMaxWidth() const { return m_maxWidth; }
-    int GetMaxHeight() const { return m_maxHeight; }
-    void SetMinSize(const wxSize& minSize) { m_minWidth = minSize.x; m_minHeight = minSize.y; }
-    void SetMaxSize(const wxSize& maxSize) { m_maxWidth = maxSize.x; m_maxHeight = maxSize.y; }
+        // 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; }

 
 
         // Methods for accessing the virtual size of a window.  For most
 
 
         // Methods for accessing the virtual size of a window.  For most


@@ -471,6 +496,11 @@ public:
         return wxSize( wxMax( client.x, best.x ), wxMax( client.y, best.y ) );
     }
 
         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;
+
+

     // window state
     // ------------
 
     // window state
     // ------------
 


@@ -479,12 +509,55 @@ public:
     virtual bool Show( bool show = true );
     bool Hide() { return Show(false); }
 
     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; }
         // 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
 
     // 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


@@ -499,14 +572,21 @@ public:
     void SetWindowStyle( long style ) { SetWindowStyleFlag(style); }
     long GetWindowStyle() const { return GetWindowStyleFlag(); }
 
     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); }
 
     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; }
 
         // 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);
 
         // make the window modal (all other windows unresponsive)
     virtual void MakeModal(bool modal = true);
 


@@ -532,23 +612,63 @@ public:
 
     static wxWindow *DoFindFocus() /* = 0: implement in derived classes */;
 
 
     static wxWindow *DoFindFocus() /* = 0: implement in derived classes */;
 

-        // can this window have focus?
-    virtual bool AcceptsFocus() const { return IsShown() && IsEnabled(); }
+        // 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(); }
 
 
         // 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); }

 
         // move this window just before/after the specified one in tab order
         // (the other window must be our sibling!)
     void MoveBeforeInTabOrder(wxWindow *win)
 
         // 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)
     void MoveAfterInTabOrder(wxWindow *win)

-        { DoMoveInTabOrder(win, MoveAfter); }
+        { DoMoveInTabOrder(win, OrderAfter); }

 
 
     // parent/children relations
 
 
     // parent/children relations


@@ -561,6 +681,11 @@ public:
     // needed just for extended runtime
     const wxWindowList& GetWindowChildren() const { return GetChildren() ; }
 
     // 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;
         // get the parent or the parent of the parent
     wxWindow *GetParent() const { return m_parent; }
     inline wxWindow *GetGrandParent() const;


@@ -578,6 +703,11 @@ public:
     virtual void AddChild( wxWindowBase *child );
     virtual void RemoveChild( wxWindowBase *child );
 
     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
     // -------------------
 
     // looking for windows
     // -------------------
 


@@ -844,6 +974,13 @@ public:
                                const wxFont *theFont = (const wxFont *) NULL)
                                const = 0;
 
                                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
     // ------------------------
 
     // client <-> screen coords
     // ------------------------
 


@@ -895,10 +1032,19 @@ public:
     virtual void DoUpdateWindowUI(wxUpdateUIEvent& event) ;
 
 #if wxUSE_MENUS
     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); }
     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); }

+
+    // 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
 #endif // wxUSE_MENUS
 
     // override this method to return true for controls having multiple pages


@@ -942,6 +1088,20 @@ public:
     bool PageUp() { return ScrollPages(-1); }
     bool PageDown() { return ScrollPages(1); }
 
     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
     // ----------------------
 
     // context-sensitive help
     // ----------------------
 


@@ -1057,7 +1217,7 @@ public:
     void SetAccessible(wxAccessible* accessible) ;
 
     // Returns the accessible object.
     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() ;
 
     // Returns the accessible object, creating if necessary.
     wxAccessible* GetOrCreateAccessible() ;


@@ -1124,18 +1284,33 @@ public:
     // behaviour in the most common case
     virtual bool ShouldInheritColours() const { return false; }
 
     // 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);
 
 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
 
 #if wxUSE_CONSTRAINTS
     // satisfy the constraints for the windows but don't set the window sizes


@@ -1151,6 +1326,18 @@ protected:
     virtual wxWindow *GetMainWindowOfCompositeControl()
         { return (wxWindow*)this; }
 
     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;
     // the window id - a number which uniquely identifies a window among
     // its siblings unless it is wxID_ANY
     wxWindowID           m_windowId;


@@ -1222,6 +1409,10 @@ protected:
     // Layout() window automatically when its size changes?
     bool                 m_autoLayout:1;
 
     // Layout() window automatically when its size changes?
     bool                 m_autoLayout:1;
 

+    // true if we had automatically allocated the id value for this window
+    // (i.e. wxID_ANY had been passed to the ctor)
+    bool                 m_freeId:1;
+

     // window state
     bool                 m_isShown:1;
     bool                 m_isEnabled:1;
     // window state
     bool                 m_isShown:1;
     bool                 m_isEnabled:1;


@@ -1268,6 +1459,11 @@ protected:
     // specified) border for the window class
     virtual wxBorder GetDefaultBorder() const;
 
     // 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; }
     // 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; }


@@ -1278,18 +1474,8 @@ protected:
     // recalculated each time the value is needed.
     wxSize m_bestSizeCache;
 
     // 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

 
 
 
 
 
 


@@ -1344,6 +1530,10 @@ protected:
     // same as DoSetSize() for the client size
     virtual void DoSetClientSize(int width, int height) = 0;
 
     // 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
     // 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


@@ -1381,11 +1571,21 @@ protected:
     static void NotifyCaptureLost();
 
 private:
     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
 
     // 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
     // the window that currently has mouse capture
     static wxWindow *ms_winCaptureCurrent;
     // indicates if execution is inside CaptureMouse/ReleaseMouse


@@ -1396,6 +1596,30 @@ private:
     DECLARE_EVENT_TABLE()
 };
 
     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
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // now include the declaration of wxWindow class
 // ----------------------------------------------------------------------------