]> git.saurik.com Git - wxWidgets.git/blobdiff - include/wx/containr.h
Implement SelectAll for OSX WebKit.
[wxWidgets.git] / include / wx / containr.h
index e738d679070cd0f79656d639821b8353ffa7c41f..7cb13e8fc10e8a347e7934551055e8e28eb2e5c9 100644 (file)
@@ -1,12 +1,11 @@
 ///////////////////////////////////////////////////////////////////////////////
 // Name:        wx/containr.h
 ///////////////////////////////////////////////////////////////////////////////
 // Name:        wx/containr.h
-// Purpose:     wxControlContainer class declration: a "mix-in" class which
-//              implements the TAB navigation between the controls
+// Purpose:     wxControlContainer and wxNavigationEnabled declarations
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     06.08.01
 // RCS-ID:      $Id$
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     06.08.01
 // RCS-ID:      $Id$
-// Copyright:   (c) 2001 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
+// Copyright:   (c) 2001, 2011 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
 // Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 
 
 #include "wx/defs.h"
 
 
 #include "wx/defs.h"
 
-class WXDLLEXPORT wxWindow;
-class WXDLLEXPORT wxWindowBase;
+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
-   logically it should be a mix-in, doing it like this has no advantage from
-   the point of view of the existing code but does have some problems (we'd
-   need to play tricks with event handlers which may be difficult to do
-   safely). The price we pay for this simplicity is the ugly macros below.
+    This header declares wxControlContainer class however it's not a real
+    container of controls but rather just a helper used to implement TAB
+    navigation among the window children. You should rarely need to use it
+    directly, derive from the documented public wxNavigationEnabled<> class to
+    implement TAB navigation in a custom composite window.
  */
 
 // ----------------------------------------------------------------------------
 // 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
@@ -42,15 +40,22 @@ 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)
     {
-        wxASSERT_MSG( !m_winParent, _T("shouldn't be called twice") );
+        wxASSERT_MSG( !m_winParent, wxT("shouldn't be called twice") );
 
         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);
 
     // should be called when we decide that we should [stop] accepting focus
     void SetCanFocus(bool acceptsFocus);
 
@@ -63,33 +68,206 @@ public:
     // wxListCtrl) and so should get focus for ourselves
     bool AcceptsFocusRecursively() const { return true; }
 
     // wxListCtrl) and so should get focus for ourselves
     bool AcceptsFocusRecursively() const { return true; }
 
-    // call this when the number of children of the window changes
-    //
-    // note that we have any children, this panel (used just as container for
-    // them) shouldn't get focus for itself
+    // 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:
     void UpdateCanFocus() { SetCanFocus(!HasAnyFocusableChildren()); }
 
 protected:
+    // 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;
 
     // the parent window we manage the children for
     wxWindow *m_winParent;
 
     // return true if we have any children accepting focus
     bool HasAnyFocusableChildren() const;
 
     // 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;
 private:
     // value returned by AcceptsFocus(), should be changed using SetCanFocus()
     // only
     bool m_acceptsFocus;
+
+    // a guard against infinite recursion
+    bool m_inSetFocus;
+};
+
+#ifdef wxHAS_NATIVE_TAB_TRAVERSAL
+
+// ----------------------------------------------------------------------------
+// wxControlContainer for native TAB navigation
+// ----------------------------------------------------------------------------
+
+// this must be a real class as we forward-declare it elsewhere
+class WXDLLIMPEXP_CORE wxControlContainer : public wxControlContainerBase
+{
+protected:
+    // set the focus to the child which had it the last time
+    virtual bool SetFocusToChild();
+};
+
+#else // !wxHAS_NATIVE_TAB_TRAVERSAL
+
+class WXDLLIMPEXP_FWD_CORE wxFocusEvent;
+class WXDLLIMPEXP_FWD_CORE wxNavigationKeyEvent;
+
+// ----------------------------------------------------------------------------
+// wxControlContainer for TAB navigation implemented in wx itself
+// ----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_CORE wxControlContainer : public wxControlContainerBase
+{
+public:
+    // default ctor, SetContainerWindow() must be called later
+    wxControlContainer();
+
+    // the methods to be called from the window event handlers
+    void HandleOnNavigationKey(wxNavigationKeyEvent& event);
+    void HandleOnFocus(wxFocusEvent& event);
+    void HandleOnWindowDestroy(wxWindowBase *child);
+
+    // called from OnChildFocus() handler, i.e. when one of our (grand)
+    // children gets the focus
+    void SetLastFocus(wxWindow *win);
+
+protected:
+
+    wxDECLARE_NO_COPY_CLASS(wxControlContainer);
+};
+
+#endif // wxHAS_NATIVE_TAB_TRAVERSAL/!wxHAS_NATIVE_TAB_TRAVERSAL
+
+// this function is for wxWidgets internal use only
+extern bool wxSetFocusToChild(wxWindow *win, wxWindow **child);
+
+// ----------------------------------------------------------------------------
+// wxNavigationEnabled: Derive from this class to support keyboard navigation
+// among window children in a wxWindow-derived class. The details of this class
+// don't matter, you just need to derive from it to make navigation work.
+// ----------------------------------------------------------------------------
+
+// The template parameter W must be a wxWindow-derived class.
+template <class W>
+class wxNavigationEnabled : public W
+{
+public:
+    typedef W BaseWindowClass;
+
+    wxNavigationEnabled()
+    {
+        m_container.SetContainerWindow(this);
+
+#ifndef wxHAS_NATIVE_TAB_TRAVERSAL
+        Connect(wxEVT_NAVIGATION_KEY,
+                wxNavigationKeyEventHandler(wxNavigationEnabled::OnNavigationKey));
+
+        Connect(wxEVT_SET_FOCUS,
+                wxFocusEventHandler(wxNavigationEnabled::OnFocus));
+
+        Connect(wxEVT_CHILD_FOCUS,
+                wxChildFocusEventHandler(wxNavigationEnabled::OnChildFocus));
+#endif // !wxHAS_NATIVE_TAB_TRAVERSAL
+    }
+
+    virtual bool AcceptsFocus() const
+    {
+        return m_container.AcceptsFocus();
+    }
+
+    virtual bool AcceptsFocusRecursively() const
+    {
+        return m_container.AcceptsFocusRecursively();
+    }
+
+    virtual bool AcceptsFocusFromKeyboard() const
+    {
+        return m_container.AcceptsFocusFromKeyboard();
+    }
+
+    virtual void AddChild(wxWindowBase *child)
+    {
+        BaseWindowClass::AddChild(child);
+
+        m_container.UpdateCanFocus();
+    }
+
+    virtual void RemoveChild(wxWindowBase *child)
+    {
+#ifndef wxHAS_NATIVE_TAB_TRAVERSAL
+        m_container.HandleOnWindowDestroy(child);
+#endif // !wxHAS_NATIVE_TAB_TRAVERSAL
+
+        BaseWindowClass::RemoveChild(child);
+
+        m_container.UpdateCanFocus();
+    }
+
+    virtual void SetFocus()
+    {
+        if ( !m_container.DoSetFocus() )
+            BaseWindowClass::SetFocus();
+    }
+
+    void SetFocusIgnoringChildren()
+    {
+        BaseWindowClass::SetFocus();
+    }
+
+    void AcceptFocus(bool acceptFocus)
+    {
+        m_container.SetCanFocus(acceptFocus);
+    }
+
+protected:
+#ifndef wxHAS_NATIVE_TAB_TRAVERSAL
+    void OnNavigationKey(wxNavigationKeyEvent& event)
+    {
+        m_container.HandleOnNavigationKey(event);
+    }
+
+    void OnFocus(wxFocusEvent& event)
+    {
+        m_container.HandleOnFocus(event);
+    }
+
+    void OnChildFocus(wxChildFocusEvent& event)
+    {
+        m_container.SetLastFocus(event.GetWindow());
+        event.Skip();
+    }
+#endif // !wxHAS_NATIVE_TAB_TRAVERSAL
+
+    wxControlContainer m_container;
+
+
+    wxDECLARE_NO_COPY_TEMPLATE_CLASS(wxNavigationEnabled, W);
 };
 
 };
 
+// ----------------------------------------------------------------------------
+// Compatibility macros from now on, do NOT use them and preferably do not even
+// look at them.
+// ----------------------------------------------------------------------------
+
+#ifdef WXWIN_COMPATIBILITY_2_8
+
 // common part of WX_DECLARE_CONTROL_CONTAINER in the native and generic cases,
 // it should be used in the wxWindow-derived class declaration
 #define WX_DECLARE_CONTROL_CONTAINER_BASE()                                   \
 public:                                                                       \
     virtual bool AcceptsFocus() const;                                        \
     virtual bool AcceptsFocusRecursively() const;                             \
 // common part of WX_DECLARE_CONTROL_CONTAINER in the native and generic cases,
 // it should be used in the wxWindow-derived class declaration
 #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)                                        \
     {                                                                         \
@@ -118,23 +296,25 @@ protected:                                                                    \
         return m_container.AcceptsFocusRecursively();                         \
     }                                                                         \
                                                                               \
         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
 
-// ----------------------------------------------------------------------------
-// wxControlContainer for native TAB navigation
-// ----------------------------------------------------------------------------
-
-// this must be a real class as we forward-declare it elsewhere
-class WXDLLEXPORT wxControlContainer : public wxControlContainerBase
-{
-};
-
 #define WX_EVENT_TABLE_CONTROL_CONTAINER(classname)
 
 #define WX_DECLARE_CONTROL_CONTAINER WX_DECLARE_CONTROL_CONTAINER_BASE
 #define WX_EVENT_TABLE_CONTROL_CONTAINER(classname)
 
 #define WX_DECLARE_CONTROL_CONTAINER WX_DECLARE_CONTROL_CONTAINER_BASE
@@ -151,58 +331,11 @@ 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;
-
-// ----------------------------------------------------------------------------
-// wxControlContainer for TAB navigation implemented in wx itself
-// ----------------------------------------------------------------------------
-
-class WXDLLEXPORT wxControlContainer : public wxControlContainerBase
-{
-public:
-    // default ctor, SetContainerWindow() must be called later
-    wxControlContainer();
-
-    // the methods to be called from the window event handlers
-    void HandleOnNavigationKey(wxNavigationKeyEvent& event);
-    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();
-
-    // 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)
-};
-
-// 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
 #define WX_DECLARE_CONTROL_CONTAINER()                                        \
     WX_DECLARE_CONTROL_CONTAINER_BASE();                                      \
 // declare the methods to be forwarded
 #define WX_DECLARE_CONTROL_CONTAINER()                                        \
     WX_DECLARE_CONTROL_CONTAINER_BASE();                                      \
@@ -210,8 +343,7 @@ extern bool wxSetFocusToChild(wxWindow *win, wxWindow **child);
 public:                                                                       \
     void OnNavigationKey(wxNavigationKeyEvent& event);                        \
     void OnFocus(wxFocusEvent& event);                                        \
 public:                                                                       \
     void OnNavigationKey(wxNavigationKeyEvent& event);                        \
     void OnFocus(wxFocusEvent& event);                                        \
-    virtual void OnChildFocus(wxChildFocusEvent& event);                      \
-    virtual void SetFocus()
+    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) \
@@ -237,12 +369,6 @@ public:                                                                       \
         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();                                                 \
@@ -251,13 +377,16 @@ public:                                                                       \
     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
 
+#endif // WXWIN_COMPATIBILITY_2_8
+
 #endif // _WX_CONTAINR_H_
 #endif // _WX_CONTAINR_H_