src/generic/panelg.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/generic/panelg.cpp
   3 // Purpose:     wxPanel and the keyboard handling code
   4 // Author:      Julian Smart, Robert Roebling, Vadim Zeitlin
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart and Markus Holzem
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "panelg.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/object.h"
  33     #include "wx/font.h"
  34     #include "wx/colour.h"
  35     #include "wx/settings.h"
  36     #include "wx/log.h"
  37 #endif
  38
  39 #include "wx/toolbar.h"
  40 #include "wx/statusbr.h"
  41
  42 #include "wx/generic/panelg.h"
  43
  44 // ----------------------------------------------------------------------------
  45 // wxWin macros
  46 // ----------------------------------------------------------------------------
  47
  48 IMPLEMENT_DYNAMIC_CLASS(wxPanel, wxWindow)
  49
  50 BEGIN_EVENT_TABLE(wxPanel, wxWindow)
  51   EVT_SYS_COLOUR_CHANGED(wxPanel::OnSysColourChanged)
  52   EVT_SET_FOCUS(wxPanel::OnFocus)
  53   EVT_NAVIGATION_KEY(wxPanel::OnNavigationKey)
  54   EVT_SIZE(wxPanel::OnSize)
  55 END_EVENT_TABLE()
  56
  57 // ============================================================================
  58 // implementation
  59 // ============================================================================
  60
  61 // ----------------------------------------------------------------------------
  62 // wxPanel creation
  63 // ----------------------------------------------------------------------------
  64
  65 void wxPanel::Init()
  66 {
  67     m_winLastFocused = (wxWindow *)NULL;
  68     m_btnDefault = (wxButton *)NULL;
  69 }
  70
  71 bool wxPanel::Create(wxWindow *parent, wxWindowID id,
  72                      const wxPoint& pos,
  73                      const wxSize& size,
  74                      long style,
  75                      const wxString& name)
  76 {
  77     bool ret = wxWindow::Create(parent, id, pos, size, style, name);
  78
  79     if ( ret )
  80     {
  81         SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
  82         SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
  83     }
  84
  85     return ret;
  86 }
  87
  88 // ----------------------------------------------------------------------------
  89 // misc
  90 // ----------------------------------------------------------------------------
  91
  92 void wxPanel::InitDialog()
  93 {
  94     wxInitDialogEvent event(GetId());
  95     event.SetEventObject(this);
  96     GetEventHandler()->ProcessEvent(event);
  97 }
  98
  99 // Responds to colour changes, and passes event on to children.
 100 void wxPanel::OnSysColourChanged(wxSysColourChangedEvent& event)
 101 {
 102     SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
 103     Refresh();
 104
 105     // Propagate the event to the non-top-level children
 106     wxWindow::OnSysColourChanged(event);
 107 }
 108
 109 void wxPanel::OnSize(wxSizeEvent& WXUNUSED(event))
 110 {
 111 #if wxUSE_CONSTRAINTS
 112     if (GetAutoLayout())
 113         Layout();
 114 #endif
 115 }
 116
 117 // ----------------------------------------------------------------------------
 118 // Keyboard handling - this is the place where the TAB traversal logic is
 119 // implemented. As this code is common to all ports, this ensures consistent
 120 // behaviour even if we don't specify how exactly the wxNavigationKeyEvent are
 121 // generated and this is done in platform specific code which also ensures that
 122 // we can follow the given platform standards.
 123 // ----------------------------------------------------------------------------
 124
 125 void wxPanel::OnNavigationKey( wxNavigationKeyEvent& event )
 126 {
 127     // the event is propagated downwards if the event emitter was our parent
 128     bool goingDown = event.GetEventObject() == GetParent();
 129
 130     const wxWindowList& children = GetChildren();
 131
 132     // there is not much to do if we don't have children and we're not
 133     // interested in "notebook page change" events here
 134     if ( !children.GetCount() || event.IsWindowChange() )
 135     {
 136         // let the parent process it unless it already comes from our parent
 137         // of we don't have any
 138         wxWindow *parent = GetParent();
 139         if ( goingDown ||
 140              !parent || !parent->GetEventHandler()->ProcessEvent(event) )
 141         {
 142             event.Skip();
 143         }
 144
 145         return;
 146     }
 147
 148     // where are we going?
 149     bool forward = event.GetDirection();
 150
 151     // the node of the children list from which we should start looking for the
 152     // next acceptable child
 153     wxWindowList::Node *node, *start_node;
 154
 155     // we should start from the first/last control and not from the one which
 156     // had focus the last time if we're propagating the event downwards because
 157     // for our parent we look like a single control
 158     if ( goingDown )
 159     {
 160         // just to be sure it's not used (normally this is not necessary, but
 161         // doesn't hurt neither)
 162         m_winLastFocused = (wxWindow *)NULL;
 163
 164         // start from first or last depending on where we're going
 165         node = forward ? children.GetFirst() : children.GetLast();
 166
 167         // we want to cycle over all nodes
 168         start_node = (wxWindowList::Node *)NULL;
 169     }
 170     else
 171     {
 172         // try to find the child which has the focus currently
 173
 174         // the event emitter might have done this for us
 175         wxWindow *winFocus = event.GetCurrentFocus();
 176
 177         // but if not, we might know where the focus was ourselves
 178         if (!winFocus)
 179             winFocus = m_winLastFocused;
 180
 181         // if still no luck, do it the hard way
 182         if (!winFocus)
 183             winFocus = wxWindow::FindFocus();
 184
 185         if ( winFocus )
 186         {
 187             // ok, we found the focus - now is it our child?
 188             start_node = children.Find( winFocus );
 189         }
 190         else
 191         {
 192             start_node = (wxWindowList::Node *)NULL;
 193         }
 194
 195         if ( !start_node && m_winLastFocused )
 196         {
 197             // window which has focus isn't our child, fall back to the one
 198             // which had the focus the last time
 199             start_node = children.Find( m_winLastFocused );
 200         }
 201
 202         // if we still didn't find anything, we should start with the first one
 203         if ( !start_node )
 204         {
 205             start_node = children.GetFirst();
 206         }
 207
 208         // and the first child which we can try setting focus to is the next or
 209         // the previous one
 210         node = forward ? start_node->GetNext() : start_node->GetPrevious();
 211     }
 212
 213     // we want to cycle over all elements passing by NULL
 214     while ( node != start_node )
 215     {
 216         // Have we come to the last or first item on the panel?
 217         if ( !node )
 218         {
 219             if ( !goingDown )
 220             {
 221                 // Check if our (may be grand) parent is another panel: if this
 222                 // is the case, they will know what to do with this navigation
 223                 // key and so give them the chance to process it instead of
 224                 // looping inside this panel (normally, the focus will go to
 225                 // the next/previous item after this panel in the parent
 226                 // panel).
 227                 wxWindow *focussed_child_of_parent = this;
 228                 for ( wxWindow *parent = GetParent();
 229                       parent;
 230                       parent = parent->GetParent() )
 231                 {
 232                     // we don't want to tab into a different dialog or frame
 233                     if ( focussed_child_of_parent->IsTopLevel() )
 234                         break;
 235
 236                     event.SetCurrentFocus( focussed_child_of_parent );
 237                     if (parent->GetEventHandler()->ProcessEvent( event ))
 238                         return;
 239
 240                     focussed_child_of_parent = parent;
 241                 }
 242             }
 243             //else: as the focus came from our parent, we definitely don't want
 244             //      to send it back to it!
 245
 246             // no, we are not inside another panel so process this ourself
 247             node = forward ? children.GetFirst() : children.GetLast();
 248
 249             continue;
 250         }
 251
 252         wxWindow *child = node->GetData();
 253
 254         if ( child->AcceptsFocus() )
 255         {
 256             m_winLastFocused = child;  // should be redundant, but it is not
 257
 258             // if we're setting the focus to a child panel we should prevent it
 259             // from giving it to the child which had the focus the last time
 260             // and instead give it to the first/last child depending from which
 261             // direction we're coming
 262             wxPanel *subpanel = wxDynamicCast(child, wxPanel);
 263             if ( subpanel )
 264             {
 265                 // trick the panel into thinking that it got the navigation
 266                 // event - instead of duplicating all the code here
 267                 //
 268                 // make sure that we do trick it by setting all the parameters
 269                 // correctly (consistently with the code in this very function
 270                 // above) and that it starts from the very beginning/end by
 271                 // using SetLastFocus(NULL)
 272                 subpanel->SetLastFocus((wxWindow *)NULL);
 273             }
 274
 275             event.SetEventObject(this);
 276             if ( !child->GetEventHandler()->ProcessEvent(event) )
 277             {
 278                 // everything is simple: just give focus to it
 279                 child->SetFocus();
 280             }
 281             //else: the child manages its focus itself
 282
 283             event.Skip( FALSE );
 284             return;
 285         }
 286
 287         node = forward ? node->GetNext() : node->GetPrevious();
 288     }
 289
 290     // we cycled through all of our children and none of them wanted to accept
 291     // focus
 292     event.Skip();
 293 }
 294
 295 void wxPanel::SetFocus()
 296 {
 297     wxLogTrace(_T("focus"), _T("SetFocus on wxPanel 0x%08x."), GetHandle());
 298
 299     // If the panel gets the focus *by way of getting it set directly*
 300     // we move the focus to the first window that can get it.
 301
 302     // VZ: no, we set the focus to the last window too. I don't understand why
 303     //     should we make this distinction: if an app wants to set focus to
 304     //     some precise control, it may always do it directly, but if we don't
 305     //     use m_winLastFocused here, the focus won't be set correctly after a
 306     //     notebook page change nor after frame activation under MSW (it calls
 307     //     SetFocus too)
 308     //
 309     // RR: yes, when I the tab key to navigate in a panel with some controls and
 310     //     a notebook and the focus jumps to the notebook (typically coming from
 311     //     a button at the top) the notebook should focus the first child in the
 312     //     current notebook page, not the last one which would otherwise get the
 313     //     focus if you used the tab key to navigate from the current notebook
 314     //     page to button at the bottom. See every page in the controls sample.
 315     //
 316     // VZ: ok, but this still doesn't (at least I don't see how it can) take
 317     //     care of first/last child problem: i.e. if Shift-TAB is pressed in a
 318     //     situation like above, the focus should be given to the last child,
 319     //     not the first one (and not to the last focused one neither) - I
 320     //     think my addition to OnNavigationKey() above takes care of it.
 321     //     Keeping #ifdef __WXGTK__ for now, but please try removing it and see
 322     //     what happens.
 323     //
 324     // RR: Removed for now. Let's see what happens..
 325
 326     if ( !SetFocusToChild() )
 327     {
 328         wxWindow::SetFocus();
 329     }
 330 }
 331
 332 void wxPanel::OnFocus(wxFocusEvent& event)
 333 {
 334     wxLogTrace(_T("focus"), _T("OnFocus on wxPanel 0x%08x, name: %s"), GetHandle(), GetName().c_str() );
 335
 336     // If the panel gets the focus *by way of getting clicked on*
 337     // we move the focus to either the last window that had the
 338     // focus or the first one that can get it.
 339     (void)SetFocusToChild();
 340
 341     event.Skip();
 342 }
 343
 344 bool wxPanel::SetFocusToChild()
 345 {
 346     return wxSetFocusToChild(this, &m_winLastFocused);
 347 }
 348
 349 // ----------------------------------------------------------------------------
 350 // SetFocusToChild(): this function is used by wxPanel but also by wxFrame in
 351 // wxMSW, this is why it is outside of wxPanel class
 352 // ----------------------------------------------------------------------------
 353
 354 bool wxSetFocusToChild(wxWindow *win, wxWindow **childLastFocused)
 355 {
 356     if ( *childLastFocused )
 357     {
 358         // It might happen that the window got reparented or no longer accepts
 359         // the focus.
 360         if ( (*childLastFocused)->GetParent() == win &&
 361              (*childLastFocused)->AcceptsFocus() )
 362         {
 363             wxLogTrace(_T("focus"),
 364                        _T("SetFocusToChild() => last child (0x%08x)."),
 365                        (*childLastFocused)->GetHandle());
 366
 367             (*childLastFocused)->SetFocus();
 368             return TRUE;
 369         }
 370         else
 371         {
 372             // it doesn't count as such any more
 373             *childLastFocused = (wxWindow *)NULL;
 374         }
 375     }
 376
 377     // set the focus to the first child who wants it
 378     wxWindowList::Node *node = win->GetChildren().GetFirst();
 379     while ( node )
 380     {
 381         wxWindow *child = node->GetData();
 382
 383         if ( child->AcceptsFocus()
 384              && !child->IsTopLevel()
 385 #if wxUSE_TOOLBAR
 386              && !wxDynamicCast(child, wxToolBar)
 387 #endif // wxUSE_TOOLBAR
 388 #if wxUSE_STATUSBAR
 389              && !wxDynamicCast(child, wxStatusBar)
 390 #endif // wxUSE_STATUSBAR
 391            )
 392         {
 393             wxLogTrace(_T("focus"),
 394                        _T("SetFocusToChild() => first child (0x%08x)."),
 395                        child->GetHandle());
 396
 397             *childLastFocused = child;  // should be redundant, but it is not
 398             child->SetFocus();
 399             return TRUE;
 400         }
 401
 402         node = node->GetNext();
 403     }
 404
 405     return FALSE;
 406 }