]> git.saurik.com Git - wxWidgets.git/blob - include/wx/containr.h
Extract wxFDIOHandler in its own header.
[wxWidgets.git] / include / wx / containr.h
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: wx/containr.h
3 // Purpose: wxControlContainer class declration: a "mix-in" class which
4 // implements the TAB navigation between the controls
5 // Author: Vadim Zeitlin
6 // Modified by:
7 // Created: 06.08.01
8 // RCS-ID: $Id$
9 // Copyright: (c) 2001 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
10 // Licence: wxWindows licence
11 ///////////////////////////////////////////////////////////////////////////////
12
13 #ifndef _WX_CONTAINR_H_
14 #define _WX_CONTAINR_H_
15
16 #include "wx/defs.h"
17
18 class WXDLLIMPEXP_FWD_CORE wxWindow;
19 class WXDLLIMPEXP_FWD_CORE wxWindowBase;
20
21 /*
22 Implementation note: wxControlContainer is not a real mix-in but rather
23 a class meant to be aggregated with (and not inherited from). Although
24 logically it should be a mix-in, doing it like this has no advantage from
25 the point of view of the existing code but does have some problems (we'd
26 need to play tricks with event handlers which may be difficult to do
27 safely). The price we pay for this simplicity is the ugly macros below.
28 */
29
30 // ----------------------------------------------------------------------------
31 // wxControlContainerBase: common part used in both native and generic cases
32 // ----------------------------------------------------------------------------
33
34 class WXDLLIMPEXP_CORE wxControlContainerBase
35 {
36 public:
37 // default ctor, SetContainerWindow() must be called later
38 wxControlContainerBase()
39 {
40 m_winParent = NULL;
41
42 // do accept focus initially, we'll stop doing it if/when any children
43 // are added
44 m_acceptsFocus = true;
45 m_inSetFocus = false;
46 m_winLastFocused = NULL;
47 }
48 virtual ~wxControlContainerBase() {}
49
50 void SetContainerWindow(wxWindow *winParent)
51 {
52 wxASSERT_MSG( !m_winParent, wxT("shouldn't be called twice") );
53
54 m_winParent = winParent;
55 }
56
57 // should be called from SetFocus(), returns false if we did nothing with
58 // the focus and the default processing should take place
59 bool DoSetFocus();
60
61 // should be called when we decide that we should [stop] accepting focus
62 void SetCanFocus(bool acceptsFocus);
63
64 // returns whether we should accept focus ourselves or not
65 bool AcceptsFocus() const { return m_acceptsFocus; }
66
67 // returns whether we or one of our children accepts focus: we always do
68 // because if we don't have any focusable children it probably means that
69 // we're not being used as a container at all (think of wxGrid or generic
70 // wxListCtrl) and so should get focus for ourselves
71 bool AcceptsFocusRecursively() const { return true; }
72
73 // this is used to determine whether we can accept focus when Tab or
74 // another navigation key is pressed -- we alsways can, for the same reason
75 // as mentioned above for AcceptsFocusRecursively()
76 bool AcceptsFocusFromKeyboard() const { return true; }
77
78 // Call this when the number of children of the window changes.
79 // If we have any children, this panel (used just as container for
80 // them) shouldn't get focus for itself.
81 void UpdateCanFocus() { SetCanFocus(!HasAnyFocusableChildren()); }
82
83 protected:
84 // set the focus to the child which had it the last time
85 virtual bool SetFocusToChild();
86
87 // return true if we have any children accepting focus
88 bool HasAnyFocusableChildren() const;
89
90 // the parent window we manage the children for
91 wxWindow *m_winParent;
92
93 // the child which had the focus last time this panel was activated
94 wxWindow *m_winLastFocused;
95
96 private:
97 // value returned by AcceptsFocus(), should be changed using SetCanFocus()
98 // only
99 bool m_acceptsFocus;
100
101 // a guard against infinite recursion
102 bool m_inSetFocus;
103 };
104
105 // common part of WX_DECLARE_CONTROL_CONTAINER in the native and generic cases,
106 // it should be used in the wxWindow-derived class declaration
107 #define WX_DECLARE_CONTROL_CONTAINER_BASE() \
108 public: \
109 virtual bool AcceptsFocus() const; \
110 virtual bool AcceptsFocusRecursively() const; \
111 virtual bool AcceptsFocusFromKeyboard() const; \
112 virtual void AddChild(wxWindowBase *child); \
113 virtual void RemoveChild(wxWindowBase *child); \
114 virtual void SetFocus(); \
115 void SetFocusIgnoringChildren(); \
116 void AcceptFocus(bool acceptFocus) \
117 { \
118 m_container.SetCanFocus(acceptFocus); \
119 } \
120 \
121 protected: \
122 wxControlContainer m_container
123
124 // this macro must be used in the derived class ctor
125 #define WX_INIT_CONTROL_CONTAINER() \
126 m_container.SetContainerWindow(this)
127
128 // common part of WX_DELEGATE_TO_CONTROL_CONTAINER in the native and generic
129 // cases, must be used in the wxWindow-derived class implementation
130 #define WX_DELEGATE_TO_CONTROL_CONTAINER_BASE(classname, basename) \
131 void classname::AddChild(wxWindowBase *child) \
132 { \
133 basename::AddChild(child); \
134 \
135 m_container.UpdateCanFocus(); \
136 } \
137 \
138 bool classname::AcceptsFocusRecursively() const \
139 { \
140 return m_container.AcceptsFocusRecursively(); \
141 } \
142 \
143 void classname::SetFocus() \
144 { \
145 if ( !m_container.DoSetFocus() ) \
146 basename::SetFocus(); \
147 } \
148 \
149 bool classname::AcceptsFocus() const \
150 { \
151 return m_container.AcceptsFocus(); \
152 } \
153 \
154 bool classname::AcceptsFocusFromKeyboard() const \
155 { \
156 return m_container.AcceptsFocusFromKeyboard(); \
157 }
158
159 #ifdef wxHAS_NATIVE_TAB_TRAVERSAL
160
161 // ----------------------------------------------------------------------------
162 // wxControlContainer for native TAB navigation
163 // ----------------------------------------------------------------------------
164
165 // this must be a real class as we forward-declare it elsewhere
166 class WXDLLIMPEXP_CORE wxControlContainer : public wxControlContainerBase
167 {
168 protected:
169 // set the focus to the child which had it the last time
170 virtual bool SetFocusToChild();
171 };
172
173 #define WX_EVENT_TABLE_CONTROL_CONTAINER(classname)
174
175 #define WX_DECLARE_CONTROL_CONTAINER WX_DECLARE_CONTROL_CONTAINER_BASE
176
177 #define WX_DELEGATE_TO_CONTROL_CONTAINER(classname, basename) \
178 WX_DELEGATE_TO_CONTROL_CONTAINER_BASE(classname, basename) \
179 \
180 void classname::RemoveChild(wxWindowBase *child) \
181 { \
182 basename::RemoveChild(child); \
183 \
184 m_container.UpdateCanFocus(); \
185 } \
186 \
187 void classname::SetFocusIgnoringChildren() \
188 { \
189 basename::SetFocus(); \
190 }
191
192 #else // !wxHAS_NATIVE_TAB_TRAVERSAL
193
194 class WXDLLIMPEXP_FWD_CORE wxFocusEvent;
195 class WXDLLIMPEXP_FWD_CORE wxNavigationKeyEvent;
196
197 // ----------------------------------------------------------------------------
198 // wxControlContainer for TAB navigation implemented in wx itself
199 // ----------------------------------------------------------------------------
200
201 class WXDLLIMPEXP_CORE wxControlContainer : public wxControlContainerBase
202 {
203 public:
204 // default ctor, SetContainerWindow() must be called later
205 wxControlContainer();
206
207 // the methods to be called from the window event handlers
208 void HandleOnNavigationKey(wxNavigationKeyEvent& event);
209 void HandleOnFocus(wxFocusEvent& event);
210 void HandleOnWindowDestroy(wxWindowBase *child);
211
212 // called from OnChildFocus() handler, i.e. when one of our (grand)
213 // children gets the focus
214 void SetLastFocus(wxWindow *win);
215
216 protected:
217
218 wxDECLARE_NO_COPY_CLASS(wxControlContainer);
219 };
220
221 // ----------------------------------------------------------------------------
222 // macros which may be used by the classes wishing to implement TAB navigation
223 // among their children
224 // ----------------------------------------------------------------------------
225
226 // declare the methods to be forwarded
227 #define WX_DECLARE_CONTROL_CONTAINER() \
228 WX_DECLARE_CONTROL_CONTAINER_BASE(); \
229 \
230 public: \
231 void OnNavigationKey(wxNavigationKeyEvent& event); \
232 void OnFocus(wxFocusEvent& event); \
233 virtual void OnChildFocus(wxChildFocusEvent& event)
234
235 // implement the event table entries for wxControlContainer
236 #define WX_EVENT_TABLE_CONTROL_CONTAINER(classname) \
237 EVT_SET_FOCUS(classname::OnFocus) \
238 EVT_CHILD_FOCUS(classname::OnChildFocus) \
239 EVT_NAVIGATION_KEY(classname::OnNavigationKey)
240
241 // implement the methods forwarding to the wxControlContainer
242 #define WX_DELEGATE_TO_CONTROL_CONTAINER(classname, basename) \
243 WX_DELEGATE_TO_CONTROL_CONTAINER_BASE(classname, basename) \
244 \
245 void classname::RemoveChild(wxWindowBase *child) \
246 { \
247 m_container.HandleOnWindowDestroy(child); \
248 \
249 basename::RemoveChild(child); \
250 \
251 m_container.UpdateCanFocus(); \
252 } \
253 \
254 void classname::OnNavigationKey( wxNavigationKeyEvent& event ) \
255 { \
256 m_container.HandleOnNavigationKey(event); \
257 } \
258 \
259 void classname::SetFocusIgnoringChildren() \
260 { \
261 basename::SetFocus(); \
262 } \
263 \
264 void classname::OnChildFocus(wxChildFocusEvent& event) \
265 { \
266 m_container.SetLastFocus(event.GetWindow()); \
267 event.Skip(); \
268 } \
269 \
270 void classname::OnFocus(wxFocusEvent& event) \
271 { \
272 m_container.HandleOnFocus(event); \
273 }
274
275 #endif // wxHAS_NATIVE_TAB_TRAVERSAL/!wxHAS_NATIVE_TAB_TRAVERSAL
276
277 // this function is for wxWidgets internal use only
278 extern bool wxSetFocusToChild(wxWindow *win, wxWindow **child);
279
280 #endif // _WX_CONTAINR_H_