X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/0dcdeee9e74c3bc485c2daf45537e7f5e6431126..068b764a5a7cc2929b1fd8ea5643f43b5cbc8762:/src/common/containr.cpp?ds=sidebyside diff --git a/src/common/containr.cpp b/src/common/containr.cpp index 51a0e1744b..535513d54d 100644 --- a/src/common/containr.cpp +++ b/src/common/containr.cpp @@ -6,7 +6,7 @@ // Created: 06.08.01 // RCS-ID: $Id$ // Copyright: (c) 2001 Vadim Zeitlin -// License: wxWindows license +// License: wxWindows licence /////////////////////////////////////////////////////////////////////////////// // ============================================================================ @@ -17,7 +17,7 @@ // headers // ---------------------------------------------------------------------------- -#ifdef __GNUG__ +#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) #pragma implementation "containr.h" #endif @@ -36,6 +36,14 @@ #include "wx/containr.h" +#ifdef __WXMAC__ + #include "wx/scrolbar.h" +#endif + +#ifdef __WXMSW__ + #include "wx/radiobut.h" +#endif + // ============================================================================ // implementation // ============================================================================ @@ -45,22 +53,211 @@ wxControlContainer::wxControlContainer(wxWindow *winParent) m_winParent = winParent; m_winLastFocused = + m_winTmpDefault = m_winDefault = NULL; + m_inSetFocus = false; +} + +bool wxControlContainer::AcceptsFocus() const +{ + // if we're not shown or disabled, we can't accept focus + if ( m_winParent->IsShown() && m_winParent->IsEnabled() ) + { + // otherwise we can accept focus either if we have no children at all + // (in this case we're probably not used as a container) or only when + // at least one child will accept focus + wxWindowList::compatibility_iterator node = m_winParent->GetChildren().GetFirst(); + if ( !node ) + return true; + +#ifdef __WXMAC__ + // wxMac has eventually the two scrollbars as children, they don't count + // as real children in the algorithm mentioned above + bool hasRealChildren = false ; +#endif + + while ( node ) + { + wxWindow *child = node->GetData(); + + if ( child->AcceptsFocus() ) + { + return true; + } + +#ifdef __WXMAC__ + wxScrollBar *sb = wxDynamicCast( child , wxScrollBar ) ; + if ( sb == NULL || !m_winParent->MacIsWindowScrollbar( sb ) ) + hasRealChildren = true ; +#endif + node = node->GetNext(); + } + +#ifdef __WXMAC__ + if ( !hasRealChildren ) + return true ; +#endif + } + + return false; } void wxControlContainer::SetLastFocus(wxWindow *win) { - // find the last _immediate_ child which got focus - while ( win && win != m_winParent ) + // the panel itself should never get the focus at all but if it does happen + // temporarily (as it seems to do under wxGTK), at the very least don't + // forget our previous m_winLastFocused + if ( win != m_winParent ) { - win = win->GetParent(); + // if we're setting the focus + if ( win ) + { + // find the last _immediate_ child which got focus + wxWindow *winParent = win; + while ( winParent != m_winParent ) + { + win = winParent; + winParent = win->GetParent(); + + // Yes, this can happen, though in a totally pathological case. + // like when detaching a menubar from a frame with a child + // which has pushed itself as an event handler for the menubar. + // (under wxGTK) + + wxASSERT_MSG( winParent, + _T("Setting last focus for a window that is not our child?") ); + } + } + + m_winLastFocused = win; + + if ( win ) + { + wxLogTrace(_T("focus"), _T("Set last focus to %s(%s)"), + win->GetClassInfo()->GetClassName(), + win->GetLabel().c_str()); + } + else + { + wxLogTrace(_T("focus"), _T("No more last focus")); + } } - wxASSERT_MSG( win, _T("attempt to set last focus to not a child?") ); + // propagate the last focus upwards so that our parent can set focus back + // to us if it loses it now and regains later + wxWindow *parent = m_winParent->GetParent(); + if ( parent ) + { + wxChildFocusEvent eventFocus(m_winParent); + parent->GetEventHandler()->ProcessEvent(eventFocus); + } +} + +// -------------------------------------------------------------------- +// The following four functions are used to find other radio buttons +// within the same group. Used by wxSetFocusToChild on wxMSW +// -------------------------------------------------------------------- + +#ifdef __WXMSW__ + +wxRadioButton* wxGetPreviousButtonInGroup(wxRadioButton *btn) +{ + if ( btn->HasFlag(wxRB_GROUP) || btn->HasFlag(wxRB_SINGLE) ) + return NULL; + + const wxWindowList& siblings = btn->GetParent()->GetChildren(); + wxWindowList::compatibility_iterator nodeThis = siblings.Find(btn); + wxCHECK_MSG( nodeThis, NULL, _T("radio button not a child of its parent?") ); + + // Iterate over all previous siblings until we find the next radio button + wxWindowList::compatibility_iterator nodeBefore = nodeThis->GetPrevious(); + wxRadioButton *prevBtn = 0; + while (nodeBefore) + { + prevBtn = wxDynamicCast(nodeBefore->GetData(), wxRadioButton); + if (prevBtn) + break; + + nodeBefore = nodeBefore->GetPrevious(); + } - m_winLastFocused = win; + if (!prevBtn || prevBtn->HasFlag(wxRB_SINGLE)) + { + // no more buttons in group + return NULL; + } + else + return prevBtn; } +wxRadioButton* wxGetNextButtonInGroup(wxRadioButton *btn) +{ + if (btn->HasFlag(wxRB_SINGLE)) + return NULL; + + const wxWindowList& siblings = btn->GetParent()->GetChildren(); + wxWindowList::compatibility_iterator nodeThis = siblings.Find(btn); + wxCHECK_MSG( nodeThis, NULL, _T("radio button not a child of its parent?") ); + + // Iterate over all previous siblings until we find the next radio button + wxWindowList::compatibility_iterator nodeNext = nodeThis->GetNext(); + wxRadioButton *nextBtn = 0; + while (nodeNext) + { + nextBtn = wxDynamicCast(nodeNext->GetData(), wxRadioButton); + if (nextBtn) + break; + + nodeNext = nodeNext->GetNext(); + } + + if ( !nextBtn || nextBtn->HasFlag(wxRB_GROUP) || nextBtn->HasFlag(wxRB_SINGLE) ) + { + // no more buttons or the first button of the next group + return NULL; + } + else + return nextBtn; +} + +wxRadioButton* wxGetFirstButtonInGroup(wxRadioButton *btn) +{ + while (true) + { + wxRadioButton* prevBtn = wxGetPreviousButtonInGroup(btn); + if (!prevBtn) + return btn; + + btn = prevBtn; + } +} + +wxRadioButton* wxGetSelectedButtonInGroup(wxRadioButton *btn) +{ + // Find currently selected button + if (btn->GetValue()) + return btn; + + if (btn->HasFlag(wxRB_SINGLE)) + return NULL; + + wxRadioButton *selBtn; + + // First check all previous buttons + for (selBtn = wxGetPreviousButtonInGroup(btn); selBtn; selBtn = wxGetPreviousButtonInGroup(selBtn)) + if (selBtn->GetValue()) + return selBtn; + + // Now all following buttons + for (selBtn = wxGetNextButtonInGroup(btn); selBtn; selBtn = wxGetNextButtonInGroup(selBtn)) + if (selBtn->GetValue()) + return selBtn; + + return NULL; +} + +#endif // __WXMSW__ + // ---------------------------------------------------------------------------- // Keyboard handling - this is the place where the TAB traversal logic is // implemented. As this code is common to all ports, this ensures consistent @@ -98,7 +295,7 @@ void wxControlContainer::HandleOnNavigationKey( wxNavigationKeyEvent& event ) // the node of the children list from which we should start looking for the // next acceptable child - wxWindowList::Node *node, *start_node; + wxWindowList::compatibility_iterator node, start_node; // we should start from the first/last control and not from the one which // had focus the last time if we're propagating the event downwards because @@ -113,7 +310,7 @@ void wxControlContainer::HandleOnNavigationKey( wxNavigationKeyEvent& event ) node = forward ? children.GetFirst() : children.GetLast(); // we want to cycle over all nodes - start_node = (wxWindowList::Node *)NULL; + start_node = wxWindowList::compatibility_iterator(); } else { @@ -132,12 +329,18 @@ void wxControlContainer::HandleOnNavigationKey( wxNavigationKeyEvent& event ) if ( winFocus ) { +#ifdef __WXMSW__ + // If we are in a radio button group, start from the first item in the + // group + if ( event.IsFromTab() && wxIsKindOf(winFocus, wxRadioButton ) ) + winFocus = wxGetFirstButtonInGroup((wxRadioButton*)winFocus); +#endif // ok, we found the focus - now is it our child? start_node = children.Find( winFocus ); } else { - start_node = (wxWindowList::Node *)NULL; + start_node = wxWindowList::compatibility_iterator(); } if ( !start_node && m_winLastFocused ) @@ -199,23 +402,74 @@ void wxControlContainer::HandleOnNavigationKey( wxNavigationKeyEvent& event ) wxWindow *child = node->GetData(); - if ( child->AcceptsFocusFromKeyboard() ) +#ifdef __WXMSW__ + bool canSelectRadioButton = true; + if (!event.IsFromTab()) + { + // If navigating using cursor keys, make sure not to navigate out of a radio button group. + if (m_winLastFocused && wxIsKindOf(m_winLastFocused, wxRadioButton)) + { + if (!wxIsKindOf(child, wxRadioButton)) + { + child = forward ? + wxGetNextButtonInGroup((wxRadioButton*)m_winLastFocused) : + wxGetPreviousButtonInGroup((wxRadioButton*)m_winLastFocused); + if (!child) + { + event.Skip(false); + return; + } + } + } + } + else + { + // If navigating using tabs, skip all but the first radio button in a group. + if (wxIsKindOf(child, wxRadioButton)) + { + if (wxGetPreviousButtonInGroup((wxRadioButton*)child)) + canSelectRadioButton = false; + } + } +#else + static bool canSelectRadioButton = true; +#endif + + if ( child->AcceptsFocusFromKeyboard() && canSelectRadioButton ) { // if we're setting the focus to a child panel we should prevent it // from giving it to the child which had the focus the last time // and instead give it to the first/last child depending from which // direction we're coming event.SetEventObject(m_winParent); - if ( !child->GetEventHandler()->ProcessEvent(event) ) + +#if defined(__WXMSW__) + // we need to hop to the next activated + // radio button, not just the next radio + // button under MSW + if (wxIsKindOf(child, wxRadioButton) && event.IsFromTab()) { - // everything is simple: just give focus to it - child->SetFocus(); + wxRadioButton *rb = wxGetSelectedButtonInGroup((wxRadioButton*)child); + if (rb) + child = rb; + } +#endif // __WXMSW__ + // disable propagation for this call as otherwise the event might + // bounce back to us. + wxPropagationDisabler disableProp(event); + if ( !child->GetEventHandler()->ProcessEvent(event) ) + { + // set it first in case SetFocusFromKbd() results in focus + // change too m_winLastFocused = child; + + // everything is simple: just give focus to it + child->SetFocusFromKbd(); } //else: the child manages its focus itself - event.Skip( FALSE ); + event.Skip( false ); return; } @@ -235,6 +489,9 @@ void wxControlContainer::HandleOnWindowDestroy(wxWindowBase *child) if ( child == m_winDefault ) m_winDefault = NULL; + + if ( child == m_winTmpDefault ) + m_winTmpDefault = NULL; } // ---------------------------------------------------------------------------- @@ -243,42 +500,24 @@ void wxControlContainer::HandleOnWindowDestroy(wxWindowBase *child) bool wxControlContainer::DoSetFocus() { - wxLogTrace(_T("focus"), _T("SetFocus on wxPanel 0x%08x."), - m_winParent->GetHandle()); - - // If the panel gets the focus *by way of getting it set directly* - // we move the focus to the first window that can get it. - - // VZ: no, we set the focus to the last window too. I don't understand why - // should we make this distinction: if an app wants to set focus to - // some precise control, it may always do it directly, but if we don't - // use m_winLastFocused here, the focus won't be set correctly after a - // notebook page change nor after frame activation under MSW (it calls - // SetFocus too) - // - // RR: yes, when I the tab key to navigate in a panel with some controls and - // a notebook and the focus jumps to the notebook (typically coming from - // a button at the top) the notebook should focus the first child in the - // current notebook page, not the last one which would otherwise get the - // focus if you used the tab key to navigate from the current notebook - // page to button at the bottom. See every page in the controls sample. - // - // VZ: ok, but this still doesn't (at least I don't see how it can) take - // care of first/last child problem: i.e. if Shift-TAB is pressed in a - // situation like above, the focus should be given to the last child, - // not the first one (and not to the last focused one neither) - I - // think my addition to OnNavigationKey() above takes care of it. - // Keeping #ifdef __WXGTK__ for now, but please try removing it and see - // what happens. - // - // RR: Removed for now. Let's see what happens.. - - // if our child already has focus, don't take it away from it + wxLogTrace(_T("focus"), _T("SetFocus on wxPanel 0x%08lx."), + (unsigned long)m_winParent->GetHandle()); + + if (m_inSetFocus) + return true; + + // when the panel gets the focus we move the focus to either the last + // window that had the focus or the first one that can get it unless the + // focus had been already set to some other child + wxWindow *win = wxWindow::FindFocus(); while ( win ) { if ( win == m_winParent ) - return TRUE; + { + // our child already has focus, don't take it away from it + return true; + } if ( win->IsTopLevel() ) { @@ -290,19 +529,23 @@ bool wxControlContainer::DoSetFocus() win = win->GetParent(); } - return SetFocusToChild(); + // protect against infinite recursion: + m_inSetFocus = true; + + bool ret = SetFocusToChild(); + + m_inSetFocus = false; + + return ret; } void wxControlContainer::HandleOnFocus(wxFocusEvent& event) { - wxLogTrace(_T("focus"), _T("OnFocus on wxPanel 0x%08x, name: %s"), - m_winParent->GetHandle(), + wxLogTrace(_T("focus"), _T("OnFocus on wxPanel 0x%08lx, name: %s"), + (unsigned long)m_winParent->GetHandle(), m_winParent->GetName().c_str() ); - // If we panel got the focus *by way of getting clicked on* - // we move the focus to either the last window that had the - // focus or the first one that can get it. - (void)SetFocusToChild(); + DoSetFocus(); event.Skip(); } @@ -319,21 +562,23 @@ bool wxControlContainer::SetFocusToChild() bool wxSetFocusToChild(wxWindow *win, wxWindow **childLastFocused) { - wxCHECK_MSG( win, FALSE, _T("wxSetFocusToChild(): invalid window") ); + wxCHECK_MSG( win, false, _T("wxSetFocusToChild(): invalid window") ); + wxCHECK_MSG( childLastFocused, false, + _T("wxSetFocusToChild(): NULL child poonter") ); if ( *childLastFocused ) { - // It might happen that the window got reparented or no longer accepts - // the focus. - if ( (*childLastFocused)->GetParent() == win && - (*childLastFocused)->AcceptsFocusFromKeyboard() ) + // It might happen that the window got reparented + if ( (*childLastFocused)->GetParent() == win ) { wxLogTrace(_T("focus"), - _T("SetFocusToChild() => last child (0x%08x)."), - (*childLastFocused)->GetHandle()); + _T("SetFocusToChild() => last child (0x%08lx)."), + (unsigned long)(*childLastFocused)->GetHandle()); + // not SetFocusFromKbd(): we're restoring focus back to the old + // window and not setting it as the result of a kbd action (*childLastFocused)->SetFocus(); - return TRUE; + return true; } else { @@ -343,24 +588,37 @@ bool wxSetFocusToChild(wxWindow *win, wxWindow **childLastFocused) } // set the focus to the first child who wants it - wxWindowList::Node *node = win->GetChildren().GetFirst(); + wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst(); while ( node ) { wxWindow *child = node->GetData(); if ( child->AcceptsFocusFromKeyboard() && !child->IsTopLevel() ) { +#ifdef __WXMSW__ + // If a radiobutton is the first focusable child, search for the + // selected radiobutton in the same group + wxRadioButton* btn = wxDynamicCast(child, wxRadioButton); + if (btn) + { + wxRadioButton* selected = wxGetSelectedButtonInGroup(btn); + if (selected) + child = selected; + } +#endif + wxLogTrace(_T("focus"), - _T("SetFocusToChild() => first child (0x%08x)."), - child->GetHandle()); + _T("SetFocusToChild() => first child (0x%08lx)."), + (unsigned long)child->GetHandle()); - *childLastFocused = child; // should be redundant, but it is not - child->SetFocus(); - return TRUE; + *childLastFocused = child; + child->SetFocusFromKbd(); + return true; } node = node->GetNext(); } - return FALSE; + return false; } +