fixing warning and compile error against 10.4

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

diff --git a/include/wx/containr.h b/include/wx/containr.h
index 3e84da9384f1298e39b02b0ed9da4dd76a30bce4..594af01367b3466c2261a8fb0f46ce759a17051e 100644 (file)
--- a/include/wx/containr.h
+++ b/include/wx/containr.h
@@ -13,18 +13,14 @@
 #ifndef _WX_CONTAINR_H_
 #define _WX_CONTAINR_H_
 
 #ifndef _WX_CONTAINR_H_
 #define _WX_CONTAINR_H_
 

-#ifdef __GNUG__
-    #pragma interface "containr.h"
-#endif
+#include "wx/defs.h"

 
 

-class WXDLLEXPORT wxFocusEvent;
-class WXDLLEXPORT wxNavigationKeyEvent;
-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
 
 /*
    Implementation note: wxControlContainer is not a real mix-in but rather

-   a class meant to be agregated with (and not inherited from). Although
+   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
    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


@@ -32,33 +28,64 @@ class WXDLLEXPORT wxWindowBase;
  */
 
 // ----------------------------------------------------------------------------
  */
 
 // ----------------------------------------------------------------------------

-// wxControlContainer
+// wxControlContainerBase: common part used in both native and generic cases

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-class WXDLLEXPORT wxControlContainer
+class WXDLLIMPEXP_CORE wxControlContainerBase

 {
 public:
 {
 public:

-    // ctors and such
-    wxControlContainer(wxWindow *winParent);
+    // default ctor, SetContainerWindow() must be called later
+    wxControlContainerBase()
+    {
+        m_winParent = NULL;

 
 

-    wxWindow *GetDefaultItem() const { return m_winDefault; }
-    wxWindow *SetDefaultItem(wxWindow *win)
-        { wxWindow *winOld = m_winDefault; m_winDefault = win; return winOld; }
+        // 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 SetLastFocus(wxWindow *win);
+    void SetContainerWindow(wxWindow *winParent)
+    {
+        wxASSERT_MSG( !m_winParent, wxT("shouldn't be called twice") );

 
 

-    // the methods to be called from the window event handlers
-    void HandleOnNavigationKey(wxNavigationKeyEvent& event);
-    void HandleOnFocus(wxFocusEvent& event);
-    void HandleOnWindowDestroy(wxWindowBase *child);
+        m_winParent = winParent;
+    }

 
 

-    // should be called from SetFocus(), returns FALSE if we did nothing with
+    // should be called from SetFocus(), returns false if we did nothing with

     // the focus and the default processing should take place
     bool DoSetFocus();
 
     // 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; }
+
+    // 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:
     // set the focus to the child which had it the last time
 protected:
     // set the focus to the child which had it the last time

-    bool SetFocusToChild();
+    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;
 
     // the parent window we manage the children for
     wxWindow *m_winParent;


@@ -66,12 +93,130 @@ protected:
     // the child which had the focus last time this panel was activated
     wxWindow *m_winLastFocused;
 
     // the child which had the focus last time this panel was activated
     wxWindow *m_winLastFocused;
 

-    // a default window (e.g. a button) or NULL
-    wxWindow *m_winDefault;
+private:
+    // value returned by AcceptsFocus(), should be changed using SetCanFocus()
+    // only
+    bool m_acceptsFocus;
+
+    // a guard against infinite recursion
+    bool m_inSetFocus;

 };
 
 };
 

-// this function is for wxWindows internal use only
-extern bool wxSetFocusToChild(wxWindow *win, wxWindow **child);
+// 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 SetFocus();                                                  \
+    void SetFocusIgnoringChildren();                                          \
+    void AcceptFocus(bool acceptFocus)                                        \
+    {                                                                         \
+        m_container.SetCanFocus(acceptFocus);                                 \
+    }                                                                         \
+                                                                              \
+protected:                                                                    \
+    wxControlContainer m_container
+
+// this macro must be used in the derived class ctor
+#define WX_INIT_CONTROL_CONTAINER() \
+    m_container.SetContainerWindow(this)
+
+// common part of WX_DELEGATE_TO_CONTROL_CONTAINER in the native and generic
+// cases, must be used in the wxWindow-derived class implementation
+#define WX_DELEGATE_TO_CONTROL_CONTAINER_BASE(classname, basename)            \
+    void classname::AddChild(wxWindowBase *child)                             \
+    {                                                                         \
+        basename::AddChild(child);                                            \
+                                                                              \
+        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::AcceptsFocusFromKeyboard() const                          \
+    {                                                                         \
+        return m_container.AcceptsFocusFromKeyboard();                        \
+    }
+
+#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();
+};
+
+#define WX_EVENT_TABLE_CONTROL_CONTAINER(classname)
+
+#define WX_DECLARE_CONTROL_CONTAINER WX_DECLARE_CONTROL_CONTAINER_BASE
+
+#define WX_DELEGATE_TO_CONTROL_CONTAINER(classname, basename)                 \
+    WX_DELEGATE_TO_CONTROL_CONTAINER_BASE(classname, basename)                \
+                                                                              \
+    void classname::RemoveChild(wxWindowBase *child)                          \
+    {                                                                         \
+        basename::RemoveChild(child);                                         \
+                                                                              \
+        m_container.UpdateCanFocus();                                         \
+    }                                                                         \
+                                                                              \
+    void classname::SetFocusIgnoringChildren()                                \
+    {                                                                         \
+        basename::SetFocus();                                                 \
+    }
+
+#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);
+};

 
 // ----------------------------------------------------------------------------
 // macros which may be used by the classes wishing to implement TAB navigation
 
 // ----------------------------------------------------------------------------
 // macros which may be used by the classes wishing to implement TAB navigation


@@ -79,18 +224,13 @@ extern bool wxSetFocusToChild(wxWindow *win, wxWindow **child);
 // ----------------------------------------------------------------------------
 
 // declare the methods to be forwarded
 // ----------------------------------------------------------------------------
 
 // declare the methods to be forwarded

-#define WX_DECLARE_CONTROL_CONTAINER() \
-public: \
-    void OnNavigationKey(wxNavigationKeyEvent& event); \
-    void OnFocus(wxFocusEvent& event); \
-    virtual void OnChildFocus(wxChildFocusEvent& event); \
-    virtual void SetFocus(); \
-    virtual void RemoveChild(wxWindowBase *child); \
-    virtual wxWindow *GetDefaultItem() const; \
-    virtual wxWindow *SetDefaultItem(wxWindow *child); \
-\
-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) \


@@ -99,44 +239,42 @@ protected: \
     EVT_NAVIGATION_KEY(classname::OnNavigationKey)
 
 // implement the methods forwarding to the wxControlContainer
     EVT_NAVIGATION_KEY(classname::OnNavigationKey)
 
 // implement the methods forwarding to the wxControlContainer

-#define WX_DELEGATE_TO_CONTROL_CONTAINER(classname)  \
-wxWindow *classname::SetDefaultItem(wxWindow *child) \
-{ \
-    return m_container.SetDefaultItem(child); \
-} \
- \
-wxWindow *classname::GetDefaultItem() const \
-{ \
-    return m_container.GetDefaultItem(); \
-} \
- \
-void classname::OnNavigationKey( wxNavigationKeyEvent& event ) \
-{ \
-    m_container.HandleOnNavigationKey(event); \
-} \
- \
-void classname::RemoveChild(wxWindowBase *child) \
-{ \
-    m_container.HandleOnWindowDestroy(child); \
- \
-    wxWindow::RemoveChild(child); \
-} \
- \
-void classname::SetFocus() \
-{ \
-    if ( !m_container.DoSetFocus() ) \
-        wxWindow::SetFocus(); \
-} \
- \
-void classname::OnChildFocus(wxChildFocusEvent& event) \
-{ \
-    m_container.SetLastFocus(event.GetWindow()); \
-} \
- \
-void classname::OnFocus(wxFocusEvent& event) \
-{ \
-    m_container.HandleOnFocus(event); \
-}
+#define WX_DELEGATE_TO_CONTROL_CONTAINER(classname, basename)                 \
+    WX_DELEGATE_TO_CONTROL_CONTAINER_BASE(classname, basename)                \
+                                                                              \
+    void classname::RemoveChild(wxWindowBase *child)                          \
+    {                                                                         \
+        m_container.HandleOnWindowDestroy(child);                             \
+                                                                              \
+        basename::RemoveChild(child);                                         \
+                                                                              \
+        m_container.UpdateCanFocus();                                         \
+    }                                                                         \
+                                                                              \
+    void classname::OnNavigationKey( wxNavigationKeyEvent& event )            \
+    {                                                                         \
+        m_container.HandleOnNavigationKey(event);                             \
+    }                                                                         \
+                                                                              \
+    void classname::SetFocusIgnoringChildren()                                \
+    {                                                                         \
+        basename::SetFocus();                                                 \
+    }                                                                         \
+                                                                              \
+    void classname::OnChildFocus(wxChildFocusEvent& event)                    \
+    {                                                                         \
+        m_container.SetLastFocus(event.GetWindow());                          \
+        event.Skip();                                                         \
+    }                                                                         \
+                                                                              \
+    void classname::OnFocus(wxFocusEvent& event)                              \
+    {                                                                         \
+        m_container.HandleOnFocus(event);                                     \
+    }
+
+#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_