don't crash if (char*)c_str() is used twice in a row on the same string and both...

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

diff --git a/include/wx/containr.h b/include/wx/containr.h
index ca1fad02aee01b8cccf161f390cada0ce142ff50..375caff127dec91b01a65a124a0d4f3898fa2383 100644 (file)
--- a/include/wx/containr.h
+++ b/include/wx/containr.h
@@ -7,24 +7,20 @@
 // Created:     06.08.01
 // RCS-ID:      $Id$
 // Copyright:   (c) 2001 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
 // Created:     06.08.01
 // RCS-ID:      $Id$
 // Copyright:   (c) 2001 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>

-// Licence:     wxWidgets licence
+// Licence:     wxWindows licence

 ///////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_CONTAINR_H_
 #define _WX_CONTAINR_H_
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_CONTAINR_H_
 #define _WX_CONTAINR_H_
 

-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-    #pragma interface "containr.h"
-#endif
+#include "wx/defs.h"

 
 

-class WXDLLEXPORT wxFocusEvent;
-class WXDLLEXPORT wxNavigationKeyEvent;

 class WXDLLEXPORT wxWindow;
 class WXDLLEXPORT wxWindowBase;
 
 /*
    Implementation note: wxControlContainer is not a real mix-in but rather
 class WXDLLEXPORT wxWindow;
 class WXDLLEXPORT wxWindowBase;
 
 /*
    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,46 +28,141 @@ class WXDLLEXPORT wxWindowBase;
  */
 
 // ----------------------------------------------------------------------------
  */
 
 // ----------------------------------------------------------------------------

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

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

-class WXDLLEXPORT wxControlContainer
+class WXDLLEXPORT wxControlContainerBase

 {
 public:
 {
 public:

-    // ctors and such
-    wxControlContainer(wxWindow *winParent = NULL);
-    void SetContainerWindow(wxWindow *winParent) { m_winParent = winParent; }
+    // default ctor, SetContainerWindow() must be called later
+    wxControlContainerBase()
+    {
+        m_winParent = NULL;
+
+        // do accept focus initially, we'll stop doing it if/when any children
+        // are added
+        m_acceptsFocus = true;
+    }
+
+    void SetContainerWindow(wxWindow *winParent)
+    {
+        wxASSERT_MSG( !m_winParent, _T("shouldn't be called twice") );
+
+        m_winParent = winParent;
+    }
+
+    // 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()); }
+
+protected:
+    // return true if we should be focusable
+    bool ShouldAcceptFocus() const;
+
+    // the parent window we manage the children for
+    wxWindow *m_winParent;
+
+private:
+    // value returned by AcceptsFocus(), should be changed using SetCanFocus()
+    // only
+    bool m_acceptsFocus;
+};
+
+// 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 void AddChild(wxWindowBase *child);                               \
+    virtual void RemoveChild(wxWindowBase *child);                            \
+    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::AcceptsFocus() const                                      \
+    {                                                                         \
+        return m_container.AcceptsFocus();                                    \
+    }
+
+
+#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)

 
 

-    // default item access: we have a permanent default item which is the one
-    // set by the user code but we may also have a temporary default item which
-    // would be chosen if the user pressed "Enter" now but the default action
-    // reverts to the "permanent" default as soon as this temporary default
-    // item lsoes focus
+#define WX_DECLARE_CONTROL_CONTAINER WX_DECLARE_CONTROL_CONTAINER_BASE

 
 

-    // get the default item, temporary or permanent
-    wxWindow *GetDefaultItem() const
-        { return m_winTmpDefault ? m_winTmpDefault : m_winDefault; }
+#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()                                \
+    {                                                                         \
+        SetFocus();                                                           \
+    }

 
 

-    // set the permanent default item, return its old value
-    wxWindow *SetDefaultItem(wxWindow *win)
-        { wxWindow *winOld = m_winDefault; m_winDefault = win; return winOld; }
+#else // !wxHAS_NATIVE_TAB_TRAVERSAL
+
+class WXDLLEXPORT wxFocusEvent;
+class WXDLLEXPORT wxNavigationKeyEvent;
+
+// ----------------------------------------------------------------------------
+// wxControlContainer for TAB navigation implemented in wx itself
+// ----------------------------------------------------------------------------

 
 

-    // set a temporary default item, SetTmpDefaultItem(NULL) should be called
-    // soon after a call to SetTmpDefaultItem(window)
-    void SetTmpDefaultItem(wxWindow *win) { m_winTmpDefault = win; }
+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);
 
 
     // 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
+    // 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();
 

-    // 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);
     // called from OnChildFocus() handler, i.e. when one of our (grand)
     // children gets the focus
     void SetLastFocus(wxWindow *win);


@@ -80,18 +171,9 @@ protected:
     // set the focus to the child which had it the last time
     bool SetFocusToChild();
 
     // set the focus to the child which had it the last time
     bool SetFocusToChild();
 

-    // 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;
 
     // the child which had the focus last time this panel was activated
     wxWindow *m_winLastFocused;
 

-    // a default window (usually a button) or NULL
-    wxWindow *m_winDefault;
-
-    // a temporary override of m_winDefault, use the latter if NULL
-    wxWindow *m_winTmpDefault;
-

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


@@ -107,20 +189,14 @@ 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); \
-    virtual void SetTmpDefaultItem(wxWindow *win); \
-    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);                      \
+    virtual void SetFocus()

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


@@ -129,53 +205,44 @@ 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); \
-} \
- \
-void classname::SetTmpDefaultItem(wxWindow *child) \
-{ \
-    m_container.SetTmpDefaultItem(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); \
-} \
-bool classname::AcceptsFocus() const \
-{ \
-    return m_container.AcceptsFocus(); \
-}
-
+#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::SetFocus()                                                \
+    {                                                                         \
+        if ( !m_container.DoSetFocus() )                                      \
+            basename::SetFocus();                                             \
+    }                                                                         \
+                                                                              \
+    void classname::SetFocusIgnoringChildren()                                \
+    {                                                                         \
+        basename::SetFocus();                                                 \
+    }                                                                         \
+                                                                              \
+    void classname::OnChildFocus(wxChildFocusEvent& event)                    \
+    {                                                                         \
+        m_container.SetLastFocus(event.GetWindow());                          \
+    }                                                                         \
+                                                                              \
+    void classname::OnFocus(wxFocusEvent& event)                              \
+    {                                                                         \
+        m_container.HandleOnFocus(event);                                     \
+    } 
+
+#endif // wxHAS_NATIVE_TAB_TRAVERSAL/!wxHAS_NATIVE_TAB_TRAVERSAL

 
 #endif // _WX_CONTAINR_H_
 
 #endif // _WX_CONTAINR_H_