src/common/containr.cpp

   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 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  21     #pragma implementation "containr.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/log.h"
  33     #include "wx/event.h"
  34     #include "wx/window.h"
  35 #endif //WX_PRECOMP
  36
  37 #include "wx/containr.h"
  38
  39 #ifdef __WXMAC__
  40     #include "wx/scrolbar.h"
  41 #endif
  42
  43 #ifdef __WXMSW__
  44     #include "wx/radiobut.h"
  45 #endif
  46
  47 // ============================================================================
  48 // implementation
  49 // ============================================================================
  50
  51 wxControlContainer::wxControlContainer(wxWindow *winParent)
  52 {
  53     m_winParent = winParent;
  54
  55     m_winLastFocused =
  56     m_winTmpDefault =
  57     m_winDefault = NULL;
  58     m_inSetFocus = false;
  59 }
  60
  61 bool wxControlContainer::AcceptsFocus() const
  62 {
  63     // if we're not shown or disabled, we can't accept focus
  64     if ( m_winParent->IsShown() && m_winParent->IsEnabled() )
  65     {
  66         // otherwise we can accept focus either if we have no children at all
  67         // (in this case we're probably not used as a container) or only when
  68         // at least one child will accept focus
  69         wxWindowList::compatibility_iterator node = m_winParent->GetChildren().GetFirst();
  70         if ( !node )
  71             return true;
  72
  73 #ifdef __WXMAC__
  74         // wxMac has eventually the two scrollbars as children, they don't count
  75         // as real children in the algorithm mentioned above
  76         bool hasRealChildren = false ;
  77 #endif
  78
  79         while ( node )
  80         {
  81             wxWindow *child = node->GetData();
  82
  83             if ( child->AcceptsFocus() )
  84             {
  85                 return true;
  86             }
  87
  88 #ifdef __WXMAC__
  89             wxScrollBar *sb = wxDynamicCast( child , wxScrollBar ) ;
  90             if ( sb == NULL || !m_winParent->MacIsWindowScrollbar( sb ) )
  91                 hasRealChildren = true ;
  92 #endif
  93             node = node->GetNext();
  94         }
  95
  96 #ifdef __WXMAC__
  97         if ( !hasRealChildren )
  98             return true ;
  99 #endif
 100     }
 101
 102     return false;
 103 }
 104
 105 void wxControlContainer::SetLastFocus(wxWindow *win)
 106 {
 107     // the panel itself should never get the focus at all but if it does happen
 108     // temporarily (as it seems to do under wxGTK), at the very least don't
 109     // forget our previous m_winLastFocused
 110     if ( win != m_winParent )
 111     {
 112         // if we're setting the focus
 113         if ( win )
 114         {
 115             // find the last _immediate_ child which got focus
 116             wxWindow *winParent = win;
 117             while ( winParent != m_winParent )
 118             {
 119                 win = winParent;
 120                 winParent = win->GetParent();
 121
 122                 // Yes, this can happen, though in a totally pathological case.
 123                 // like when detaching a menubar from a frame with a child
 124                 // which has pushed itself as an event handler for the menubar.
 125                 // (under wxGTK)
 126
 127                 wxASSERT_MSG( winParent,
 128                               _T("Setting last focus for a window that is not our child?") );
 129             }
 130         }
 131
 132         m_winLastFocused = win;
 133
 134         if ( win )
 135         {
 136             wxLogTrace(_T("focus"), _T("Set last focus to %s(%s)"),
 137                        win->GetClassInfo()->GetClassName(),
 138                        win->GetLabel().c_str());
 139         }
 140         else
 141         {
 142             wxLogTrace(_T("focus"), _T("No more last focus"));
 143         }
 144     }
 145
 146     // propagate the last focus upwards so that our parent can set focus back
 147     // to us if it loses it now and regains later
 148     wxWindow *parent = m_winParent->GetParent();
 149     if ( parent )
 150     {
 151         wxChildFocusEvent eventFocus(m_winParent);
 152         parent->GetEventHandler()->ProcessEvent(eventFocus);
 153     }
 154 }
 155
 156 // ----------------------------------------------------------------------------
 157 // Keyboard handling - this is the place where the TAB traversal logic is
 158 // implemented. As this code is common to all ports, this ensures consistent
 159 // behaviour even if we don't specify how exactly the wxNavigationKeyEvent are
 160 // generated and this is done in platform specific code which also ensures that
 161 // we can follow the given platform standards.
 162 // ----------------------------------------------------------------------------
 163
 164 void wxControlContainer::HandleOnNavigationKey( wxNavigationKeyEvent& event )
 165 {
 166     wxWindow *parent = m_winParent->GetParent();
 167
 168     // the event is propagated downwards if the event emitter was our parent
 169     bool goingDown = event.GetEventObject() == parent;
 170
 171     const wxWindowList& children = m_winParent->GetChildren();
 172
 173     // there is not much to do if we don't have children and we're not
 174     // interested in "notebook page change" events here
 175     if ( !children.GetCount() || event.IsWindowChange() )
 176     {
 177         // let the parent process it unless it already comes from our parent
 178         // of we don't have any
 179         if ( goingDown ||
 180              !parent || !parent->GetEventHandler()->ProcessEvent(event) )
 181         {
 182             event.Skip();
 183         }
 184
 185         return;
 186     }
 187
 188     // where are we going?
 189     bool forward = event.GetDirection();
 190
 191     // the node of the children list from which we should start looking for the
 192     // next acceptable child
 193     wxWindowList::compatibility_iterator node, start_node;
 194
 195     // we should start from the first/last control and not from the one which
 196     // had focus the last time if we're propagating the event downwards because
 197     // for our parent we look like a single control
 198     if ( goingDown )
 199     {
 200         // just to be sure it's not used (normally this is not necessary, but
 201         // doesn't hurt neither)
 202         m_winLastFocused = (wxWindow *)NULL;
 203
 204         // start from first or last depending on where we're going
 205         node = forward ? children.GetFirst() : children.GetLast();
 206
 207         // we want to cycle over all nodes
 208         start_node = wxWindowList::compatibility_iterator();
 209     }
 210     else
 211     {
 212         // try to find the child which has the focus currently
 213
 214         // the event emitter might have done this for us
 215         wxWindow *winFocus = event.GetCurrentFocus();
 216
 217         // but if not, we might know where the focus was ourselves
 218         if (!winFocus)
 219             winFocus = m_winLastFocused;
 220
 221         // if still no luck, do it the hard way
 222         if (!winFocus)
 223             winFocus = wxWindow::FindFocus();
 224
 225         if ( winFocus )
 226         {
 227             // ok, we found the focus - now is it our child?
 228             start_node = children.Find( winFocus );
 229         }
 230         else
 231         {
 232             start_node = wxWindowList::compatibility_iterator();
 233         }
 234
 235         if ( !start_node && m_winLastFocused )
 236         {
 237             // window which has focus isn't our child, fall back to the one
 238             // which had the focus the last time
 239             start_node = children.Find( m_winLastFocused );
 240         }
 241
 242         // if we still didn't find anything, we should start with the first one
 243         if ( !start_node )
 244         {
 245             start_node = children.GetFirst();
 246         }
 247
 248         // and the first child which we can try setting focus to is the next or
 249         // the previous one
 250         node = forward ? start_node->GetNext() : start_node->GetPrevious();
 251     }
 252
 253     // we want to cycle over all elements passing by NULL
 254     while ( node != start_node )
 255     {
 256         // Have we come to the last or first item on the panel?
 257         if ( !node )
 258         {
 259             if ( !goingDown )
 260             {
 261                 // Check if our (may be grand) parent is another panel: if this
 262                 // is the case, they will know what to do with this navigation
 263                 // key and so give them the chance to process it instead of
 264                 // looping inside this panel (normally, the focus will go to
 265                 // the next/previous item after this panel in the parent
 266                 // panel).
 267                 wxWindow *focussed_child_of_parent = m_winParent;
 268                 while ( parent )
 269                 {
 270                     // we don't want to tab into a different dialog or frame
 271                     if ( focussed_child_of_parent->IsTopLevel() )
 272                         break;
 273
 274                     event.SetCurrentFocus( focussed_child_of_parent );
 275                     if ( parent->GetEventHandler()->ProcessEvent( event ) )
 276                         return;
 277
 278                     focussed_child_of_parent = parent;
 279
 280                     parent = parent->GetParent();
 281                 }
 282             }
 283             //else: as the focus came from our parent, we definitely don't want
 284             //      to send it back to it!
 285
 286             // no, we are not inside another panel so process this ourself
 287             node = forward ? children.GetFirst() : children.GetLast();
 288
 289             continue;
 290         }
 291
 292         wxWindow *child = node->GetData();
 293
 294 #ifdef __WXMSW__
 295         bool is_not_msw_rb = !m_winLastFocused ||
 296                                 !wxIsKindOf(m_winLastFocused,wxRadioButton);
 297 #else
 298         static const bool is_not_msw_rb = true;
 299 #endif
 300
 301         if ( child->AcceptsFocusFromKeyboard() && is_not_msw_rb )
 302         {
 303             // if we're setting the focus to a child panel we should prevent it
 304             // from giving it to the child which had the focus the last time
 305             // and instead give it to the first/last child depending from which
 306             // direction we're coming
 307             event.SetEventObject(m_winParent);
 308
 309 #ifdef __WXMSW__
 310             // we need to hop to the next activated
 311             // radio button, not just the next radio
 312             // button under MSW
 313             if (wxIsKindOf(child,wxRadioButton))
 314             {
 315                 wxRadioButton *rb = (wxRadioButton*) child;
 316                 if (!rb->GetValue())
 317                 {
 318                     for (;;)
 319                     {
 320                         wxWindowList::compatibility_iterator node = children.Find( child );
 321                         if (forward)
 322                             node = node->GetNext();
 323                         else
 324                             node = node->GetPrevious();
 325                         if (!node)
 326                             return; // this would probably an error
 327                         child = node->GetData();
 328                         if (!wxIsKindOf(child,wxRadioButton))
 329                             continue;
 330                         rb = (wxRadioButton*) child;
 331                         if (rb->GetValue())
 332                             break;
 333                     }
 334                 }
 335             }
 336 #endif // __WXMSW__
 337
 338             // disable propagation for this call as otherwise the event might
 339             // bounce back to us.
 340             wxPropagationDisabler disableProp(event);
 341             if ( !child->GetEventHandler()->ProcessEvent(event) )
 342             {
 343                 // set it first in case SetFocusFromKbd() results in focus
 344                 // change too
 345                 m_winLastFocused = child;
 346
 347                 // everything is simple: just give focus to it
 348                 child->SetFocusFromKbd();
 349             }
 350             //else: the child manages its focus itself
 351
 352             event.Skip( false );
 353
 354             return;
 355         }
 356
 357         node = forward ? node->GetNext() : node->GetPrevious();
 358     }
 359
 360     // we cycled through all of our children and none of them wanted to accept
 361     // focus
 362     event.Skip();
 363 }
 364
 365 void wxControlContainer::HandleOnWindowDestroy(wxWindowBase *child)
 366 {
 367     if ( child == m_winLastFocused )
 368         m_winLastFocused = NULL;
 369
 370     if ( child == m_winDefault )
 371         m_winDefault = NULL;
 372
 373     if ( child == m_winTmpDefault )
 374         m_winTmpDefault = NULL;
 375 }
 376
 377 // ----------------------------------------------------------------------------
 378 // focus handling
 379 // ----------------------------------------------------------------------------
 380
 381 bool wxControlContainer::DoSetFocus()
 382 {
 383     wxLogTrace(_T("focus"), _T("SetFocus on wxPanel 0x%08lx."),
 384                (unsigned long)m_winParent->GetHandle());
 385
 386     if (m_inSetFocus)
 387         return true;
 388
 389     // when the panel gets the focus we move the focus to either the last
 390     // window that had the focus or the first one that can get it unless the
 391     // focus had been already set to some other child
 392
 393     wxWindow *win = wxWindow::FindFocus();
 394     while ( win )
 395     {
 396         if ( win == m_winParent )
 397         {
 398             // our child already has focus, don't take it away from it
 399             return true;
 400         }
 401
 402         if ( win->IsTopLevel() )
 403         {
 404             // don't look beyond the first top level parent - useless and
 405             // unnecessary
 406             break;
 407         }
 408
 409         win = win->GetParent();
 410     }
 411
 412     // protect against infinite recursion:
 413     m_inSetFocus = true;
 414
 415     bool ret = SetFocusToChild();
 416
 417     m_inSetFocus = false;
 418
 419     return ret;
 420 }
 421
 422 void wxControlContainer::HandleOnFocus(wxFocusEvent& event)
 423 {
 424     wxLogTrace(_T("focus"), _T("OnFocus on wxPanel 0x%08lx, name: %s"),
 425                (unsigned long)m_winParent->GetHandle(),
 426                m_winParent->GetName().c_str() );
 427
 428     DoSetFocus();
 429
 430     event.Skip();
 431 }
 432
 433 bool wxControlContainer::SetFocusToChild()
 434 {
 435     return wxSetFocusToChild(m_winParent, &m_winLastFocused);
 436 }
 437
 438 // ----------------------------------------------------------------------------
 439 // SetFocusToChild(): this function is used by wxPanel but also by wxFrame in
 440 // wxMSW, this is why it is outside of wxControlContainer class
 441 // ----------------------------------------------------------------------------
 442
 443 bool wxSetFocusToChild(wxWindow *win, wxWindow **childLastFocused)
 444 {
 445     wxCHECK_MSG( win, false, _T("wxSetFocusToChild(): invalid window") );
 446     wxCHECK_MSG( childLastFocused, false,
 447                  _T("wxSetFocusToChild(): NULL child poonter") );
 448
 449     if ( *childLastFocused )
 450     {
 451         // It might happen that the window got reparented
 452         if ( (*childLastFocused)->GetParent() == win )
 453         {
 454             wxLogTrace(_T("focus"),
 455                        _T("SetFocusToChild() => last child (0x%08lx)."),
 456                        (unsigned long)(*childLastFocused)->GetHandle());
 457
 458             // not SetFocusFromKbd(): we're restoring focus back to the old
 459             // window and not setting it as the result of a kbd action
 460             (*childLastFocused)->SetFocus();
 461             return true;
 462         }
 463         else
 464         {
 465             // it doesn't count as such any more
 466             *childLastFocused = (wxWindow *)NULL;
 467         }
 468     }
 469
 470     // set the focus to the first child who wants it
 471     wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
 472     while ( node )
 473     {
 474         wxWindow *child = node->GetData();
 475
 476         if ( child->AcceptsFocusFromKeyboard() && !child->IsTopLevel() )
 477         {
 478             wxLogTrace(_T("focus"),
 479                        _T("SetFocusToChild() => first child (0x%08lx)."),
 480                        (unsigned long)child->GetHandle());
 481
 482             *childLastFocused = child;
 483             child->SetFocusFromKbd();
 484             return true;
 485         }
 486
 487         node = node->GetNext();
 488     }
 489
 490     return false;
 491 }
 492