fix getting tooltip colors for GTK 2.11

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

diff --git a/include/wx/window.h b/include/wx/window.h
index ae32b4736832f93678c5cf63e276de55ad951d14..53aad4df97f478fdbced90454f74aae6ade14331 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
 
 // ----------------------------------------------------------------------------


@@ -353,25 +366,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


@@ -389,26 +396,29 @@ public:
         // set virtual size to satisfy children
     virtual void FitInside();
 
         // 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 )
     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)
 
     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 DoSetSizeHints( int minW, int minH,
+                                 int maxW, int maxH,
+                                 int incW, int incH );
+
+        // Methods for setting virtual size hints
+        // FIXME: What are virtual size hints?

 
     virtual void SetVirtualSizeHints( int minW, int minH,
                                       int maxW = wxDefaultCoord, int maxH = wxDefaultCoord );
 
     virtual void SetVirtualSizeHints( int minW, int minH,
                                       int maxW = wxDefaultCoord, int maxH = wxDefaultCoord );


@@ -418,17 +428,25 @@ public:
         SetVirtualSizeHints(minSize.x, minSize.y, maxSize.x, maxSize.y);
     }
 
         SetVirtualSizeHints(minSize.x, minSize.y, maxSize.x, maxSize.y);
     }
 

-    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; }

 
 

-        // 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); }
+
+        // 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
 
         // Methods for accessing the virtual size of a window.  For most
         // windows this is just the client area of the window, but for


@@ -468,6 +486,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
     // ------------
 


@@ -481,7 +504,21 @@ public:
     bool Disable() { return Enable(false); }
 
     virtual bool IsShown() const { return m_isShown; }
     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


@@ -496,14 +533,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);
 


@@ -529,16 +573,56 @@ 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!)
 
         // move this window just before/after the specified one in tab order
         // (the other window must be our sibling!)


@@ -575,6 +659,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
     // -------------------
 


@@ -725,6 +814,9 @@ public:
         // adjust DC for drawing on this window
     virtual void PrepareDC( wxDC & WXUNUSED(dc) ) { }
 
         // 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; }
         // the update region of the window contains the areas which must be
         // repainted by the program
     const wxRegion& GetUpdateRegion() const { return m_updateRegion; }


@@ -838,6 +930,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
     // ------------------------
 


@@ -1051,7 +1150,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() ;


@@ -1118,6 +1217,13 @@ 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
+    virtual bool CanApplyThemeBorder() const { return true; }
+

 protected:
     // event handling specific to wxWindow
     virtual bool TryValidator(wxEvent& event);
 protected:
     // event handling specific to wxWindow
     virtual bool TryValidator(wxEvent& event);


@@ -1131,6 +1237,10 @@ protected:
     };
     virtual void DoMoveInTabOrder(wxWindow *win, MoveKind move);
 
     };
     virtual void DoMoveInTabOrder(wxWindow *win, MoveKind 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();
 #if wxUSE_CONSTRAINTS
     // satisfy the constraints for the windows but don't set the window sizes
     void SatisfyConstraints();


@@ -1145,6 +1255,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;


@@ -1262,6 +1384,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 wxWindowBase::GetDefaultBorder(); }
+

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


@@ -1272,18 +1399,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

 
 
 
 
 
 


@@ -1375,11 +1492,17 @@ protected:
     static void NotifyCaptureLost();
 
 private:
     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);
+
+

     // contains the last id generated by NewControlId
     static int ms_lastControlId;
 
     // the stack of windows which have captured the mouse
     // contains the last id generated by NewControlId
     static int ms_lastControlId;
 
     // 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


@@ -1390,6 +1513,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
 // ----------------------------------------------------------------------------