]>
Commit | Line | Data |
---|---|---|
1 | /////////////////////////////////////////////////////////////////////////////// | |
2 | // Name: src/common/containr.cpp | |
3 | // Purpose: implementation of wxControlContainer | |
4 | // Author: Vadim Zeitlin | |
5 | // Modified by: | |
6 | // Created: 06.08.01 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) 2001 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr> | |
9 | // License: wxWindows licence | |
10 | /////////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | // ============================================================================ | |
13 | // declarations | |
14 | // ============================================================================ | |
15 | ||
16 | // ---------------------------------------------------------------------------- | |
17 | // headers | |
18 | // ---------------------------------------------------------------------------- | |
19 | ||
20 | // For compilers that support precompilation, includes "wx.h". | |
21 | #include "wx/wxprec.h" | |
22 | ||
23 | #ifdef __BORLANDC__ | |
24 | #pragma hdrstop | |
25 | #endif | |
26 | ||
27 | #ifndef WX_PRECOMP | |
28 | #include "wx/log.h" | |
29 | #include "wx/event.h" | |
30 | #include "wx/window.h" | |
31 | #endif //WX_PRECOMP | |
32 | ||
33 | #include "wx/containr.h" | |
34 | ||
35 | #ifdef __WXMAC__ | |
36 | #include "wx/scrolbar.h" | |
37 | #endif | |
38 | ||
39 | #ifdef __WXMSW__ | |
40 | #include "wx/radiobut.h" | |
41 | #endif | |
42 | ||
43 | // trace mask for focus messages | |
44 | #define TRACE_FOCUS _T("focus") | |
45 | ||
46 | // ============================================================================ | |
47 | // implementation | |
48 | // ============================================================================ | |
49 | ||
50 | wxControlContainer::wxControlContainer(wxWindow *winParent) | |
51 | { | |
52 | m_winParent = winParent; | |
53 | ||
54 | m_winLastFocused = | |
55 | m_winTmpDefault = | |
56 | m_winDefault = NULL; | |
57 | m_inSetFocus = false; | |
58 | } | |
59 | ||
60 | bool wxControlContainer::AcceptsFocus() const | |
61 | { | |
62 | // if we're not shown or disabled, we can't accept focus | |
63 | if ( m_winParent->IsShown() && m_winParent->IsEnabled() ) | |
64 | { | |
65 | // otherwise we can accept focus either if we have no children at all | |
66 | // (in this case we're probably not used as a container) or only when | |
67 | // at least one child will accept focus | |
68 | wxWindowList::compatibility_iterator node = m_winParent->GetChildren().GetFirst(); | |
69 | if ( !node ) | |
70 | return true; | |
71 | ||
72 | #ifdef __WXMAC__ | |
73 | // wxMac has eventually the two scrollbars as children, they don't count | |
74 | // as real children in the algorithm mentioned above | |
75 | bool hasRealChildren = false ; | |
76 | #endif | |
77 | ||
78 | while ( node ) | |
79 | { | |
80 | wxWindow *child = node->GetData(); | |
81 | ||
82 | if ( child->AcceptsFocus() ) | |
83 | { | |
84 | return true; | |
85 | } | |
86 | ||
87 | #ifdef __WXMAC__ | |
88 | wxScrollBar *sb = wxDynamicCast( child , wxScrollBar ) ; | |
89 | if ( sb == NULL || !m_winParent->MacIsWindowScrollbar( sb ) ) | |
90 | hasRealChildren = true ; | |
91 | #endif | |
92 | node = node->GetNext(); | |
93 | } | |
94 | ||
95 | #ifdef __WXMAC__ | |
96 | if ( !hasRealChildren ) | |
97 | return true ; | |
98 | #endif | |
99 | } | |
100 | ||
101 | return false; | |
102 | } | |
103 | ||
104 | void wxControlContainer::SetLastFocus(wxWindow *win) | |
105 | { | |
106 | // the panel itself should never get the focus at all but if it does happen | |
107 | // temporarily (as it seems to do under wxGTK), at the very least don't | |
108 | // forget our previous m_winLastFocused | |
109 | if ( win != m_winParent ) | |
110 | { | |
111 | // if we're setting the focus | |
112 | if ( win ) | |
113 | { | |
114 | // find the last _immediate_ child which got focus | |
115 | wxWindow *winParent = win; | |
116 | while ( winParent != m_winParent ) | |
117 | { | |
118 | win = winParent; | |
119 | winParent = win->GetParent(); | |
120 | ||
121 | // Yes, this can happen, though in a totally pathological case. | |
122 | // like when detaching a menubar from a frame with a child | |
123 | // which has pushed itself as an event handler for the menubar. | |
124 | // (under wxGTK) | |
125 | ||
126 | wxASSERT_MSG( winParent, | |
127 | _T("Setting last focus for a window that is not our child?") ); | |
128 | } | |
129 | } | |
130 | ||
131 | m_winLastFocused = win; | |
132 | ||
133 | if ( win ) | |
134 | { | |
135 | wxLogTrace(TRACE_FOCUS, _T("Set last focus to %s(%s)"), | |
136 | win->GetClassInfo()->GetClassName(), | |
137 | win->GetLabel().c_str()); | |
138 | } | |
139 | else | |
140 | { | |
141 | wxLogTrace(TRACE_FOCUS, _T("No more last focus")); | |
142 | } | |
143 | } | |
144 | ||
145 | // propagate the last focus upwards so that our parent can set focus back | |
146 | // to us if it loses it now and regains later | |
147 | wxWindow *parent = m_winParent->GetParent(); | |
148 | if ( parent ) | |
149 | { | |
150 | wxChildFocusEvent eventFocus(m_winParent); | |
151 | parent->GetEventHandler()->ProcessEvent(eventFocus); | |
152 | } | |
153 | } | |
154 | ||
155 | // -------------------------------------------------------------------- | |
156 | // The following four functions are used to find other radio buttons | |
157 | // within the same group. Used by wxSetFocusToChild on wxMSW | |
158 | // -------------------------------------------------------------------- | |
159 | ||
160 | #ifdef __WXMSW__ | |
161 | ||
162 | wxRadioButton* wxGetPreviousButtonInGroup(wxRadioButton *btn) | |
163 | { | |
164 | if ( btn->HasFlag(wxRB_GROUP) || btn->HasFlag(wxRB_SINGLE) ) | |
165 | return NULL; | |
166 | ||
167 | const wxWindowList& siblings = btn->GetParent()->GetChildren(); | |
168 | wxWindowList::compatibility_iterator nodeThis = siblings.Find(btn); | |
169 | wxCHECK_MSG( nodeThis, NULL, _T("radio button not a child of its parent?") ); | |
170 | ||
171 | // Iterate over all previous siblings until we find the next radio button | |
172 | wxWindowList::compatibility_iterator nodeBefore = nodeThis->GetPrevious(); | |
173 | wxRadioButton *prevBtn = 0; | |
174 | while (nodeBefore) | |
175 | { | |
176 | prevBtn = wxDynamicCast(nodeBefore->GetData(), wxRadioButton); | |
177 | if (prevBtn) | |
178 | break; | |
179 | ||
180 | nodeBefore = nodeBefore->GetPrevious(); | |
181 | } | |
182 | ||
183 | if (!prevBtn || prevBtn->HasFlag(wxRB_SINGLE)) | |
184 | { | |
185 | // no more buttons in group | |
186 | return NULL; | |
187 | } | |
188 | ||
189 | return prevBtn; | |
190 | } | |
191 | ||
192 | wxRadioButton* wxGetNextButtonInGroup(wxRadioButton *btn) | |
193 | { | |
194 | if (btn->HasFlag(wxRB_SINGLE)) | |
195 | return NULL; | |
196 | ||
197 | const wxWindowList& siblings = btn->GetParent()->GetChildren(); | |
198 | wxWindowList::compatibility_iterator nodeThis = siblings.Find(btn); | |
199 | wxCHECK_MSG( nodeThis, NULL, _T("radio button not a child of its parent?") ); | |
200 | ||
201 | // Iterate over all previous siblings until we find the next radio button | |
202 | wxWindowList::compatibility_iterator nodeNext = nodeThis->GetNext(); | |
203 | wxRadioButton *nextBtn = 0; | |
204 | while (nodeNext) | |
205 | { | |
206 | nextBtn = wxDynamicCast(nodeNext->GetData(), wxRadioButton); | |
207 | if (nextBtn) | |
208 | break; | |
209 | ||
210 | nodeNext = nodeNext->GetNext(); | |
211 | } | |
212 | ||
213 | if ( !nextBtn || nextBtn->HasFlag(wxRB_GROUP) || nextBtn->HasFlag(wxRB_SINGLE) ) | |
214 | { | |
215 | // no more buttons or the first button of the next group | |
216 | return NULL; | |
217 | } | |
218 | ||
219 | return nextBtn; | |
220 | } | |
221 | ||
222 | wxRadioButton* wxGetFirstButtonInGroup(wxRadioButton *btn) | |
223 | { | |
224 | while (true) | |
225 | { | |
226 | wxRadioButton* prevBtn = wxGetPreviousButtonInGroup(btn); | |
227 | if (!prevBtn) | |
228 | return btn; | |
229 | ||
230 | btn = prevBtn; | |
231 | } | |
232 | } | |
233 | ||
234 | wxRadioButton* wxGetLastButtonInGroup(wxRadioButton *btn) | |
235 | { | |
236 | while (true) | |
237 | { | |
238 | wxRadioButton* nextBtn = wxGetNextButtonInGroup(btn); | |
239 | if (!nextBtn) | |
240 | return btn; | |
241 | ||
242 | btn = nextBtn; | |
243 | } | |
244 | } | |
245 | ||
246 | wxRadioButton* wxGetSelectedButtonInGroup(wxRadioButton *btn) | |
247 | { | |
248 | // Find currently selected button | |
249 | if (btn->GetValue()) | |
250 | return btn; | |
251 | ||
252 | if (btn->HasFlag(wxRB_SINGLE)) | |
253 | return NULL; | |
254 | ||
255 | wxRadioButton *selBtn; | |
256 | ||
257 | // First check all previous buttons | |
258 | for (selBtn = wxGetPreviousButtonInGroup(btn); selBtn; selBtn = wxGetPreviousButtonInGroup(selBtn)) | |
259 | if (selBtn->GetValue()) | |
260 | return selBtn; | |
261 | ||
262 | // Now all following buttons | |
263 | for (selBtn = wxGetNextButtonInGroup(btn); selBtn; selBtn = wxGetNextButtonInGroup(selBtn)) | |
264 | if (selBtn->GetValue()) | |
265 | return selBtn; | |
266 | ||
267 | return NULL; | |
268 | } | |
269 | ||
270 | #endif // __WXMSW__ | |
271 | ||
272 | // ---------------------------------------------------------------------------- | |
273 | // Keyboard handling - this is the place where the TAB traversal logic is | |
274 | // implemented. As this code is common to all ports, this ensures consistent | |
275 | // behaviour even if we don't specify how exactly the wxNavigationKeyEvent are | |
276 | // generated and this is done in platform specific code which also ensures that | |
277 | // we can follow the given platform standards. | |
278 | // ---------------------------------------------------------------------------- | |
279 | ||
280 | void wxControlContainer::HandleOnNavigationKey( wxNavigationKeyEvent& event ) | |
281 | { | |
282 | wxWindow *parent = m_winParent->GetParent(); | |
283 | ||
284 | // the event is propagated downwards if the event emitter was our parent | |
285 | bool goingDown = event.GetEventObject() == parent; | |
286 | ||
287 | const wxWindowList& children = m_winParent->GetChildren(); | |
288 | ||
289 | // there is not much to do if we don't have children and we're not | |
290 | // interested in "notebook page change" events here | |
291 | if ( !children.GetCount() || event.IsWindowChange() ) | |
292 | { | |
293 | // let the parent process it unless it already comes from our parent | |
294 | // of we don't have any | |
295 | if ( goingDown || | |
296 | !parent || !parent->GetEventHandler()->ProcessEvent(event) ) | |
297 | { | |
298 | event.Skip(); | |
299 | } | |
300 | ||
301 | return; | |
302 | } | |
303 | ||
304 | // where are we going? | |
305 | const bool forward = event.GetDirection(); | |
306 | ||
307 | // the node of the children list from which we should start looking for the | |
308 | // next acceptable child | |
309 | wxWindowList::compatibility_iterator node, start_node; | |
310 | ||
311 | // we should start from the first/last control and not from the one which | |
312 | // had focus the last time if we're propagating the event downwards because | |
313 | // for our parent we look like a single control | |
314 | if ( goingDown ) | |
315 | { | |
316 | // just to be sure it's not used (normally this is not necessary, but | |
317 | // doesn't hurt neither) | |
318 | m_winLastFocused = (wxWindow *)NULL; | |
319 | ||
320 | // start from first or last depending on where we're going | |
321 | node = forward ? children.GetFirst() : children.GetLast(); | |
322 | } | |
323 | else // going up | |
324 | { | |
325 | // try to find the child which has the focus currently | |
326 | ||
327 | // the event emitter might have done this for us | |
328 | wxWindow *winFocus = event.GetCurrentFocus(); | |
329 | ||
330 | // but if not, we might know where the focus was ourselves | |
331 | if (!winFocus) | |
332 | winFocus = m_winLastFocused; | |
333 | ||
334 | // if still no luck, do it the hard way | |
335 | if (!winFocus) | |
336 | winFocus = wxWindow::FindFocus(); | |
337 | ||
338 | if ( winFocus ) | |
339 | { | |
340 | #ifdef __WXMSW__ | |
341 | // If we are in a radio button group, start from the first item in the | |
342 | // group | |
343 | if ( event.IsFromTab() && wxIsKindOf(winFocus, wxRadioButton ) ) | |
344 | winFocus = wxGetFirstButtonInGroup((wxRadioButton*)winFocus); | |
345 | #endif | |
346 | // ok, we found the focus - now is it our child? | |
347 | start_node = children.Find( winFocus ); | |
348 | } | |
349 | ||
350 | if ( !start_node && m_winLastFocused ) | |
351 | { | |
352 | // window which has focus isn't our child, fall back to the one | |
353 | // which had the focus the last time | |
354 | start_node = children.Find( m_winLastFocused ); | |
355 | } | |
356 | ||
357 | // if we still didn't find anything, we should start with the first one | |
358 | if ( !start_node ) | |
359 | { | |
360 | start_node = children.GetFirst(); | |
361 | } | |
362 | ||
363 | // and the first child which we can try setting focus to is the next or | |
364 | // the previous one | |
365 | node = forward ? start_node->GetNext() : start_node->GetPrevious(); | |
366 | } | |
367 | ||
368 | // we want to cycle over all elements passing by NULL | |
369 | for ( ;; ) | |
370 | { | |
371 | // don't go into infinite loop | |
372 | if ( start_node && node && node == start_node ) | |
373 | break; | |
374 | ||
375 | // Have we come to the last or first item on the panel? | |
376 | if ( !node ) | |
377 | { | |
378 | if ( !start_node ) | |
379 | { | |
380 | // exit now as otherwise we'd loop forever | |
381 | break; | |
382 | } | |
383 | ||
384 | if ( !goingDown ) | |
385 | { | |
386 | // Check if our (maybe grand) parent is another panel: if this | |
387 | // is the case, they will know what to do with this navigation | |
388 | // key and so give them the chance to process it instead of | |
389 | // looping inside this panel (normally, the focus will go to | |
390 | // the next/previous item after this panel in the parent | |
391 | // panel). | |
392 | wxWindow *focussed_child_of_parent = m_winParent; | |
393 | while ( parent ) | |
394 | { | |
395 | // we don't want to tab into a different dialog or frame | |
396 | if ( focussed_child_of_parent->IsTopLevel() ) | |
397 | break; | |
398 | ||
399 | event.SetCurrentFocus( focussed_child_of_parent ); | |
400 | if ( parent->GetEventHandler()->ProcessEvent( event ) ) | |
401 | return; | |
402 | ||
403 | focussed_child_of_parent = parent; | |
404 | ||
405 | parent = parent->GetParent(); | |
406 | } | |
407 | } | |
408 | //else: as the focus came from our parent, we definitely don't want | |
409 | // to send it back to it! | |
410 | ||
411 | // no, we are not inside another panel so process this ourself | |
412 | node = forward ? children.GetFirst() : children.GetLast(); | |
413 | ||
414 | continue; | |
415 | } | |
416 | ||
417 | wxWindow *child = node->GetData(); | |
418 | ||
419 | #ifdef __WXMSW__ | |
420 | if ( event.IsFromTab() ) | |
421 | { | |
422 | if ( wxIsKindOf(child, wxRadioButton) ) | |
423 | { | |
424 | // only radio buttons with either wxRB_GROUP or wxRB_SINGLE | |
425 | // can be tabbed to | |
426 | if ( child->HasFlag(wxRB_GROUP) ) | |
427 | { | |
428 | // need to tab into the active button within a group | |
429 | wxRadioButton *rb = wxGetSelectedButtonInGroup((wxRadioButton*)child); | |
430 | if ( rb ) | |
431 | child = rb; | |
432 | } | |
433 | else if ( !child->HasFlag(wxRB_SINGLE) ) | |
434 | { | |
435 | node = forward ? node->GetNext() : node->GetPrevious(); | |
436 | continue; | |
437 | } | |
438 | } | |
439 | } | |
440 | else if ( m_winLastFocused && | |
441 | wxIsKindOf(m_winLastFocused, wxRadioButton) && | |
442 | !m_winLastFocused->HasFlag(wxRB_SINGLE) ) | |
443 | { | |
444 | // cursor keys don't navigate out of a radio button group so | |
445 | // find the correct radio button to focus | |
446 | if ( forward ) | |
447 | { | |
448 | child = wxGetNextButtonInGroup((wxRadioButton*)m_winLastFocused); | |
449 | if ( !child ) | |
450 | { | |
451 | // no next button in group, set it to the first button | |
452 | child = wxGetFirstButtonInGroup((wxRadioButton*)m_winLastFocused); | |
453 | } | |
454 | } | |
455 | else | |
456 | { | |
457 | child = wxGetPreviousButtonInGroup((wxRadioButton*)m_winLastFocused); | |
458 | if ( !child ) | |
459 | { | |
460 | // no previous button in group, set it to the last button | |
461 | child = wxGetLastButtonInGroup((wxRadioButton*)m_winLastFocused); | |
462 | } | |
463 | } | |
464 | ||
465 | if ( child == m_winLastFocused ) | |
466 | { | |
467 | // must be a group consisting of only one button therefore | |
468 | // no need to send a navigation event | |
469 | event.Skip(false); | |
470 | return; | |
471 | } | |
472 | } | |
473 | #endif // __WXMSW__ | |
474 | ||
475 | if ( child->AcceptsFocusFromKeyboard() ) | |
476 | { | |
477 | // if we're setting the focus to a child panel we should prevent it | |
478 | // from giving it to the child which had the focus the last time | |
479 | // and instead give it to the first/last child depending from which | |
480 | // direction we're coming | |
481 | event.SetEventObject(m_winParent); | |
482 | ||
483 | // disable propagation for this call as otherwise the event might | |
484 | // bounce back to us. | |
485 | wxPropagationDisabler disableProp(event); | |
486 | if ( !child->GetEventHandler()->ProcessEvent(event) ) | |
487 | { | |
488 | // set it first in case SetFocusFromKbd() results in focus | |
489 | // change too | |
490 | m_winLastFocused = child; | |
491 | ||
492 | // everything is simple: just give focus to it | |
493 | child->SetFocusFromKbd(); | |
494 | } | |
495 | //else: the child manages its focus itself | |
496 | ||
497 | event.Skip( false ); | |
498 | ||
499 | return; | |
500 | } | |
501 | ||
502 | node = forward ? node->GetNext() : node->GetPrevious(); | |
503 | } | |
504 | ||
505 | // we cycled through all of our children and none of them wanted to accept | |
506 | // focus | |
507 | event.Skip(); | |
508 | } | |
509 | ||
510 | void wxControlContainer::HandleOnWindowDestroy(wxWindowBase *child) | |
511 | { | |
512 | if ( child == m_winLastFocused ) | |
513 | m_winLastFocused = NULL; | |
514 | ||
515 | if ( child == m_winDefault ) | |
516 | m_winDefault = NULL; | |
517 | ||
518 | if ( child == m_winTmpDefault ) | |
519 | m_winTmpDefault = NULL; | |
520 | } | |
521 | ||
522 | // ---------------------------------------------------------------------------- | |
523 | // focus handling | |
524 | // ---------------------------------------------------------------------------- | |
525 | ||
526 | bool wxControlContainer::DoSetFocus() | |
527 | { | |
528 | wxLogTrace(TRACE_FOCUS, _T("SetFocus on wxPanel 0x%p."), | |
529 | m_winParent->GetHandle()); | |
530 | ||
531 | if (m_inSetFocus) | |
532 | return true; | |
533 | ||
534 | // when the panel gets the focus we move the focus to either the last | |
535 | // window that had the focus or the first one that can get it unless the | |
536 | // focus had been already set to some other child | |
537 | ||
538 | wxWindow *win = wxWindow::FindFocus(); | |
539 | while ( win ) | |
540 | { | |
541 | if ( win == m_winParent ) | |
542 | { | |
543 | // our child already has focus, don't take it away from it | |
544 | return true; | |
545 | } | |
546 | ||
547 | if ( win->IsTopLevel() ) | |
548 | { | |
549 | // don't look beyond the first top level parent - useless and | |
550 | // unnecessary | |
551 | break; | |
552 | } | |
553 | ||
554 | win = win->GetParent(); | |
555 | } | |
556 | ||
557 | // protect against infinite recursion: | |
558 | m_inSetFocus = true; | |
559 | ||
560 | bool ret = SetFocusToChild(); | |
561 | ||
562 | m_inSetFocus = false; | |
563 | ||
564 | return ret; | |
565 | } | |
566 | ||
567 | void wxControlContainer::HandleOnFocus(wxFocusEvent& event) | |
568 | { | |
569 | wxLogTrace(TRACE_FOCUS, _T("OnFocus on wxPanel 0x%p, name: %s"), | |
570 | m_winParent->GetHandle(), | |
571 | m_winParent->GetName().c_str() ); | |
572 | ||
573 | DoSetFocus(); | |
574 | ||
575 | event.Skip(); | |
576 | } | |
577 | ||
578 | bool wxControlContainer::SetFocusToChild() | |
579 | { | |
580 | return wxSetFocusToChild(m_winParent, &m_winLastFocused); | |
581 | } | |
582 | ||
583 | // ---------------------------------------------------------------------------- | |
584 | // SetFocusToChild(): this function is used by wxPanel but also by wxFrame in | |
585 | // wxMSW, this is why it is outside of wxControlContainer class | |
586 | // ---------------------------------------------------------------------------- | |
587 | ||
588 | bool wxSetFocusToChild(wxWindow *win, wxWindow **childLastFocused) | |
589 | { | |
590 | wxCHECK_MSG( win, false, _T("wxSetFocusToChild(): invalid window") ); | |
591 | wxCHECK_MSG( childLastFocused, false, | |
592 | _T("wxSetFocusToChild(): NULL child poonter") ); | |
593 | ||
594 | if ( *childLastFocused ) | |
595 | { | |
596 | // It might happen that the window got reparented | |
597 | if ( (*childLastFocused)->GetParent() == win ) | |
598 | { | |
599 | wxLogTrace(TRACE_FOCUS, | |
600 | _T("SetFocusToChild() => last child (0x%p)."), | |
601 | (*childLastFocused)->GetHandle()); | |
602 | ||
603 | // not SetFocusFromKbd(): we're restoring focus back to the old | |
604 | // window and not setting it as the result of a kbd action | |
605 | (*childLastFocused)->SetFocus(); | |
606 | return true; | |
607 | } | |
608 | else | |
609 | { | |
610 | // it doesn't count as such any more | |
611 | *childLastFocused = (wxWindow *)NULL; | |
612 | } | |
613 | } | |
614 | ||
615 | // set the focus to the first child who wants it | |
616 | wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst(); | |
617 | while ( node ) | |
618 | { | |
619 | wxWindow *child = node->GetData(); | |
620 | ||
621 | if ( child->AcceptsFocusFromKeyboard() && !child->IsTopLevel() ) | |
622 | { | |
623 | #ifdef __WXMSW__ | |
624 | // If a radiobutton is the first focusable child, search for the | |
625 | // selected radiobutton in the same group | |
626 | wxRadioButton* btn = wxDynamicCast(child, wxRadioButton); | |
627 | if (btn) | |
628 | { | |
629 | wxRadioButton* selected = wxGetSelectedButtonInGroup(btn); | |
630 | if (selected) | |
631 | child = selected; | |
632 | } | |
633 | #endif | |
634 | ||
635 | wxLogTrace(TRACE_FOCUS, | |
636 | _T("SetFocusToChild() => first child (0x%p)."), | |
637 | child->GetHandle()); | |
638 | ||
639 | *childLastFocused = child; | |
640 | child->SetFocusFromKbd(); | |
641 | return true; | |
642 | } | |
643 | ||
644 | node = node->GetNext(); | |
645 | } | |
646 | ||
647 | return false; | |
648 | } | |
649 |