1. wxMSW::wxNotebook::SetPageSize() and SetPadding() added

2. wxNavigationKeyEvent changes:
 a) doesn't derive from wxCommandEvent any more
 b) has a new ShouldPropagate() accessor
 c) wxPanel::OnNavigationKey() changed significantly, beware


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@5605 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/event.h

@@ -1248,27 +1248,56 @@ protected:
  Event generated by dialog navigation keys
  wxEVT_NAVIGATION_KEY
  */
-// must derive from command event to be propagated to the parent
+// NB: don't derive from command event to avoid being propagated to the parent
-class WXDLLEXPORT wxNavigationKeyEvent : public wxCommandEvent
+class WXDLLEXPORT wxNavigationKeyEvent : public wxEvent
 {
-    DECLARE_DYNAMIC_CLASS(wxNavigationKeyEvent)
-
 public:
-    wxNavigationKeyEvent() : wxCommandEvent(wxEVT_NAVIGATION_KEY) { }
+    wxNavigationKeyEvent()
+    {
+        SetEventType(wxEVT_NAVIGATION_KEY);
+
+        m_flags = IsForward | Propagate;    // defaults are for TAB
+        m_focus = (wxWindow *)NULL;
+    }
 
     // direction: forward (true) or backward (false)
-    bool GetDirection() const        { return m_commandInt == 1; }
+    bool GetDirection() const
-    void SetDirection(bool bForward) { m_commandInt = bForward;  }
+        { return (m_flags & IsForward) != 0; }
+    void SetDirection(bool bForward)
+        { if ( bForward ) m_flags |= IsForward; else m_flags &= ~IsForward; }
 
     // it may be a window change event (MDI, notebook pages...) or a control
     // change event
-    bool IsWindowChange() const    { return m_extraLong == 1; }
+    bool IsWindowChange() const
-    void SetWindowChange(bool bIs) { m_extraLong = bIs; }
+        { return (m_flags & WinChange) != 0; }
+    void SetWindowChange(bool bIs)
+        { if ( bIs ) m_flags |= WinChange; else m_flags &= ~WinChange; }
+
+    // some navigation events are meant to be propagated upwards (Windows
+    // convention is to do this for TAB events) while others should always
+    // cycle inside the panel/radiobox/whatever we're current inside
+    bool ShouldPropagate() const
+        { return (m_flags & Propagate) != 0; }
+    void SetPropagate(bool bDoIt)
+        { if ( bDoIt ) m_flags |= Propagate; else m_flags &= ~Propagate; }
 
     // the child which has the focus currently (may be NULL - use
     // wxWindow::FindFocus then)
-    wxWindow* GetCurrentFocus() const { return (wxWindow *)m_clientData; }
+    wxWindow* GetCurrentFocus() const { return m_focus; }
-    void SetCurrentFocus(wxWindow *win) { m_clientData = (void *)win; }
+    void SetCurrentFocus(wxWindow *win) { m_focus = win; }
+
+private:
+    enum
+    {
+        IsForward = 0x0001,
+        WinChange = 0x0002,
+        Propagate = 0x0004
+    };
+
+    long m_flags;
+    wxWindow *m_focus;
+
+    DECLARE_DYNAMIC_CLASS(wxNavigationKeyEvent)
 };
 
 // Window creation/destruction events: the first is sent as soon as window is

src/generic/panelg.cpp

@@ -1,7 +1,7 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        panelg.cpp
+// Name:        src/generic/panelg.cpp
-// Purpose:     wxPanel
+// Purpose:     wxPanel and the keyboard handling code
-// Author:      Julian Smart
+// Author:      Julian Smart, Robert Roebling, Vadim Zeitlin
 // Modified by:
 // Created:     04/01/98
 // RCS-ID:      $Id$
@@ -9,6 +9,14 @@
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
 #ifdef __GNUG__
     #pragma implementation "panelg.h"
 #endif
@@ -30,6 +38,10 @@
 
 #include "wx/generic/panelg.h"
 
+// ----------------------------------------------------------------------------
+// wxWin macros
+// ----------------------------------------------------------------------------
+
 IMPLEMENT_DYNAMIC_CLASS(wxPanel, wxWindow)
 
 BEGIN_EVENT_TABLE(wxPanel, wxWindow)
@@ -39,6 +51,13 @@ BEGIN_EVENT_TABLE(wxPanel, wxWindow)
   EVT_SIZE(wxPanel::OnSize)
 END_EVENT_TABLE()
 
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxPanel creation
+// ----------------------------------------------------------------------------
 
 void wxPanel::Init()
 {
@@ -63,7 +82,11 @@ bool wxPanel::Create(wxWindow *parent, wxWindowID id,
     return ret;
 }
 
-void wxPanel::InitDialog(void)
+// ----------------------------------------------------------------------------
+// misc
+// ----------------------------------------------------------------------------
+
+void wxPanel::InitDialog()
 {
     wxInitDialogEvent event(GetId());
     event.SetEventObject(this);
@@ -80,61 +103,125 @@ void wxPanel::OnSysColourChanged(wxSysColourChangedEvent& event)
     wxWindow::OnSysColourChanged(event);
 }
 
+void wxPanel::OnSize(wxSizeEvent& WXUNUSED(event))
+{
+#if wxUSE_CONSTRAINTS
+    if (GetAutoLayout())
+        Layout();
+#endif
+}
+
+// ----------------------------------------------------------------------------
+// Keyboard handling - this is the place where the TAB traversal logic is
+// implemented. As this code is common to all ports, this ensures consistent
+// behaviour even if we don't specify how exactly the wxNavigationKeyEvent are
+// generated and this is done in platform specific code which also ensures that
+// we can follow the given platform standards.
+// ----------------------------------------------------------------------------
+
 void wxPanel::OnNavigationKey( wxNavigationKeyEvent& event )
 {
-    // there is not much to do if we have only one child (or not at all)
+    // there is not much to do if we have only one child (or not at all) and
-    if (GetChildren().GetCount() < 2)
+    // we're not interested in "notebook page change" events here
+    if ( (GetChildren().GetCount() < 2) || event.IsWindowChange() )
+    {
+        wxWindow *parent = GetParent();
+        if ( !parent || !parent->GetEventHandler()->ProcessEvent(event) )
         {
             event.Skip();
+        }
+
         return;
     }
 
-    // don't process these ones here
+    // where are we going?
-    if (event.IsWindowChange())
+    bool forward = event.GetDirection();
-    {
-        event.Skip();
-        return;
-    }
 
-    // Did the event emitter tell us where the last focus was?
+    // the node of the children list from which we should start looking for the
-    // wxGTK does this in wxWindow, but wxMSW does not. It is
+    // next acceptable child
-    // also done in wxPanel if the event is propagated up.
+    wxWindowList::Node *node, *start_node;
+
+    // the event is propagated downwards if the event emitter was our parent
+    bool goingDown = event.GetEventObject() == GetParent();
+
+    const wxWindowList& children = GetChildren();
+
+    // 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
+    // for our parent we look like a single control
+    if ( goingDown )
+    {
+        // just to be sure it's not used (normally this is not necessary, but
+        // doesn't hurt neither)
+        m_winLastFocused = (wxWindow *)NULL;
+
+        // start from first or last depending on where we're going
+        node = forward ? children.GetFirst() : children.GetLast();
+
+        // we want to cycle over all nodes
+        start_node = (wxWindowList::Node *)NULL;
+    }
+    else
+    {
+        // try to find the child which has the focus currently
+
+        // the event emitter might have done this for us
         wxWindow *winFocus = event.GetCurrentFocus();
 
-    // Do we know where the focus was ourselves, then?
+        // but if not, we might know where the focus was ourselves
         if (!winFocus)
             winFocus = m_winLastFocused;
 
+        // if still no luck, do it the hard way
         if (!winFocus)
             winFocus = wxWindow::FindFocus();
 
-    if (!winFocus)
+        if ( winFocus )
         {
-        event.Skip();
+            // ok, we found the focus - now is it our child?
-        return;
+            start_node = children.Find( winFocus );
+        }
+        else
+        {
+            start_node = (wxWindowList::Node *)NULL;
         }
 
-    wxWindowList::Node *start_node = GetChildren().Find( winFocus );
+        if ( !start_node && m_winLastFocused )
-    if ( !start_node )
+        {
-        start_node = GetChildren().Find( m_winLastFocused );
+            // window which has focus isn't our child, fall back to the one
-    if ( !start_node )
+            // which had the focus the last time
-        start_node = GetChildren().GetFirst();
+            start_node = children.Find( m_winLastFocused );
+        }
 
-    wxWindowList::Node *node = event.GetDirection() ? start_node->GetNext()
+        // if we still didn't find anything, we should start with the first one
-                                                    : start_node->GetPrevious();
+        if ( !start_node )
+        {
+            start_node = children.GetFirst();
+        }
 
+        // and the first child which we can try setting focus to is the next or
+        // the previous one
+        node = forward ? start_node->GetNext() : start_node->GetPrevious();
+    }
+
+    // we want to cycle over all elements passing by NULL
     while ( node != start_node )
     {
         // Have we come to the last or first item on the panel?
         if ( !node )
         {
-            // Check if our (may be grand) parent is another panel: if this is
+            if ( !goingDown )
-            // the case, they will know what to do with this navigation key and
+            {
-            // so give them the chance to process it instead of looping inside
+                // Check if our (may be grand) parent is another panel: if this
-            // this panel (normally, the focus will go to the next/previous
+                // is the case, they will know what to do with this navigation
-            // item after this panel in the parent panel).
+                // key and so give them the chance to process it instead of
+                // looping inside this panel (normally, the focus will go to
+                // the next/previous item after this panel in the parent
+                // panel).
                 wxWindow *focussed_child_of_parent = this;
-            for ( wxWindow *parent = GetParent(); parent; parent = parent->GetParent() )
+                for ( wxWindow *parent = GetParent();
+                      parent;
+                      parent = parent->GetParent() )
                 {
                     // we don't want to tab into a different dialog or frame
                     if ( focussed_child_of_parent->IsTopLevel() )
@@ -151,10 +238,12 @@ void wxPanel::OnNavigationKey( wxNavigationKeyEvent& event )
 
                     focussed_child_of_parent = parent;
                 }
+            }
+            //else: as the focus came from our parent, we definitely don't want
+            //      to send it back to it!
 
             // no, we are not inside another panel so process this ourself
-            node = event.GetDirection() ? GetChildren().GetFirst()
+            node = forward ? children.GetFirst() : children.GetLast();
-                                        : GetChildren().GetLast();
 
             continue;
         }
@@ -164,11 +253,36 @@ void wxPanel::OnNavigationKey( wxNavigationKeyEvent& event )
         if ( child->AcceptsFocus() )
         {
             m_winLastFocused = child;  // should be redundant, but it is not
+
+            // 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
+            wxPanel *subpanel = wxDynamicCast(child, wxPanel);
+            if ( subpanel )
+            {
+                // trick the panel into thinking that it got the navigation
+                // event - instead of duplicating all the code here
+                //
+                // make sure that we do trick it by setting all the parameters
+                // correctly (consistently with the code in this very function
+                // above) and that it starts from the very beginning/end by
+                // using SetLastFocus(NULL)
+                subpanel->SetLastFocus((wxWindow *)NULL);
+            }
+
+            event.SetEventObject(this);
+            if ( !child->GetEventHandler()->ProcessEvent(event) )
+            {
+                // everything is simple: just give focus to it
                 child->SetFocus();
+            }
+            //else: the child manages its focus itself
+
             return;
         }
 
-        node = event.GetDirection() ? node->GetNext() : node->GetPrevious();
+        node = forward ? node->GetNext() : node->GetPrevious();
     }
 
     // we cycled through all of our children and none of them wanted to accept
@@ -176,15 +290,6 @@ void wxPanel::OnNavigationKey( wxNavigationKeyEvent& event )
     event.Skip();
 }
 
-
-void wxPanel::OnSize(wxSizeEvent& WXUNUSED(event))
-{
-#if wxUSE_CONSTRAINTS
-    if (GetAutoLayout())
-        Layout();
-#endif
-}
-
 void wxPanel::SetFocus()
 {
     wxLogTrace(_T("focus"), _T("SetFocus on wxPanel 0x%08x."), GetHandle());
@@ -205,6 +310,14 @@ void wxPanel::SetFocus()
     //     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.
 
 #ifdef __WXGTK__
     m_winLastFocused = (wxWindow *)NULL;

src/msw/notebook.cpp

@@ -282,6 +282,29 @@ void wxNotebook::SetImageList(wxImageList* imageList)
   TabCtrl_SetImageList(m_hwnd, (HIMAGELIST)imageList->GetHIMAGELIST());
 }
 
+// ----------------------------------------------------------------------------
+// wxNotebook size settings
+// ----------------------------------------------------------------------------
+
+void wxNotebook::SetPageSize(const wxSize& size)
+{
+    // transform the page size into the notebook size
+    RECT rc;
+    rc.left =
+    rc.top = 0;
+    rc.right = size.x;
+    rc.bottom = size.y;
+
+    TabCtrl_AdjustRect(GetHwnd(), TRUE, &rc);
+
+    // and now set it
+    SetSize(rc.right - rc.left, rc.bottom - rc.top);
+}
+
+void wxNotebook::SetPadding(const wxSize& padding)
+{
+    TabCtrl_SetPadding(GetHwnd(), padding.x, padding.y);
+}
 
 // Windows-only at present. Also, you must use the wxNB_FIXEDWIDTH
 // style.
@@ -423,7 +446,6 @@ bool wxNotebook::InsertPage(int nPage,
   TabCtrl_AdjustRect(m_hwnd, FALSE, &rc);
   pPage->SetSize(rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top);
 
-
   // some page should be selected: either this one or the first one if there is
   // still no selection
   int selNew = -1;
@@ -488,6 +510,11 @@ void wxNotebook::OnSelChange(wxNotebookEvent& event)
 
 void wxNotebook::OnSetFocus(wxFocusEvent& event)
 {
+    // this function is only called when the focus is explicitly set (i.e. from
+    // the program) to the notebook - in this case we don't need the
+    // complicated OnNavigationKey() logic because the programmer knows better
+    // what [s]he wants
+
     // set focus to the currently selected page if any
     if ( m_nSelection != -1 )
         m_aPages[m_nSelection]->SetFocus();
@@ -502,10 +529,50 @@ void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event)
         AdvanceSelection(event.GetDirection());
     }
     else {
-    // pass to the parent
+        // we get this event in 2 cases
-    if ( GetParent() ) {
+        //
+        // a) one of our pages might have generated it because the user TABbed
+        // out from it in which case we should propagate the event upwards and
+        // our parent will take care of setting the focus to prev/next sibling
+        //
+        // or
+        //
+        // b) the parent panel wants to give the focus to us so that we
+        // forward it to our selected page. We can't deal with this in
+        // OnSetFocus() because we don't know which direction the focus came
+        // from in this case and so can't choose between setting the focus to
+        // first or last panel child
+
+        wxWindow *parent = GetParent();
+        if ( event.GetEventObject() == parent )
+        {
+            // no, it doesn't come from child, case (b): forward to a page
+            if ( m_nSelection != -1 )
+            {
+                // so that the page knows that the event comes from it's parent
+                // and is being propagated downwards
+                event.SetEventObject(this);
+
+                wxWindow *page = m_aPages[m_nSelection];
+                if ( !page->GetEventHandler()->ProcessEvent(event) )
+                {
+                    page->SetFocus();
+                }
+                //else: page manages focus inside it itself
+            }
+            else
+            {
+                // we have no pages - still have to give focus to _something_
+                SetFocus();
+            }
+        }
+        else
+        {
+            // it comes from our child, case (a), pass to the parent
+            if ( parent ) {
                 event.SetCurrentFocus(this);
-      GetParent()->GetEventHandler()->ProcessEvent(event);
+                parent->GetEventHandler()->ProcessEvent(event);
+            }
         }
     }
 }

src/msw/textctrl.cpp

@@ -902,7 +902,7 @@ void wxTextCtrl::OnChar(wxKeyEvent& event)
                 eventNav.SetWindowChange(FALSE);
                 eventNav.SetEventObject(this);
 
-                if ( GetEventHandler()->ProcessEvent(eventNav) )
+                if ( GetParent()->GetEventHandler()->ProcessEvent(eventNav) )
                     return;
             }
             break;

src/msw/window.cpp

@@ -1473,7 +1473,7 @@ bool wxWindow::MSWProcessMessage(WXMSG* pMsg)
 
         // here we try to do all the job which ::IsDialogMessage() usually does
         // internally
-#if 0
+#if 1
         bool bProcess = TRUE;
         if ( msg->message != WM_KEYDOWN )
             bProcess = FALSE;