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

///////////////////////////////////////////////////////////////////////////////
// Name:        wx/containr.h
// Purpose:     wxControlContainer and wxNavigationEnabled declarations
// Author:      Vadim Zeitlin
// Modified by:
// Created:     06.08.01
// RCS-ID:      $Id$
// Copyright:   (c) 2001, 2011 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
// Licence:     wxWindows licence
///////////////////////////////////////////////////////////////////////////////

#ifndef _WX_CONTAINR_H_
#define _WX_CONTAINR_H_

#include "wx/defs.h"

class WXDLLIMPEXP_FWD_CORE wxWindow;
class WXDLLIMPEXP_FWD_CORE wxWindowBase;

/*
    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
// ----------------------------------------------------------------------------

class WXDLLIMPEXP_CORE wxControlContainerBase
{
public:
    // 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;
        m_inSetFocus = false;
        m_winLastFocused = NULL;
    }
    virtual ~wxControlContainerBase() {}

    void SetContainerWindow(wxWindow *winParent)
    {
        wxASSERT_MSG( !m_winParent, wxT("shouldn't be called twice") );

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

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

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

#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

// declare the methods to be forwarded
#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) \
    EVT_SET_FOCUS(classname::OnFocus) \
    EVT_CHILD_FOCUS(classname::OnChildFocus) \
    EVT_NAVIGATION_KEY(classname::OnNavigationKey)

// implement the methods forwarding to the wxControlContainer
#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

#endif // WXWIN_COMPATIBILITY_2_8

#endif // _WX_CONTAINR_H_
Commit	Line	Data
456bc6d9 VZ	1	///////////////////////////////////////////////////////////////////////////////
456bc6d9 VZ	2	// Name: wx/containr.h
4d98817c	3	// Purpose: wxControlContainer and wxNavigationEnabled declarations
456bc6d9 VZ	4	// Author: Vadim Zeitlin
	5	// Modified by:
	6	// Created: 06.08.01
	7	// RCS-ID: $Id$
4d98817c	8	// Copyright: (c) 2001, 2011 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
65571936	9	// Licence: wxWindows licence
456bc6d9 VZ	10	///////////////////////////////////////////////////////////////////////////////
	11
	12	#ifndef _WX_CONTAINR_H_
	13	#define _WX_CONTAINR_H_
	14
617fb24f VZ	15	#include "wx/defs.h"
617fb24f VZ	16
b5dbe15d VS	17	class WXDLLIMPEXP_FWD_CORE wxWindow;
b5dbe15d VS	18	class WXDLLIMPEXP_FWD_CORE wxWindowBase;
bf0e8244	19
80332672	20	/*
4d98817c VZ	21	This header declares wxControlContainer class however it's not a real
	22	container of controls but rather just a helper used to implement TAB
	23	navigation among the window children. You should rarely need to use it
	24	directly, derive from the documented public wxNavigationEnabled<> class to
	25	implement TAB navigation in a custom composite window.
80332672 VZ	26	*/
	27
	28	// ----------------------------------------------------------------------------
	29	// wxControlContainerBase: common part used in both native and generic cases
	30	// ----------------------------------------------------------------------------
	31
53a2db12	32	class WXDLLIMPEXP_CORE wxControlContainerBase
80332672 VZ	33	{
	34	public:
	35	// default ctor, SetContainerWindow() must be called later
	36	wxControlContainerBase()
	37	{
	38	m_winParent = NULL;
	39
	40	// do accept focus initially, we'll stop doing it if/when any children
	41	// are added
	42	m_acceptsFocus = true;
c7bfb76a JS	43	m_inSetFocus = false;
c7bfb76a JS	44	m_winLastFocused = NULL;
80332672	45	}
c7bfb76a	46	virtual ~wxControlContainerBase() {}
80332672 VZ	47
	48	void SetContainerWindow(wxWindow *winParent)
	49	{
9a83f860	50	wxASSERT_MSG( !m_winParent, wxT("shouldn't be called twice") );
80332672 VZ	51
	52	m_winParent = winParent;
	53	}
	54
c7bfb76a JS	55	// should be called from SetFocus(), returns false if we did nothing with
	56	// the focus and the default processing should take place
	57	bool DoSetFocus();
	58
80332672 VZ	59	// should be called when we decide that we should [stop] accepting focus
	60	void SetCanFocus(bool acceptsFocus);
	61
	62	// returns whether we should accept focus ourselves or not
	63	bool AcceptsFocus() const { return m_acceptsFocus; }
	64
edc09871 VZ	65	// returns whether we or one of our children accepts focus: we always do
	66	// because if we don't have any focusable children it probably means that
	67	// we're not being used as a container at all (think of wxGrid or generic
	68	// wxListCtrl) and so should get focus for ourselves
	69	bool AcceptsFocusRecursively() const { return true; }
	70
21bf81db VZ	71	// this is used to determine whether we can accept focus when Tab or
	72	// another navigation key is pressed -- we alsways can, for the same reason
	73	// as mentioned above for AcceptsFocusRecursively()
	74	bool AcceptsFocusFromKeyboard() const { return true; }
	75
00ff24c8 RR	76	// Call this when the number of children of the window changes.
	77	// If we have any children, this panel (used just as container for
	78	// them) shouldn't get focus for itself.
edc09871	79	void UpdateCanFocus() { SetCanFocus(!HasAnyFocusableChildren()); }
80332672 VZ	80
80332672 VZ	81	protected:
c7bfb76a JS	82	// set the focus to the child which had it the last time
	83	virtual bool SetFocusToChild();
	84
edc09871 VZ	85	// return true if we have any children accepting focus
edc09871 VZ	86	bool HasAnyFocusableChildren() const;
80332672	87
80332672 VZ	88	// the parent window we manage the children for
	89	wxWindow *m_winParent;
	90
1c1ad005 JS	91	// the child which had the focus last time this panel was activated
	92	wxWindow *m_winLastFocused;
	93
bf0e8244	94	private:
80332672 VZ	95	// value returned by AcceptsFocus(), should be changed using SetCanFocus()
	96	// only
	97	bool m_acceptsFocus;
c7bfb76a JS	98
	99	// a guard against infinite recursion
	100	bool m_inSetFocus;
80332672 VZ	101	};
80332672 VZ	102
4d98817c VZ	103	#ifdef wxHAS_NATIVE_TAB_TRAVERSAL
	104
	105	// ----------------------------------------------------------------------------
	106	// wxControlContainer for native TAB navigation
	107	// ----------------------------------------------------------------------------
	108
	109	// this must be a real class as we forward-declare it elsewhere
	110	class WXDLLIMPEXP_CORE wxControlContainer : public wxControlContainerBase
	111	{
	112	protected:
	113	// set the focus to the child which had it the last time
	114	virtual bool SetFocusToChild();
	115	};
	116
	117	#else // !wxHAS_NATIVE_TAB_TRAVERSAL
	118
	119	class WXDLLIMPEXP_FWD_CORE wxFocusEvent;
	120	class WXDLLIMPEXP_FWD_CORE wxNavigationKeyEvent;
	121
	122	// ----------------------------------------------------------------------------
	123	// wxControlContainer for TAB navigation implemented in wx itself
	124	// ----------------------------------------------------------------------------
	125
	126	class WXDLLIMPEXP_CORE wxControlContainer : public wxControlContainerBase
	127	{
	128	public:
	129	// default ctor, SetContainerWindow() must be called later
	130	wxControlContainer();
	131
	132	// the methods to be called from the window event handlers
	133	void HandleOnNavigationKey(wxNavigationKeyEvent& event);
	134	void HandleOnFocus(wxFocusEvent& event);
	135	void HandleOnWindowDestroy(wxWindowBase *child);
	136
	137	// called from OnChildFocus() handler, i.e. when one of our (grand)
	138	// children gets the focus
	139	void SetLastFocus(wxWindow *win);
	140
	141	protected:
	142
	143	wxDECLARE_NO_COPY_CLASS(wxControlContainer);
	144	};
	145
	146	#endif // wxHAS_NATIVE_TAB_TRAVERSAL/!wxHAS_NATIVE_TAB_TRAVERSAL
	147
	148	// this function is for wxWidgets internal use only
	149	extern bool wxSetFocusToChild(wxWindow win, wxWindow *child);
	150
	151	// ----------------------------------------------------------------------------
	152	// wxNavigationEnabled: Derive from this class to support keyboard navigation
	153	// among window children in a wxWindow-derived class. The details of this class
	154	// don't matter, you just need to derive from it to make navigation work.
	155	// ----------------------------------------------------------------------------
	156
	157	// The template parameter W must be a wxWindow-derived class.
	158	template <class W>
	159	class wxNavigationEnabled : public W
	160	{
	161	public:
	162	typedef W BaseWindowClass;
	163
	164	wxNavigationEnabled()
	165	{
	166	m_container.SetContainerWindow(this);
167
168	#ifndef wxHAS_NATIVE_TAB_TRAVERSAL
169	Connect(wxEVT_NAVIGATION_KEY,
170	wxNavigationKeyEventHandler(wxNavigationEnabled::OnNavigationKey));
171
172	Connect(wxEVT_SET_FOCUS,
173	wxFocusEventHandler(wxNavigationEnabled::OnFocus));
174
175	Connect(wxEVT_CHILD_FOCUS,
176	wxChildFocusEventHandler(wxNavigationEnabled::OnChildFocus));
177	#endif // !wxHAS_NATIVE_TAB_TRAVERSAL
178	}
179
180	virtual bool AcceptsFocus() const
181	{
182	return m_container.AcceptsFocus();
183	}
184
185	virtual bool AcceptsFocusRecursively() const
186	{
187	return m_container.AcceptsFocusRecursively();
188	}
189
190	virtual bool AcceptsFocusFromKeyboard() const
191	{
192	return m_container.AcceptsFocusFromKeyboard();
193	}
194
195	virtual void AddChild(wxWindowBase *child)
196	{
197	BaseWindowClass::AddChild(child);
198
199	m_container.UpdateCanFocus();
200	}
201
202	virtual void RemoveChild(wxWindowBase *child)
203	{
204	#ifndef wxHAS_NATIVE_TAB_TRAVERSAL
205	m_container.HandleOnWindowDestroy(child);
206	#endif // !wxHAS_NATIVE_TAB_TRAVERSAL
207
208	BaseWindowClass::RemoveChild(child);
209
210	m_container.UpdateCanFocus();
211	}
212
213	virtual void SetFocus()
214	{
215	if ( !m_container.DoSetFocus() )
216	BaseWindowClass::SetFocus();
217	}
218
219	void SetFocusIgnoringChildren()
220	{
221	BaseWindowClass::SetFocus();
222	}
223
224	void AcceptFocus(bool acceptFocus)
225	{
226	m_container.SetCanFocus(acceptFocus);
227	}
228
229	protected:
230	#ifndef wxHAS_NATIVE_TAB_TRAVERSAL
231	void OnNavigationKey(wxNavigationKeyEvent& event)
232	{
233	m_container.HandleOnNavigationKey(event);
234	}
235
236	void OnFocus(wxFocusEvent& event)
237	{
238	m_container.HandleOnFocus(event);
239	}
240
241	void OnChildFocus(wxChildFocusEvent& event)
242	{
243	m_container.SetLastFocus(event.GetWindow());
244	event.Skip();
245	}
246	#endif // !wxHAS_NATIVE_TAB_TRAVERSAL
247
248	wxControlContainer m_container;
249
250
251	wxDECLARE_NO_COPY_TEMPLATE_CLASS(wxNavigationEnabled, W);
252	};
253
254	// ----------------------------------------------------------------------------
255	// Compatibility macros from now on, do NOT use them and preferably do not even
256	// look at them.
257	// ----------------------------------------------------------------------------
258
259	#ifdef WXWIN_COMPATIBILITY_2_8
260
80332672 VZ	261	// common part of WX_DECLARE_CONTROL_CONTAINER in the native and generic cases,
	262	// it should be used in the wxWindow-derived class declaration
	263	#define WX_DECLARE_CONTROL_CONTAINER_BASE() \
	264	public: \
	265	virtual bool AcceptsFocus() const; \
edc09871	266	virtual bool AcceptsFocusRecursively() const; \
21bf81db	267	virtual bool AcceptsFocusFromKeyboard() const; \
80332672 VZ	268	virtual void AddChild(wxWindowBase *child); \
80332672 VZ	269	virtual void RemoveChild(wxWindowBase *child); \
c7bfb76a	270	virtual void SetFocus(); \
80332672 VZ	271	void SetFocusIgnoringChildren(); \
	272	void AcceptFocus(bool acceptFocus) \
	273	{ \
	274	m_container.SetCanFocus(acceptFocus); \
	275	} \
	276	\
	277	protected: \
	278	wxControlContainer m_container
	279
	280	// this macro must be used in the derived class ctor
	281	#define WX_INIT_CONTROL_CONTAINER() \
	282	m_container.SetContainerWindow(this)
	283
	284	// common part of WX_DELEGATE_TO_CONTROL_CONTAINER in the native and generic
	285	// cases, must be used in the wxWindow-derived class implementation
	286	#define WX_DELEGATE_TO_CONTROL_CONTAINER_BASE(classname, basename) \
	287	void classname::AddChild(wxWindowBase *child) \
	288	{ \
	289	basename::AddChild(child); \
	290	\
	291	m_container.UpdateCanFocus(); \
	292	} \
	293	\
edc09871 VZ	294	bool classname::AcceptsFocusRecursively() const \
	295	{ \
	296	return m_container.AcceptsFocusRecursively(); \
	297	} \
	298	\
c7bfb76a JS	299	void classname::SetFocus() \
	300	{ \
	301	if ( !m_container.DoSetFocus() ) \
	302	basename::SetFocus(); \
	303	} \
	304	\
80332672 VZ	305	bool classname::AcceptsFocus() const \
	306	{ \
	307	return m_container.AcceptsFocus(); \
21bf81db VZ	308	} \
	309	\
	310	bool classname::AcceptsFocusFromKeyboard() const \
	311	{ \
	312	return m_container.AcceptsFocusFromKeyboard(); \
80332672 VZ	313	}
80332672 VZ	314
de160b06	315
4d98817c	316	#ifdef wxHAS_NATIVE_TAB_TRAVERSAL
de160b06	317
de160b06	318	#define WX_EVENT_TABLE_CONTROL_CONTAINER(classname)
80332672 VZ	319
	320	#define WX_DECLARE_CONTROL_CONTAINER WX_DECLARE_CONTROL_CONTAINER_BASE
	321
	322	#define WX_DELEGATE_TO_CONTROL_CONTAINER(classname, basename) \
	323	WX_DELEGATE_TO_CONTROL_CONTAINER_BASE(classname, basename) \
	324	\
	325	void classname::RemoveChild(wxWindowBase *child) \
	326	{ \
	327	basename::RemoveChild(child); \
	328	\
	329	m_container.UpdateCanFocus(); \
	330	} \
	331	\
	332	void classname::SetFocusIgnoringChildren() \
	333	{ \
00ff24c8	334	basename::SetFocus(); \
80332672	335	}
de160b06 VZ	336
	337	#else // !wxHAS_NATIVE_TAB_TRAVERSAL
	338
456bc6d9	339	// declare the methods to be forwarded
d1cd787b VZ	340	#define WX_DECLARE_CONTROL_CONTAINER() \
	341	WX_DECLARE_CONTROL_CONTAINER_BASE(); \
	342	\
	343	public: \
	344	void OnNavigationKey(wxNavigationKeyEvent& event); \
	345	void OnFocus(wxFocusEvent& event); \
c7bfb76a	346	virtual void OnChildFocus(wxChildFocusEvent& event)
456bc6d9 VZ	347
	348	// implement the event table entries for wxControlContainer
	349	#define WX_EVENT_TABLE_CONTROL_CONTAINER(classname) \
	350	EVT_SET_FOCUS(classname::OnFocus) \
	351	EVT_CHILD_FOCUS(classname::OnChildFocus) \
	352	EVT_NAVIGATION_KEY(classname::OnNavigationKey)
	353
	354	// implement the methods forwarding to the wxControlContainer
80332672 VZ	355	#define WX_DELEGATE_TO_CONTROL_CONTAINER(classname, basename) \
	356	WX_DELEGATE_TO_CONTROL_CONTAINER_BASE(classname, basename) \
	357	\
	358	void classname::RemoveChild(wxWindowBase *child) \
	359	{ \
	360	m_container.HandleOnWindowDestroy(child); \
	361	\
	362	basename::RemoveChild(child); \
	363	\
	364	m_container.UpdateCanFocus(); \
	365	} \
	366	\
	367	void classname::OnNavigationKey( wxNavigationKeyEvent& event ) \
	368	{ \
	369	m_container.HandleOnNavigationKey(event); \
	370	} \
	371	\
80332672 VZ	372	void classname::SetFocusIgnoringChildren() \
	373	{ \
	374	basename::SetFocus(); \
	375	} \
	376	\
	377	void classname::OnChildFocus(wxChildFocusEvent& event) \
	378	{ \
	379	m_container.SetLastFocus(event.GetWindow()); \
57c5c10f	380	event.Skip(); \
80332672 VZ	381	} \
	382	\
	383	void classname::OnFocus(wxFocusEvent& event) \
	384	{ \
	385	m_container.HandleOnFocus(event); \
1c1ad005	386	}
456bc6d9	387
de160b06	388	#endif // wxHAS_NATIVE_TAB_TRAVERSAL/!wxHAS_NATIVE_TAB_TRAVERSAL
456bc6d9	389
4d98817c	390	#endif // WXWIN_COMPATIBILITY_2_8
c7bfb76a	391
456bc6d9	392	#endif // _WX_CONTAINR_H_