made wxHeaderColumnBase dtor virtual to avoid gcc warnings

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

diff --git a/include/wx/containr.h b/include/wx/containr.h
index e44b507a33a40f30f8161d0a4c7e81f8c0d06a4f..7dcf2a048e2bdb15b06be9e85a735d0e7f9e89f1 100644 (file)
--- a/include/wx/containr.h
+++ b/include/wx/containr.h
@@ -15,6 +15,9 @@
 
 #include "wx/defs.h"
 
 
 #include "wx/defs.h"
 

+class WXDLLIMPEXP_FWD_CORE wxWindow;
+class WXDLLIMPEXP_FWD_CORE wxWindowBase;
+

 /*
    Implementation note: wxControlContainer is not a real mix-in but rather
    a class meant to be aggregated with (and not inherited from). Although
 /*
    Implementation note: wxControlContainer is not a real mix-in but rather
    a class meant to be aggregated with (and not inherited from). Although


@@ -28,7 +31,7 @@
 // wxControlContainerBase: common part used in both native and generic cases
 // ----------------------------------------------------------------------------
 
 // wxControlContainerBase: common part used in both native and generic cases
 // ----------------------------------------------------------------------------
 

-class WXDLLEXPORT wxControlContainerBase
+class WXDLLIMPEXP_CORE wxControlContainerBase

 {
 public:
     // default ctor, SetContainerWindow() must be called later
 {
 public:
     // default ctor, SetContainerWindow() must be called later


@@ -39,7 +42,10 @@ public:
         // do accept focus initially, we'll stop doing it if/when any children
         // are added
         m_acceptsFocus = true;
         // do accept focus initially, we'll stop doing it if/when any children
         // are added
         m_acceptsFocus = true;

+        m_inSetFocus = false;
+        m_winLastFocused = NULL;

     }
     }

+    virtual ~wxControlContainerBase() {}

 
     void SetContainerWindow(wxWindow *winParent)
     {
 
     void SetContainerWindow(wxWindow *winParent)
     {


@@ -48,26 +54,52 @@ public:
         m_winParent = winParent;
     }
 
         m_winParent = winParent;
     }
 

+    // should be called from SetFocus(), returns false if we did nothing with
+    // the focus and the default processing should take place
+    bool DoSetFocus();
+

     // should be called when we decide that we should [stop] accepting focus
     void SetCanFocus(bool acceptsFocus);
 
     // returns whether we should accept focus ourselves or not
     bool AcceptsFocus() const { return m_acceptsFocus; }
 
     // should be called when we decide that we should [stop] accepting focus
     void SetCanFocus(bool acceptsFocus);
 
     // returns whether we should accept focus ourselves or not
     bool AcceptsFocus() const { return m_acceptsFocus; }
 

-    // call this when the number of children of the window changes
-    void UpdateCanFocus() { SetCanFocus(ShouldAcceptFocus()); }
+    // returns whether we or one of our children accepts focus: we always do
+    // because if we don't have any focusable children it probably means that
+    // we're not being used as a container at all (think of wxGrid or generic
+    // wxListCtrl) and so should get focus for ourselves
+    bool AcceptsFocusRecursively() const { return true; }
+
+    // this is used to determine whether we can accept focus when Tab or
+    // another navigation key is pressed -- we alsways can, for the same reason
+    // as mentioned above for AcceptsFocusRecursively()
+    bool AcceptsFocusFromKeyboard() const { return true; }
+
+    // Call this when the number of children of the window changes.
+    // If we have any children, this panel (used just as container for
+    // them) shouldn't get focus for itself.
+    void UpdateCanFocus() { SetCanFocus(!HasAnyFocusableChildren()); }

 
 protected:
 
 protected:

-    // return true if we should be focusable
-    bool ShouldAcceptFocus() const;
+    // set the focus to the child which had it the last time
+    virtual bool SetFocusToChild();
+
+    // return true if we have any children accepting focus
+    bool HasAnyFocusableChildren() const;

 
 

-private:

     // the parent window we manage the children for
     wxWindow *m_winParent;
 
     // the parent window we manage the children for
     wxWindow *m_winParent;
 

+    // the child which had the focus last time this panel was activated
+    wxWindow *m_winLastFocused;
+
+private:

     // value returned by AcceptsFocus(), should be changed using SetCanFocus()
     // only
     bool m_acceptsFocus;
     // value returned by AcceptsFocus(), should be changed using SetCanFocus()
     // only
     bool m_acceptsFocus;

+
+    // a guard against infinite recursion
+    bool m_inSetFocus;

 };
 
 // common part of WX_DECLARE_CONTROL_CONTAINER in the native and generic cases,
 };
 
 // common part of WX_DECLARE_CONTROL_CONTAINER in the native and generic cases,


@@ -75,8 +107,11 @@ private:
 #define WX_DECLARE_CONTROL_CONTAINER_BASE()                                   \
 public:                                                                       \
     virtual bool AcceptsFocus() const;                                        \
 #define WX_DECLARE_CONTROL_CONTAINER_BASE()                                   \
 public:                                                                       \
     virtual bool AcceptsFocus() const;                                        \

+    virtual bool AcceptsFocusRecursively() const;                             \
+    virtual bool AcceptsFocusFromKeyboard() const;                            \

     virtual void AddChild(wxWindowBase *child);                               \
     virtual void RemoveChild(wxWindowBase *child);                            \
     virtual void AddChild(wxWindowBase *child);                               \
     virtual void RemoveChild(wxWindowBase *child);                            \

+    virtual void SetFocus();                                                  \

     void SetFocusIgnoringChildren();                                          \
     void AcceptFocus(bool acceptFocus)                                        \
     {                                                                         \
     void SetFocusIgnoringChildren();                                          \
     void AcceptFocus(bool acceptFocus)                                        \
     {                                                                         \


@@ -100,12 +135,27 @@ protected:                                                                    \
         m_container.UpdateCanFocus();                                         \
     }                                                                         \
                                                                               \
         m_container.UpdateCanFocus();                                         \
     }                                                                         \
                                                                               \

+    bool classname::AcceptsFocusRecursively() const                           \
+    {                                                                         \
+        return m_container.AcceptsFocusRecursively();                         \
+    }                                                                         \
+                                                                              \
+    void classname::SetFocus()                                                \
+    {                                                                         \
+        if ( !m_container.DoSetFocus() )                                      \
+            basename::SetFocus();                                             \
+    }                                                                         \
+                                                                              \

     bool classname::AcceptsFocus() const                                      \
     {                                                                         \
         return m_container.AcceptsFocus();                                    \
     bool classname::AcceptsFocus() const                                      \
     {                                                                         \
         return m_container.AcceptsFocus();                                    \

+    }                                                                         \
+                                                                              \
+    bool classname::AcceptsFocusFromKeyboard() const                          \
+    {                                                                         \
+        return m_container.AcceptsFocusFromKeyboard();                        \

     }
 
     }
 

-

 #ifdef wxHAS_NATIVE_TAB_TRAVERSAL
 
 // ----------------------------------------------------------------------------
 #ifdef wxHAS_NATIVE_TAB_TRAVERSAL
 
 // ----------------------------------------------------------------------------


@@ -113,8 +163,11 @@ protected:                                                                    \
 // ----------------------------------------------------------------------------
 
 // this must be a real class as we forward-declare it elsewhere
 // ----------------------------------------------------------------------------
 
 // this must be a real class as we forward-declare it elsewhere

-class WXDLLEXPORT wxControlContainer : public wxControlContainerBase
+class WXDLLIMPEXP_CORE wxControlContainer : public wxControlContainerBase

 {
 {

+protected:
+    // set the focus to the child which had it the last time
+    virtual bool SetFocusToChild();

 };
 
 #define WX_EVENT_TABLE_CONTROL_CONTAINER(classname)
 };
 
 #define WX_EVENT_TABLE_CONTROL_CONTAINER(classname)


@@ -133,21 +186,19 @@ class WXDLLEXPORT wxControlContainer : public wxControlContainerBase
                                                                               \
     void classname::SetFocusIgnoringChildren()                                \
     {                                                                         \
                                                                               \
     void classname::SetFocusIgnoringChildren()                                \
     {                                                                         \

-        SetFocus();                                                           \
+        basename::SetFocus();                                                 \

     }
 
 #else // !wxHAS_NATIVE_TAB_TRAVERSAL
 
     }
 
 #else // !wxHAS_NATIVE_TAB_TRAVERSAL
 

-class WXDLLEXPORT wxFocusEvent;
-class WXDLLEXPORT wxNavigationKeyEvent;
-class WXDLLEXPORT wxWindow;
-class WXDLLEXPORT wxWindowBase;
+class WXDLLIMPEXP_FWD_CORE wxFocusEvent;
+class WXDLLIMPEXP_FWD_CORE wxNavigationKeyEvent;

 
 // ----------------------------------------------------------------------------
 // wxControlContainer for TAB navigation implemented in wx itself
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // wxControlContainer for TAB navigation implemented in wx itself
 // ----------------------------------------------------------------------------
 

-class WXDLLEXPORT wxControlContainer : public wxControlContainerBase
+class WXDLLIMPEXP_CORE wxControlContainer : public wxControlContainerBase

 {
 public:
     // default ctor, SetContainerWindow() must be called later
 {
 public:
     // default ctor, SetContainerWindow() must be called later


@@ -158,51 +209,28 @@ public:
     void HandleOnFocus(wxFocusEvent& event);
     void HandleOnWindowDestroy(wxWindowBase *child);
 
     void HandleOnFocus(wxFocusEvent& event);
     void HandleOnWindowDestroy(wxWindowBase *child);
 

-    // should be called from SetFocus(), returns false if we did nothing with
-    // the focus and the default processing should take place
-    bool DoSetFocus();
-
-    // can our child get the focus?
-    bool AcceptsFocus() const;
-

     // called from OnChildFocus() handler, i.e. when one of our (grand)
     // children gets the focus
     void SetLastFocus(wxWindow *win);
 
 protected:
     // called from OnChildFocus() handler, i.e. when one of our (grand)
     // children gets the focus
     void SetLastFocus(wxWindow *win);
 
 protected:

-    // set the focus to the child which had it the last time
-    bool SetFocusToChild();
-
-    // the child which had the focus last time this panel was activated
-    wxWindow *m_winLastFocused;
-
-    // a guard against infinite recursion
-    bool m_inSetFocus;

 
     DECLARE_NO_COPY_CLASS(wxControlContainer)
 };
 
 
     DECLARE_NO_COPY_CLASS(wxControlContainer)
 };
 

-// this function is for wxWidgets internal use only
-extern bool wxSetFocusToChild(wxWindow *win, wxWindow **child);
-

 // ----------------------------------------------------------------------------
 // macros which may be used by the classes wishing to implement TAB navigation
 // among their children
 // ----------------------------------------------------------------------------
 
 // declare the methods to be forwarded
 // ----------------------------------------------------------------------------
 // macros which may be used by the classes wishing to implement TAB navigation
 // among their children
 // ----------------------------------------------------------------------------
 
 // declare the methods to be forwarded

-#define WX_DECLARE_CONTROL_CONTAINER() \
-public: \
-    void OnNavigationKey(wxNavigationKeyEvent& event); \
-    void OnFocus(wxFocusEvent& event); \
-    void SetFocusIgnoringChildren(); \
-    virtual void OnChildFocus(wxChildFocusEvent& event); \
-    virtual void SetFocus(); \
-    virtual void RemoveChild(wxWindowBase *child); \
-    virtual bool AcceptsFocus() const; \
-\
-protected: \
-    wxControlContainer m_container
+#define WX_DECLARE_CONTROL_CONTAINER()                                        \
+    WX_DECLARE_CONTROL_CONTAINER_BASE();                                      \
+                                                                              \
+public:                                                                       \
+    void OnNavigationKey(wxNavigationKeyEvent& event);                        \
+    void OnFocus(wxFocusEvent& event);                                        \
+    virtual void OnChildFocus(wxChildFocusEvent& event)

 
 // implement the event table entries for wxControlContainer
 #define WX_EVENT_TABLE_CONTROL_CONTAINER(classname) \
 
 // implement the event table entries for wxControlContainer
 #define WX_EVENT_TABLE_CONTROL_CONTAINER(classname) \


@@ -228,12 +256,6 @@ protected: \
         m_container.HandleOnNavigationKey(event);                             \
     }                                                                         \
                                                                               \
         m_container.HandleOnNavigationKey(event);                             \
     }                                                                         \
                                                                               \

-    void classname::SetFocus()                                                \
-    {                                                                         \
-        if ( !m_container.DoSetFocus() )                                      \
-            basename::SetFocus();                                             \
-    }                                                                         \
-                                                                              \

     void classname::SetFocusIgnoringChildren()                                \
     {                                                                         \
         basename::SetFocus();                                                 \
     void classname::SetFocusIgnoringChildren()                                \
     {                                                                         \
         basename::SetFocus();                                                 \


@@ -242,13 +264,17 @@ protected: \
     void classname::OnChildFocus(wxChildFocusEvent& event)                    \
     {                                                                         \
         m_container.SetLastFocus(event.GetWindow());                          \
     void classname::OnChildFocus(wxChildFocusEvent& event)                    \
     {                                                                         \
         m_container.SetLastFocus(event.GetWindow());                          \

+        event.Skip();                                                         \

     }                                                                         \
                                                                               \
     void classname::OnFocus(wxFocusEvent& event)                              \
     {                                                                         \
         m_container.HandleOnFocus(event);                                     \
     }                                                                         \
                                                                               \
     void classname::OnFocus(wxFocusEvent& event)                              \
     {                                                                         \
         m_container.HandleOnFocus(event);                                     \

-    } 
+    }

 
 #endif // wxHAS_NATIVE_TAB_TRAVERSAL/!wxHAS_NATIVE_TAB_TRAVERSAL
 
 
 #endif // wxHAS_NATIVE_TAB_TRAVERSAL/!wxHAS_NATIVE_TAB_TRAVERSAL
 

+// this function is for wxWidgets internal use only
+extern bool wxSetFocusToChild(wxWindow *win, wxWindow **child);
+

 #endif // _WX_CONTAINR_H_
 #endif // _WX_CONTAINR_H_