More doxygen topic overview cleanup.

[wxWidgets.git] / src / univ / menu.cpp

diff --git a/src/univ/menu.cpp b/src/univ/menu.cpp
index 586b829b2d23e7b4eae87a819a4c41e3905ce116..ac4d815131db7daf174258685e9fd3ef9f7c4f5f 100644 (file)
--- a/src/univ/menu.cpp
+++ b/src/univ/menu.cpp
@@ -1,12 +1,12 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        univ/menu.cpp
+// Name:        src/univ/menu.cpp

 // Purpose:     wxMenuItem, wxMenu and wxMenuBar implementation
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     25.08.00
 // RCS-ID:      $Id$
 // Copyright:   (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
 // Purpose:     wxMenuItem, wxMenu and wxMenuBar implementation
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     25.08.00
 // RCS-ID:      $Id$
 // Copyright:   (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)

-// Licence:     wxWindows license
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
 /////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================


@@ -17,32 +17,29 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __GNUG__
-    #pragma implementation "univmenuitem.h"
-    #pragma implementation "univmenu.h"
-#endif
-

 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
     #pragma hdrstop
 #endif
 
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
     #pragma hdrstop
 #endif
 

+#if wxUSE_MENUS
+
+#include "wx/menu.h"
+#include "wx/stockitem.h"
+

 #ifndef WX_PRECOMP
     #include "wx/dynarray.h"
     #include "wx/control.h"      // for FindAccelIndex()
 #ifndef WX_PRECOMP
     #include "wx/dynarray.h"
     #include "wx/control.h"      // for FindAccelIndex()

-    #include "wx/menu.h"

     #include "wx/settings.h"
     #include "wx/accel.h"
     #include "wx/log.h"
     #include "wx/settings.h"
     #include "wx/accel.h"
     #include "wx/log.h"

+    #include "wx/frame.h"
+    #include "wx/dcclient.h"

 #endif // WX_PRECOMP
 
 #endif // WX_PRECOMP
 

-#if wxUSE_MENUS
-

 #include "wx/popupwin.h"
 #include "wx/evtloop.h"
 #include "wx/popupwin.h"
 #include "wx/evtloop.h"

-#include "wx/dcclient.h"
-#include "wx/frame.h"

 
 #include "wx/univ/renderer.h"
 
 
 #include "wx/univ/renderer.h"
 


@@ -50,6 +47,8 @@
     #include "wx/msw/private.h"
 #endif // __WXMSW__
 
     #include "wx/msw/private.h"
 #endif // __WXMSW__
 

+typedef wxMenuItemList::compatibility_iterator wxMenuItemIter;
+

 // ----------------------------------------------------------------------------
 // wxMenuInfo contains all extra information about top level menus we need
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxMenuInfo contains all extra information about top level menus we need
 // ----------------------------------------------------------------------------


@@ -68,6 +67,8 @@ public:
 
     void SetLabel(const wxString& text)
     {
 
     void SetLabel(const wxString& text)
     {

+        m_originalLabel = text;
+

         // remember the accel char (may be -1 if none)
         m_indexAccel = wxControl::FindAccelIndex(text, &m_label);
 
         // remember the accel char (may be -1 if none)
         m_indexAccel = wxControl::FindAccelIndex(text, &m_label);
 


@@ -75,11 +76,12 @@ public:
         m_width = 0;
     }
 
         m_width = 0;
     }
 

-    void SetEnabled(bool enabled = TRUE) { m_isEnabled = enabled; }
+    void SetEnabled(bool enabled = true) { m_isEnabled = enabled; }

 
     // accessors
 
     const wxString& GetLabel() const { return m_label; }
 
     // accessors
 
     const wxString& GetLabel() const { return m_label; }

+    const wxString& GetOriginalLabel() const { return m_originalLabel; }

     bool IsEnabled() const { return m_isEnabled; }
     wxCoord GetWidth(wxMenuBar *menubar) const
     {
     bool IsEnabled() const { return m_isEnabled; }
     wxCoord GetWidth(wxMenuBar *menubar) const
     {


@@ -98,7 +100,7 @@ private:
     {
         wxSize size;
         wxClientDC dc(menubar);
     {
         wxSize size;
         wxClientDC dc(menubar);

-        dc.SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
+        dc.SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));

         dc.GetTextExtent(m_label, &size.x, &size.y);
 
         // adjust for the renderer we use and store the width
         dc.GetTextExtent(m_label, &size.x, &size.y);
 
         // adjust for the renderer we use and store the width


@@ -106,6 +108,7 @@ private:
     }
 
     wxString m_label;
     }
 
     wxString m_label;

+    wxString m_originalLabel;

     wxCoord m_width;
     int m_indexAccel;
     bool m_isEnabled;
     wxCoord m_width;
     int m_indexAccel;
     bool m_isEnabled;


@@ -124,17 +127,23 @@ class wxPopupMenuWindow : public wxPopupTransientWindow
 public:
     wxPopupMenuWindow(wxWindow *parent, wxMenu *menu);
 
 public:
     wxPopupMenuWindow(wxWindow *parent, wxMenu *menu);
 

+    virtual ~wxPopupMenuWindow();
+

     // override the base class version to select the first item initially
     virtual void Popup(wxWindow *focus = NULL);
 
     // override the base class version to dismiss any open submenus
     virtual void Dismiss();
 
     // override the base class version to select the first item initially
     virtual void Popup(wxWindow *focus = NULL);
 
     // override the base class version to dismiss any open submenus
     virtual void Dismiss();
 

-    // notify the menu when the window disappears from screen
-    virtual void OnDismiss();
-

     // called when a submenu is dismissed
     // called when a submenu is dismissed

-    void OnSubmenuDismiss() { m_hasOpenSubMenu = FALSE; }
+    void OnSubmenuDismiss(bool dismissParent);
+
+    // the default wxMSW wxPopupTransientWindow::OnIdle disables the capture
+    // when the cursor is inside the popup, which dsables the menu tracking
+    // so override it to do nothing
+#ifdef __WXMSW__
+    void OnIdle(wxIdleEvent& WXUNUSED(event)) { }
+#endif

 
     // get the currently selected item (may be NULL)
     wxMenuItem *GetCurrentItem() const
 
     // get the currently selected item (may be NULL)
     wxMenuItem *GetCurrentItem() const


@@ -143,15 +152,15 @@ public:
     }
 
     // find the menu item at given position
     }
 
     // find the menu item at given position

-    wxMenuItemList::Node *GetMenuItemFromPoint(const wxPoint& pt) const;
+    wxMenuItemIter GetMenuItemFromPoint(const wxPoint& pt) const;

 
     // refresh the given item
     void RefreshItem(wxMenuItem *item);
 
     // preselect the first item
 
     // refresh the given item
     void RefreshItem(wxMenuItem *item);
 
     // preselect the first item

-    void SelectFirst() { SetCurrent(m_menu->GetMenuItems().GetFirst()); }
+    void SelectFirst() { SetCurrentItem(m_menu->GetMenuItems().GetFirst()); }

 
 

-    // process the key event, return TRUE if done
+    // process the key event, return true if done

     bool ProcessKeyDown(int key);
 
     // process mouse move event
     bool ProcessKeyDown(int key);
 
     // process mouse move event


@@ -168,6 +177,9 @@ protected:
         WithMouse
     };
 
         WithMouse
     };
 

+    // notify the menu when the window disappears from screen
+    virtual void OnDismiss();
+

     // draw the menu inside this window
     virtual void DoDraw(wxControlRenderer *renderer);
 
     // draw the menu inside this window
     virtual void DoDraw(wxControlRenderer *renderer);
 


@@ -180,14 +192,14 @@ protected:
     // reset the current item and node
     void ResetCurrent();
 
     // reset the current item and node
     void ResetCurrent();
 

-    // set the current node and item withotu refreshing anything
-    void SetCurrent(wxMenuItemList::Node *node);
+    // set the current node and item without refreshing anything
+    void SetCurrentItem(wxMenuItemIter node);

 
     // change the current item refreshing the old and new items
 
     // change the current item refreshing the old and new items

-    void ChangeCurrent(wxMenuItemList::Node *node);
+    void ChangeCurrent(wxMenuItemIter node);

 
     // activate item, i.e. call either ClickItem() or OpenSubmenu() depending
 
     // activate item, i.e. call either ClickItem() or OpenSubmenu() depending

-    // on what it is, return TRUE if something was done (i.e. it's not a
+    // on what it is, return true if something was done (i.e. it's not a

     // separator...)
     bool ActivateItem(wxMenuItem *item, InputMethod how = WithKeyboard);
 
     // separator...)
     bool ActivateItem(wxMenuItem *item, InputMethod how = WithKeyboard);
 


@@ -214,23 +226,23 @@ protected:
     bool HasOpenSubmenu() const { return m_hasOpenSubMenu; }
 
     // get previous node after the current one
     bool HasOpenSubmenu() const { return m_hasOpenSubMenu; }
 
     // get previous node after the current one

-    wxMenuItemList::Node *GetPrevNode() const;
+    wxMenuItemIter GetPrevNode() const;

 
     // get previous node before the given one, wrapping if it's the first one
 
     // get previous node before the given one, wrapping if it's the first one

-    wxMenuItemList::Node *GetPrevNode(wxMenuItemList::Node *node) const;
+    wxMenuItemIter GetPrevNode(wxMenuItemIter node) const;

 
     // get next node after the current one
 
     // get next node after the current one

-    wxMenuItemList::Node *GetNextNode() const;
+    wxMenuItemIter GetNextNode() const;

 
     // get next node after the given one, wrapping if it's the last one
 
     // get next node after the given one, wrapping if it's the last one

-    wxMenuItemList::Node *GetNextNode(wxMenuItemList::Node *node) const;
+    wxMenuItemIter GetNextNode(wxMenuItemIter node) const;

 
 private:
     // the menu we show
     wxMenu *m_menu;
 
     // the menu node corresponding to the current item
 
 private:
     // the menu we show
     wxMenu *m_menu;
 
     // the menu node corresponding to the current item

-    wxMenuItemList::Node *m_nodeCurrent;
+    wxMenuItemIter m_nodeCurrent;

 
     // do we currently have an opened submenu?
     bool m_hasOpenSubMenu;
 
     // do we currently have an opened submenu?
     bool m_hasOpenSubMenu;


@@ -255,6 +267,8 @@ public:
         }
         else
         {
         }
         else
         {

+            // return false;
+

             return wxEvtHandler::ProcessEvent(event);
         }
     }
             return wxEvtHandler::ProcessEvent(event);
         }
     }


@@ -277,6 +291,9 @@ BEGIN_EVENT_TABLE(wxPopupMenuWindow, wxPopupTransientWindow)
     EVT_LEFT_UP(wxPopupMenuWindow::OnLeftUp)
     EVT_MOTION(wxPopupMenuWindow::OnMouseMove)
     EVT_LEAVE_WINDOW(wxPopupMenuWindow::OnMouseLeave)
     EVT_LEFT_UP(wxPopupMenuWindow::OnLeftUp)
     EVT_MOTION(wxPopupMenuWindow::OnMouseMove)
     EVT_LEAVE_WINDOW(wxPopupMenuWindow::OnMouseLeave)

+#ifdef __WXMSW__
+    EVT_IDLE(wxPopupMenuWindow::OnIdle)
+#endif

 END_EVENT_TABLE()
 
 BEGIN_EVENT_TABLE(wxMenuBar, wxMenuBarBase)
 END_EVENT_TABLE()
 
 BEGIN_EVENT_TABLE(wxMenuBar, wxMenuBarBase)


@@ -299,7 +316,7 @@ END_EVENT_TABLE()
 wxPopupMenuWindow::wxPopupMenuWindow(wxWindow *parent, wxMenu *menu)
 {
     m_menu = menu;
 wxPopupMenuWindow::wxPopupMenuWindow(wxWindow *parent, wxMenu *menu)
 {
     m_menu = menu;

-    m_hasOpenSubMenu = FALSE;
+    m_hasOpenSubMenu = false;

 
     ResetCurrent();
 
 
     ResetCurrent();
 


@@ -308,25 +325,35 @@ wxPopupMenuWindow::wxPopupMenuWindow(wxWindow *parent, wxMenu *menu)
     SetCursor(wxCURSOR_ARROW);
 }
 
     SetCursor(wxCURSOR_ARROW);
 }
 

+wxPopupMenuWindow::~wxPopupMenuWindow()
+{
+    // When m_popupMenu in wxMenu is deleted because it
+    // is a child of an old menu bar being deleted (note: it does
+    // not get destroyed by the wxMenu destructor, but
+    // by DestroyChildren()), m_popupMenu should be reset to NULL.
+
+    m_menu->m_popupMenu = NULL;
+}
+

 // ----------------------------------------------------------------------------
 // wxPopupMenuWindow current item/node handling
 // ----------------------------------------------------------------------------
 
 void wxPopupMenuWindow::ResetCurrent()
 {
 // ----------------------------------------------------------------------------
 // wxPopupMenuWindow current item/node handling
 // ----------------------------------------------------------------------------
 
 void wxPopupMenuWindow::ResetCurrent()
 {

-    SetCurrent(NULL);
+    SetCurrentItem(wxMenuItemIter());

 }
 
 }
 

-void wxPopupMenuWindow::SetCurrent(wxMenuItemList::Node *node)
+void wxPopupMenuWindow::SetCurrentItem(wxMenuItemIter node)

 {
     m_nodeCurrent = node;
 }
 
 {
     m_nodeCurrent = node;
 }
 

-void wxPopupMenuWindow::ChangeCurrent(wxMenuItemList::Node *node)
+void wxPopupMenuWindow::ChangeCurrent(wxMenuItemIter node)

 {
 {

-    if ( node != m_nodeCurrent )
+    if ( !m_nodeCurrent || !node || (node != m_nodeCurrent) )

     {
     {

-        wxMenuItemList::Node *nodeOldCurrent = m_nodeCurrent;
+        wxMenuItemIter nodeOldCurrent = m_nodeCurrent;

 
         m_nodeCurrent = node;
 
 
         m_nodeCurrent = node;
 


@@ -339,7 +366,7 @@ void wxPopupMenuWindow::ChangeCurrent(wxMenuItemList::Node *node)
             if ( item->IsSubMenu() && item->GetSubMenu()->IsShown() )
             {
                 item->GetSubMenu()->Dismiss();
             if ( item->IsSubMenu() && item->GetSubMenu()->IsShown() )
             {
                 item->GetSubMenu()->Dismiss();

-                OnSubmenuDismiss();
+                OnSubmenuDismiss( false );

             }
 
             RefreshItem(item);
             }
 
             RefreshItem(item);


@@ -350,20 +377,15 @@ void wxPopupMenuWindow::ChangeCurrent(wxMenuItemList::Node *node)
     }
 }
 
     }
 }
 

-wxMenuItemList::Node *wxPopupMenuWindow::GetPrevNode() const
+wxMenuItemIter wxPopupMenuWindow::GetPrevNode() const

 {
 {

-    wxMenuItemList::Node *node = m_nodeCurrent;
-    if ( !node )
-    {
-        // start from the end if no current item
-        node = m_menu->GetMenuItems().GetLast();
-    }
-
-    return GetPrevNode(node);
+    // return the last node if there had been no previously selected one
+    return m_nodeCurrent ? GetPrevNode(m_nodeCurrent)
+                         : wxMenuItemIter(m_menu->GetMenuItems().GetLast());

 }
 
 }
 

-wxMenuItemList::Node *
-wxPopupMenuWindow::GetPrevNode(wxMenuItemList::Node *node) const
+wxMenuItemIter
+wxPopupMenuWindow::GetPrevNode(wxMenuItemIter node) const

 {
     if ( node )
     {
 {
     if ( node )
     {


@@ -378,20 +400,15 @@ wxPopupMenuWindow::GetPrevNode(wxMenuItemList::Node *node) const
     return node;
 }
 
     return node;
 }
 

-wxMenuItemList::Node *wxPopupMenuWindow::GetNextNode() const
+wxMenuItemIter wxPopupMenuWindow::GetNextNode() const

 {
 {

-    wxMenuItemList::Node *node = m_nodeCurrent;
-    if ( !node )
-    {
-        // start from the beginning if no current item
-        node = m_menu->GetMenuItems().GetFirst();
-    }
-
-    return GetNextNode(node);
+    // return the first node if there had been no previously selected one
+    return m_nodeCurrent ? GetNextNode(m_nodeCurrent)
+                         : wxMenuItemIter(m_menu->GetMenuItems().GetFirst());

 }
 
 }
 

-wxMenuItemList::Node *
-wxPopupMenuWindow::GetNextNode(wxMenuItemList::Node *node) const
+wxMenuItemIter
+wxPopupMenuWindow::GetNextNode(wxMenuItemIter node) const

 {
     if ( node )
     {
 {
     if ( node )
     {


@@ -419,6 +436,11 @@ void wxPopupMenuWindow::Popup(wxWindow *focus)
 
     wxPopupTransientWindow::Popup(focus);
 
 
     wxPopupTransientWindow::Popup(focus);
 

+    // the base class no-longer captures the mouse automatically when Popup
+    // is called, so do it here to allow the menu tracking to work
+    if ( !HasCapture() )
+        CaptureMouse();
+

 #ifdef __WXMSW__
     // ensure that this window is really on top of everything: without using
     // SetWindowPos() it can be covered by its parent menu which is not
 #ifdef __WXMSW__
     // ensure that this window is really on top of everything: without using
     // SetWindowPos() it can be covered by its parent menu which is not


@@ -454,37 +476,42 @@ void wxPopupMenuWindow::Dismiss()
         wxCHECK_RET( win, _T("opened submenu is not opened?") );
 
         win->Dismiss();
         wxCHECK_RET( win, _T("opened submenu is not opened?") );
 
         win->Dismiss();

-        OnSubmenuDismiss();
+        OnSubmenuDismiss( false );

     }
 
     wxPopupTransientWindow::Dismiss();
     }
 
     wxPopupTransientWindow::Dismiss();

+
+    ResetCurrent();

 }
 
 void wxPopupMenuWindow::OnDismiss()
 {
     // when we are dismissed because the user clicked elsewhere or we lost
     // focus in any other way, hide the parent menu as well
 }
 
 void wxPopupMenuWindow::OnDismiss()
 {
     // when we are dismissed because the user clicked elsewhere or we lost
     // focus in any other way, hide the parent menu as well

-    HandleDismiss(TRUE);
+    HandleDismiss(true);

 }
 
 }
 

-void wxPopupMenuWindow::HandleDismiss(bool dismissParent)
+void wxPopupMenuWindow::OnSubmenuDismiss(bool WXUNUSED(dismissParent))

 {
 {

-    ResetCurrent();
+    m_hasOpenSubMenu = false;
+}

 
 

+void wxPopupMenuWindow::HandleDismiss(bool dismissParent)
+{

     m_menu->OnDismiss(dismissParent);
 }
 
 void wxPopupMenuWindow::DismissAndNotify()
 {
     Dismiss();
     m_menu->OnDismiss(dismissParent);
 }
 
 void wxPopupMenuWindow::DismissAndNotify()
 {
     Dismiss();

-    HandleDismiss(TRUE);
+    HandleDismiss(true);

 }
 
 // ----------------------------------------------------------------------------
 // wxPopupMenuWindow geometry
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // wxPopupMenuWindow geometry
 // ----------------------------------------------------------------------------
 

-wxMenuItemList::Node *
+wxMenuItemIter

 wxPopupMenuWindow::GetMenuItemFromPoint(const wxPoint& pt) const
 {
     // we only use the y coord normally, but still check x in case the point is
 wxPopupMenuWindow::GetMenuItemFromPoint(const wxPoint& pt) const
 {
     // we only use the y coord normally, but still check x in case the point is


@@ -492,7 +519,7 @@ wxPopupMenuWindow::GetMenuItemFromPoint(const wxPoint& pt) const
     if ( wxWindow::HitTest(pt) == wxHT_WINDOW_INSIDE )
     {
         wxCoord y = 0;
     if ( wxWindow::HitTest(pt) == wxHT_WINDOW_INSIDE )
     {
         wxCoord y = 0;

-        for ( wxMenuItemList::Node *node = m_menu->GetMenuItems().GetFirst();
+        for ( wxMenuItemIter node = m_menu->GetMenuItems().GetFirst();

               node;
               node = node->GetNext() )
         {
               node;
               node = node->GetNext() )
         {


@@ -506,7 +533,7 @@ wxPopupMenuWindow::GetMenuItemFromPoint(const wxPoint& pt) const
         }
     }
 
         }
     }
 

-    return NULL;
+    return wxMenuItemIter();

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -530,7 +557,7 @@ void wxPopupMenuWindow::DoDraw(wxControlRenderer *renderer)
     // never partially covered as it is always on top of everything
 
     wxDC& dc = renderer->GetDC();
     // never partially covered as it is always on top of everything
 
     wxDC& dc = renderer->GetDC();

-    dc.SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
+    dc.SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));

 
     // FIXME: this should be done in the renderer, however when it is fixed
     //        wxPopupMenuWindow::RefreshItem() should be changed too!
 
     // FIXME: this should be done in the renderer, however when it is fixed
     //        wxPopupMenuWindow::RefreshItem() should be changed too!


@@ -540,7 +567,7 @@ void wxPopupMenuWindow::DoDraw(wxControlRenderer *renderer)
 
     wxCoord y = 0;
     const wxMenuGeometryInfo& gi = m_menu->GetGeometryInfo();
 
     wxCoord y = 0;
     const wxMenuGeometryInfo& gi = m_menu->GetGeometryInfo();

-    for ( wxMenuItemList::Node *node = m_menu->GetMenuItems().GetFirst();
+    for ( wxMenuItemIter node = m_menu->GetMenuItems().GetFirst();

           node;
           node = node->GetNext() )
     {
           node;
           node = node->GetNext() )
     {


@@ -572,17 +599,29 @@ void wxPopupMenuWindow::DoDraw(wxControlRenderer *renderer)
             if ( item == GetCurrentItem() )
                 flags |= wxCONTROL_SELECTED;
 
             if ( item == GetCurrentItem() )
                 flags |= wxCONTROL_SELECTED;
 

+            wxBitmap bmp;
+
+            if ( !item->IsEnabled() )
+            {
+                bmp = item->GetDisabledBitmap();
+            }
+
+            if ( !bmp.Ok() )
+            {
+                // strangely enough, for unchecked item we use the
+                // "checked" bitmap because this is the default one - this
+                // explains this strange boolean expression
+                bmp = item->GetBitmap(!item->IsCheckable() || item->IsChecked());
+            }
+

             rend->DrawMenuItem
                   (
                      dc,
                      y,
                      gi,
             rend->DrawMenuItem
                   (
                      dc,
                      y,
                      gi,

-                     item->GetLabel(),
+                     item->GetItemLabelText(),

                      item->GetAccelString(),
                      item->GetAccelString(),

-                     // strangely enough, for unchecked item we use the
-                     // "checked" bitmap because this is the default one - this
-                     // explains this strange boolean expression
-                     item->GetBitmap(!item->IsCheckable() || item->IsChecked()),
+                     bmp,

                      flags,
                      item->GetAccelIndex()
                   );
                      flags,
                      item->GetAccelIndex()
                   );


@@ -607,7 +646,7 @@ void wxPopupMenuWindow::ClickItem(wxMenuItem *item)
 
     // close all menus
     DismissAndNotify();
 
     // close all menus
     DismissAndNotify();

-    
+

     menu->ClickItem(item);
 }
 
     menu->ClickItem(item);
 }
 


@@ -623,7 +662,7 @@ void wxPopupMenuWindow::OpenSubmenu(wxMenuItem *item, InputMethod how)
                    wxSize(m_menu->GetGeometryInfo().GetSize().x, 0),
                    how == WithKeyboard /* preselect first item then */);
 
                    wxSize(m_menu->GetGeometryInfo().GetSize().x, 0),
                    how == WithKeyboard /* preselect first item then */);
 

-    m_hasOpenSubMenu = TRUE;
+    m_hasOpenSubMenu = true;

 }
 
 bool wxPopupMenuWindow::ActivateItem(wxMenuItem *item, InputMethod how)
 }
 
 bool wxPopupMenuWindow::ActivateItem(wxMenuItem *item, InputMethod how)


@@ -631,7 +670,7 @@ bool wxPopupMenuWindow::ActivateItem(wxMenuItem *item, InputMethod how)
     // don't activate disabled items
     if ( !item || !item->IsEnabled() )
     {
     // don't activate disabled items
     if ( !item || !item->IsEnabled() )
     {

-        return FALSE;
+        return false;

     }
 
     // normal menu items generate commands, submenus can be opened and
     }
 
     // normal menu items generate commands, submenus can be opened and


@@ -646,10 +685,10 @@ bool wxPopupMenuWindow::ActivateItem(wxMenuItem *item, InputMethod how)
     }
     else // separator, can't activate
     {
     }
     else // separator, can't activate
     {

-        return FALSE;
+        return false;

     }
 
     }
 

-    return TRUE;
+    return true;

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -671,24 +710,24 @@ bool wxPopupMenuWindow::ProcessLeftDown(wxMouseEvent& event)
         {
             wxPopupMenuWindow *win = menu->m_popupMenu;
 
         {
             wxPopupMenuWindow *win = menu->m_popupMenu;
 

-            wxCHECK_MSG( win, FALSE, _T("parent menu not shown?") );
+            wxCHECK_MSG( win, false, _T("parent menu not shown?") );

 
             pos = ClientToScreen(pos);
             if ( win->GetMenuItemFromPoint(win->ScreenToClient(pos)) )
             {
                 // eat the event
 
             pos = ClientToScreen(pos);
             if ( win->GetMenuItemFromPoint(win->ScreenToClient(pos)) )
             {
                 // eat the event

-                return TRUE;
+                return true;

             }
             //else: it is outside the parent menu as well, do dismiss this one
         }
     }
 
             }
             //else: it is outside the parent menu as well, do dismiss this one
         }
     }
 

-    return FALSE;
+    return false;

 }
 
 void wxPopupMenuWindow::OnLeftUp(wxMouseEvent& event)
 {
 }
 
 void wxPopupMenuWindow::OnLeftUp(wxMouseEvent& event)
 {

-    wxMenuItemList::Node *node = GetMenuItemFromPoint(event.GetPosition());
+    wxMenuItemIter node = GetMenuItemFromPoint(event.GetPosition());

     if ( node )
     {
         ActivateItem(node->GetData(), WithMouse);
     if ( node )
     {
         ActivateItem(node->GetData(), WithMouse);


@@ -722,13 +761,13 @@ void wxPopupMenuWindow::OnMouseMove(wxMouseEvent& event)
 
 void wxPopupMenuWindow::ProcessMouseMove(const wxPoint& pt)
 {
 
 void wxPopupMenuWindow::ProcessMouseMove(const wxPoint& pt)
 {

-    wxMenuItemList::Node *node = GetMenuItemFromPoint(pt);
+    wxMenuItemIter node = GetMenuItemFromPoint(pt);

 
     // don't reset current to NULL here, we only do it when the mouse leaves
     // the window (see below)
     if ( node )
     {
 
     // don't reset current to NULL here, we only do it when the mouse leaves
     // the window (see below)
     if ( node )
     {

-        if ( node != m_nodeCurrent )
+        if ( !m_nodeCurrent || (node != m_nodeCurrent) )

         {
             ChangeCurrent(node);
 
         {
             ChangeCurrent(node);
 


@@ -808,12 +847,12 @@ void wxPopupMenuWindow::OnMouseLeave(wxMouseEvent& event)
         else
         {
             // this menu is the last opened
         else
         {
             // this menu is the last opened

-            resetCurrent = TRUE;
+            resetCurrent = true;

         }
 
         if ( resetCurrent )
         {
         }
 
         if ( resetCurrent )
         {

-            ChangeCurrent(NULL);
+            ChangeCurrent(wxMenuItemIter());

         }
     }
 
         }
     }
 


@@ -822,7 +861,13 @@ void wxPopupMenuWindow::OnMouseLeave(wxMouseEvent& event)
 
 void wxPopupMenuWindow::OnKeyDown(wxKeyEvent& event)
 {
 
 void wxPopupMenuWindow::OnKeyDown(wxKeyEvent& event)
 {

-    if ( !ProcessKeyDown(event.GetKeyCode()) )
+    wxMenuBar *menubar = m_menu->GetMenuBar();
+
+    if ( menubar )
+    {
+        menubar->ProcessEvent(event);
+    }
+    else if ( !ProcessKeyDown(event.GetKeyCode()) )

     {
         event.Skip();
     }
     {
         event.Skip();
     }


@@ -837,14 +882,14 @@ bool wxPopupMenuWindow::ProcessKeyDown(int key)
     // to open it inspit of this)
     if ( HasOpenSubmenu() )
     {
     // to open it inspit of this)
     if ( HasOpenSubmenu() )
     {

-        wxCHECK_MSG( CanOpen(item), FALSE,
+        wxCHECK_MSG( CanOpen(item), false,

                      _T("has open submenu but another item selected?") );
 
         if ( item->GetSubMenu()->ProcessKeyDown(key) )
                      _T("has open submenu but another item selected?") );
 
         if ( item->GetSubMenu()->ProcessKeyDown(key) )

-            return TRUE;
+            return true;

     }
 
     }
 

-    bool processed = TRUE;
+    bool processed = true;

 
     // handle the up/down arrows, home, end, esc and return here, pass the
     // left/right arrows to the menu bar except when the right arrow can be
 
     // handle the up/down arrows, home, end, esc and return here, pass the
     // left/right arrows to the menu bar except when the right arrow can be


@@ -856,7 +901,7 @@ bool wxPopupMenuWindow::ProcessKeyDown(int key)
             // menubar
             if ( !m_menu->GetParent() )
             {
             // menubar
             if ( !m_menu->GetParent() )
             {

-                processed = FALSE;
+                processed = false;

                 break;
             }
 
                 break;
             }
 


@@ -865,7 +910,7 @@ bool wxPopupMenuWindow::ProcessKeyDown(int key)
         case WXK_ESCAPE:
             // close just this menu
             Dismiss();
         case WXK_ESCAPE:
             // close just this menu
             Dismiss();

-            HandleDismiss(FALSE);
+            HandleDismiss(false);

             break;
 
         case WXK_RETURN:
             break;
 
         case WXK_RETURN:


@@ -885,9 +930,8 @@ bool wxPopupMenuWindow::ProcessKeyDown(int key)
             {
                 bool up = key == WXK_UP;
 
             {
                 bool up = key == WXK_UP;
 

-                wxMenuItemList::Node *nodeStart = up ? GetPrevNode()
-                                                     : GetNextNode(),
-                                     *node = nodeStart;
+                wxMenuItemIter nodeStart = up ? GetPrevNode() : GetNextNode(),
+                               node = nodeStart;

                 while ( node && node->GetData()->IsSeparator() )
                 {
                     node = up ? GetPrevNode(node) : GetNextNode(node);
                 while ( node && node->GetData()->IsSeparator() )
                 {
                     node = up ? GetPrevNode(node) : GetNextNode(node);


@@ -896,7 +940,7 @@ bool wxPopupMenuWindow::ProcessKeyDown(int key)
                     {
                         // nothing but separators and disabled items in this
                         // menu, break out
                     {
                         // nothing but separators and disabled items in this
                         // menu, break out

-                        node = NULL;
+                        node = wxMenuItemIter();

                     }
                 }
 
                     }
                 }
 


@@ -906,7 +950,7 @@ bool wxPopupMenuWindow::ProcessKeyDown(int key)
                 }
                 else
                 {
                 }
                 else
                 {

-                    processed = FALSE;
+                    processed = false;

                 }
             }
             break;
                 }
             }
             break;


@@ -919,36 +963,36 @@ bool wxPopupMenuWindow::ProcessKeyDown(int key)
             }
             else
             {
             }
             else
             {

-                processed = FALSE;
+                processed = false;

             }
             break;
 
         default:
             // look for the menu item starting with this letter
             }
             break;
 
         default:
             // look for the menu item starting with this letter

-            if ( wxIsalnum(key) )
+            if ( wxIsalnum((wxChar)key) )

             {
                 // we want to start from the item after this one because
                 // if we're already on the item with the given accel we want to
                 // go to the next one, not to stay in place
             {
                 // we want to start from the item after this one because
                 // if we're already on the item with the given accel we want to
                 // go to the next one, not to stay in place

-                wxMenuItemList::Node *nodeStart = GetNextNode();
+                wxMenuItemIter nodeStart = GetNextNode();

 
                 // do we have more than one item with this accel?
 
                 // do we have more than one item with this accel?

-                bool notUnique = FALSE;
+                bool notUnique = false;

 
                 // translate everything to lower case before comparing
 
                 // translate everything to lower case before comparing

-                wxChar chAccel = wxTolower(key);
+                wxChar chAccel = (wxChar)wxTolower(key);

 
                 // loop through all items searching for the item with this
                 // accel
 
                 // loop through all items searching for the item with this
                 // accel

-                wxMenuItemList::Node *node = nodeStart,
-                                     *nodeFound = NULL;
+                wxMenuItemIter nodeFound,
+                               node = nodeStart;

                 for ( ;; )
                 {
                     item = node->GetData();
 
                     int idxAccel = item->GetAccelIndex();
                     if ( idxAccel != -1 &&
                 for ( ;; )
                 {
                     item = node->GetData();
 
                     int idxAccel = item->GetAccelIndex();
                     if ( idxAccel != -1 &&

-                         wxTolower(item->GetLabel()[(size_t)idxAccel])
+                         (wxChar)wxTolower(item->GetItemLabelText()[(size_t)idxAccel])

                             == chAccel )
                     {
                         // ok, found an item with this accel
                             == chAccel )
                     {
                         // ok, found an item with this accel


@@ -961,7 +1005,7 @@ bool wxPopupMenuWindow::ProcessKeyDown(int key)
                         }
                         else // we already had found such item
                         {
                         }
                         else // we already had found such item
                         {

-                            notUnique = TRUE;
+                            notUnique = true;

 
                             // no need to continue further, we won't find
                             // anything we don't already know
 
                             // no need to continue further, we won't find
                             // anything we don't already know


@@ -994,12 +1038,12 @@ bool wxPopupMenuWindow::ProcessKeyDown(int key)
                     //else: just select it but don't activate as the user might
                     //      have wanted to activate another item
 
                     //else: just select it but don't activate as the user might
                     //      have wanted to activate another item
 

-                    // skip "processed = FALSE" below
+                    // skip "processed = false" below

                     break;
                 }
             }
 
                     break;
                 }
             }
 

-            processed = FALSE;
+            processed = false;

     }
 
     return processed;
     }
 
     return processed;


@@ -1014,6 +1058,8 @@ void wxMenu::Init()
     m_geometry = NULL;
 
     m_popupMenu = NULL;
     m_geometry = NULL;
 
     m_popupMenu = NULL;

+
+    m_startRadioGroup = -1;

 }
 
 wxMenu::~wxMenu()
 }
 
 wxMenu::~wxMenu()


@@ -1077,24 +1123,64 @@ void wxMenu::OnItemAdded(wxMenuItem *item)
     }
 }
 
     }
 }
 

-bool wxMenu::DoAppend(wxMenuItem *item)
+void wxMenu::EndRadioGroup()
+{
+    // we're not inside a radio group any longer
+    m_startRadioGroup = -1;
+}
+
+wxMenuItem* wxMenu::DoAppend(wxMenuItem *item)

 {
 {

+    if ( item->GetKind() == wxITEM_RADIO )
+    {
+        int count = GetMenuItemCount();
+
+        if ( m_startRadioGroup == -1 )
+        {
+            // start a new radio group
+            m_startRadioGroup = count;
+
+            // for now it has just one element
+            item->SetAsRadioGroupStart();
+            item->SetRadioGroupEnd(m_startRadioGroup);
+        }
+        else // extend the current radio group
+        {
+            // we need to update its end item
+            item->SetRadioGroupStart(m_startRadioGroup);
+            wxMenuItemIter node = GetMenuItems().Item(m_startRadioGroup);
+
+            if ( node )
+            {
+                node->GetData()->SetRadioGroupEnd(count);
+            }
+            else
+            {
+                wxFAIL_MSG( _T("where is the radio group start item?") );
+            }
+        }
+    }
+    else // not a radio item
+    {
+        EndRadioGroup();
+    }
+

     if ( !wxMenuBase::DoAppend(item) )
     if ( !wxMenuBase::DoAppend(item) )

-        return FALSE;
+        return NULL;

 
     OnItemAdded(item);
 
 
     OnItemAdded(item);
 

-    return TRUE;
+    return item;

 }
 
 }
 

-bool wxMenu::DoInsert(size_t pos, wxMenuItem *item)
+wxMenuItem* wxMenu::DoInsert(size_t pos, wxMenuItem *item)

 {
     if ( !wxMenuBase::DoInsert(pos, item) )
 {
     if ( !wxMenuBase::DoInsert(pos, item) )

-        return FALSE;
+        return NULL;

 
     OnItemAdded(item);
 
 
     OnItemAdded(item);
 

-    return TRUE;
+    return item;

 }
 
 wxMenuItem *wxMenu::DoRemove(wxMenuItem *item)
 }
 
 wxMenuItem *wxMenu::DoRemove(wxMenuItem *item)


@@ -1145,10 +1231,10 @@ void wxMenu::Detach()
 
 wxWindow *wxMenu::GetRootWindow() const
 {
 
 wxWindow *wxMenu::GetRootWindow() const
 {

-    if ( m_menuBar )
+    if ( GetMenuBar() )

     {
         // simple case - a normal menu attached to the menubar
     {
         // simple case - a normal menu attached to the menubar

-        return m_menuBar;
+        return GetMenuBar();

     }
 
     // we're a popup menu but the trouble is that only the top level popup menu
     }
 
     // we're a popup menu but the trouble is that only the top level popup menu


@@ -1164,6 +1250,10 @@ wxWindow *wxMenu::GetRootWindow() const
     wxMenu *menu = GetParent();
     while ( menu )
     {
     wxMenu *menu = GetParent();
     while ( menu )
     {

+        // We are a submenu of a menu of a menubar
+        if (menu->GetMenuBar())
+           return menu->GetMenuBar();
+

         win = menu->GetInvokingWindow();
         if ( win )
             break;
         win = menu->GetInvokingWindow();
         if ( win )
             break;


@@ -1224,7 +1314,7 @@ void wxMenu::OnDismiss(bool dismissParent)
         wxPopupMenuWindow *win = m_menuParent->m_popupMenu;
         if ( win )
         {
         wxPopupMenuWindow *win = m_menuParent->m_popupMenu;
         if ( win )
         {

-            win->OnSubmenuDismiss();
+            win->OnSubmenuDismiss( true );

         }
         else
         {
         }
         else
         {


@@ -1236,7 +1326,7 @@ void wxMenu::OnDismiss(bool dismissParent)
         {
             // dismissParent is recursive
             m_menuParent->Dismiss();
         {
             // dismissParent is recursive
             m_menuParent->Dismiss();

-            m_menuParent->OnDismiss(TRUE);
+            m_menuParent->OnDismiss(true);

         }
     }
     else // no parent menu
         }
     }
     else // no parent menu


@@ -1251,7 +1341,9 @@ void wxMenu::OnDismiss(bool dismissParent)
             wxCHECK_RET( m_invokingWindow, _T("what kind of menu is this?") );
 
             m_invokingWindow->DismissPopupMenu();
             wxCHECK_RET( m_invokingWindow, _T("what kind of menu is this?") );
 
             m_invokingWindow->DismissPopupMenu();

-            SetInvokingWindow(NULL);
+
+            // Why reset it here? We need it for sending the event to...
+            // SetInvokingWindow(NULL);

         }
     }
 }
         }
     }
 }


@@ -1300,7 +1392,7 @@ void wxMenu::Dismiss()
 
 bool wxMenu::ProcessKeyDown(int key)
 {
 
 bool wxMenu::ProcessKeyDown(int key)
 {

-    wxCHECK_MSG( m_popupMenu, FALSE,
+    wxCHECK_MSG( m_popupMenu, false,

                  _T("can't process key events if not shown") );
 
     return m_popupMenu->ProcessKeyDown(key);
                  _T("can't process key events if not shown") );
 
     return m_popupMenu->ProcessKeyDown(key);


@@ -1341,7 +1433,7 @@ bool wxMenu::ProcessAccelEvent(const wxKeyEvent& event)
     }
 
     // try our submenus
     }
 
     // try our submenus

-    for ( wxMenuItemList::Node *node = GetMenuItems().GetFirst();
+    for ( wxMenuItemIter node = GetMenuItems().GetFirst();

           node;
           node = node->GetNext() )
     {
           node;
           node = node->GetNext() )
     {


@@ -1351,12 +1443,12 @@ bool wxMenu::ProcessAccelEvent(const wxKeyEvent& event)
             // try its elements
             if ( item->GetSubMenu()->ProcessAccelEvent(event) )
             {
             // try its elements
             if ( item->GetSubMenu()->ProcessAccelEvent(event) )
             {

-                return TRUE;
+                return true;

             }
         }
     }
 
             }
         }
     }
 

-    return FALSE;
+    return false;

 }
 
 void wxMenu::AddAccelFor(wxMenuItem *item)
 }
 
 void wxMenu::AddAccelFor(wxMenuItem *item)


@@ -1393,22 +1485,17 @@ wxMenuItem::wxMenuItem(wxMenu *parentMenu,
                        int id,
                        const wxString& text,
                        const wxString& help,
                        int id,
                        const wxString& text,
                        const wxString& help,

-                       bool isCheckable,
+                       wxItemKind kind,

                        wxMenu *subMenu)
                        wxMenu *subMenu)

+          : wxMenuItemBase(parentMenu, id, text, help, kind, subMenu)

 {
 {

-    m_id = id;
-    m_parentMenu = parentMenu;
-    m_subMenu = subMenu;
-
-    m_text = text;
-    m_help = help;
+    m_posY =
+    m_height = wxDefaultCoord;

 
 

-    m_isCheckable = isCheckable;
-    m_isEnabled = TRUE;
-    m_isChecked = FALSE;
+    m_radioGroup.start = -1;
+    m_isRadioGroupStart = false;

 
 

-    m_posY =
-    m_height = -1;
+    m_bmpDisabled = wxNullBitmap;

 
     UpdateAccelInfo();
 }
 
     UpdateAccelInfo();
 }


@@ -1426,14 +1513,14 @@ wxMenuItem *wxMenuItemBase::New(wxMenu *parentMenu,
                                 int id,
                                 const wxString& name,
                                 const wxString& help,
                                 int id,
                                 const wxString& name,
                                 const wxString& help,

-                                bool isCheckable,
+                                wxItemKind kind,

                                 wxMenu *subMenu)
 {
                                 wxMenu *subMenu)
 {

-    return new wxMenuItem(parentMenu, id, name, help, isCheckable, subMenu);
+    return new wxMenuItem(parentMenu, id, name, help, kind, subMenu);

 }
 
 /* static */
 }
 
 /* static */

-wxString wxMenuItemBase::GetLabelFromText(const wxString& text)
+wxString wxMenuItemBase::GetLabelText(const wxString& text)

 {
     return wxStripMenuCodes(text);
 }
 {
     return wxStripMenuCodes(text);
 }


@@ -1455,12 +1542,13 @@ void wxMenuItem::UpdateAccelInfo()
     m_strAccel = m_text.AfterFirst(_T('\t'));
 }
 
     m_strAccel = m_text.AfterFirst(_T('\t'));
 }
 

-void wxMenuItem::SetText(const wxString& text)
+void wxMenuItem::SetItemLabel(const wxString& text)

 {
     if ( text != m_text )
     {
         // first call the base class version to change m_text
 {
     if ( text != m_text )
     {
         // first call the base class version to change m_text

-        wxMenuItemBase::SetText(text);
+        // (and also check if we don't have a stock menu item)
+        wxMenuItemBase::SetItemLabel(text);

 
         UpdateAccelInfo();
 
 
         UpdateAccelInfo();
 


@@ -1470,7 +1558,7 @@ void wxMenuItem::SetText(const wxString& text)
 
 void wxMenuItem::SetCheckable(bool checkable)
 {
 
 void wxMenuItem::SetCheckable(bool checkable)
 {

-    if ( checkable != m_isCheckable )
+    if ( checkable != IsCheckable() )

     {
         wxMenuItemBase::SetCheckable(checkable);
 
     {
         wxMenuItemBase::SetCheckable(checkable);
 


@@ -1499,12 +1587,79 @@ void wxMenuItem::Enable(bool enable)
 
 void wxMenuItem::Check(bool check)
 {
 
 void wxMenuItem::Check(bool check)
 {

-    if ( check != m_isChecked )
+    wxCHECK_RET( IsCheckable(), wxT("only checkable items may be checked") );
+
+    if ( m_isChecked == check )
+        return;
+
+    if ( GetKind() == wxITEM_RADIO )

     {
     {

-        wxMenuItemBase::Check(check);
+        // it doesn't make sense to uncheck a radio item - what would this do?
+        if ( !check )
+            return;

 
 

-        NotifyMenu();
+        // get the index of this item in the menu
+        const wxMenuItemList& items = m_parentMenu->GetMenuItems();
+        int pos = items.IndexOf(this);
+        wxCHECK_RET( pos != wxNOT_FOUND,
+                     _T("menuitem not found in the menu items list?") );
+
+        // get the radio group range
+        int start,
+            end;
+
+        if ( m_isRadioGroupStart )
+        {
+            // we already have all information we need
+            start = pos;
+            end = m_radioGroup.end;
+        }
+        else // next radio group item
+        {
+            // get the radio group end from the start item
+            start = m_radioGroup.start;
+            end = items.Item(start)->GetData()->m_radioGroup.end;
+        }
+
+        // also uncheck all the other items in this radio group
+        wxMenuItemIter node = items.Item(start);
+        for ( int n = start; n <= end && node; n++ )
+        {
+            if ( n != pos )
+            {
+                node->GetData()->m_isChecked = false;
+            }
+            node = node->GetNext();
+        }

     }
     }

+
+    wxMenuItemBase::Check(check);
+
+    NotifyMenu();
+}
+
+// radio group stuff
+// -----------------
+
+void wxMenuItem::SetAsRadioGroupStart()
+{
+    m_isRadioGroupStart = true;
+}
+
+void wxMenuItem::SetRadioGroupStart(int start)
+{
+    wxASSERT_MSG( !m_isRadioGroupStart,
+                  _T("should only be called for the next radio items") );
+
+    m_radioGroup.start = start;
+}
+
+void wxMenuItem::SetRadioGroupEnd(int end)
+{
+    wxASSERT_MSG( m_isRadioGroupStart,
+                  _T("should only be called for the first radio item") );
+
+    m_radioGroup.end = end;

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -1519,7 +1674,15 @@ void wxMenuBar::Init()
 
     m_menuShown = NULL;
 
 
     m_menuShown = NULL;
 

-    m_shouldShowMenu = FALSE;
+    m_shouldShowMenu = false;
+}
+
+wxMenuBar::wxMenuBar(size_t n, wxMenu *menus[], const wxString titles[], long WXUNUSED(style))
+{
+    Init();
+
+    for (size_t i = 0; i < n; ++i )
+        Append(menus[i], titles[i]);

 }
 
 void wxMenuBar::Attach(wxFrame *frame)
 }
 
 void wxMenuBar::Attach(wxFrame *frame)


@@ -1543,14 +1706,14 @@ void wxMenuBar::Attach(wxFrame *frame)
     else // not created yet, do it now
     {
         // we have no way to return the error from here anyhow :-(
     else // not created yet, do it now
     {
         // we have no way to return the error from here anyhow :-(

-        (void)Create(frame, -1);
+        (void)Create(frame, wxID_ANY);

 
         SetCursor(wxCURSOR_ARROW);
 
 
         SetCursor(wxCURSOR_ARROW);
 

-        SetFont(wxSystemSettings::GetSystemFont(wxSYS_SYSTEM_FONT));
+        SetFont(wxSystemSettings::GetFont(wxSYS_SYSTEM_FONT));

 
         // calculate and set our height (it won't be changed any more)
 
         // calculate and set our height (it won't be changed any more)

-        SetSize(-1, GetBestSize().y);
+        SetSize(wxDefaultCoord, GetBestSize().y);

     }
 
     // remember the last frame which had us to avoid unnecessarily reparenting
     }
 
     // remember the last frame which had us to avoid unnecessarily reparenting


@@ -1585,14 +1748,14 @@ bool wxMenuBar::Append(wxMenu *menu, const wxString& title)
 bool wxMenuBar::Insert(size_t pos, wxMenu *menu, const wxString& title)
 {
     if ( !wxMenuBarBase::Insert(pos, menu, title) )
 bool wxMenuBar::Insert(size_t pos, wxMenu *menu, const wxString& title)
 {
     if ( !wxMenuBarBase::Insert(pos, menu, title) )

-        return FALSE;
+        return false;

 
     wxMenuInfo *info = new wxMenuInfo(title);
     m_menuInfos.Insert(info, pos);
 
     RefreshAllItemsAfter(pos);
 
 
     wxMenuInfo *info = new wxMenuInfo(title);
     m_menuInfos.Insert(info, pos);
 
     RefreshAllItemsAfter(pos);
 

-    return TRUE;
+    return true;

 }
 
 wxMenu *wxMenuBar::Replace(size_t pos, wxMenu *menu, const wxString& title)
 }
 
 wxMenu *wxMenuBar::Replace(size_t pos, wxMenu *menu, const wxString& title)


@@ -1656,16 +1819,16 @@ void wxMenuBar::EnableTop(size_t pos, bool enable)
 
 bool wxMenuBar::IsEnabledTop(size_t pos) const
 {
 
 bool wxMenuBar::IsEnabledTop(size_t pos) const
 {

-    wxCHECK_MSG( pos < GetCount(), FALSE, _T("invalid index in IsEnabledTop") );
+    wxCHECK_MSG( pos < GetCount(), false, _T("invalid index in IsEnabledTop") );

 
     return m_menuInfos[pos].IsEnabled();
 }
 
 
     return m_menuInfos[pos].IsEnabled();
 }
 

-void wxMenuBar::SetLabelTop(size_t pos, const wxString& label)
+void wxMenuBar::SetMenuLabel(size_t pos, const wxString& label)

 {
 {

-    wxCHECK_RET( pos < GetCount(), _T("invalid index in EnableTop") );
+    wxCHECK_RET( pos < GetCount(), _T("invalid index in SetMenuLabel") );

 
 

-    if ( label != m_menuInfos[pos].GetLabel() )
+    if ( label != m_menuInfos[pos].GetOriginalLabel() )

     {
         m_menuInfos[pos].SetLabel(label);
 
     {
         m_menuInfos[pos].SetLabel(label);
 


@@ -1674,11 +1837,11 @@ void wxMenuBar::SetLabelTop(size_t pos, const wxString& label)
     //else: nothing to do
 }
 
     //else: nothing to do
 }
 

-wxString wxMenuBar::GetLabelTop(size_t pos) const
+wxString wxMenuBar::GetMenuLabel(size_t pos) const

 {
 {

-    wxCHECK_MSG( pos < GetCount(), _T(""), _T("invalid index in GetLabelTop") );
+    wxCHECK_MSG( pos < GetCount(), wxEmptyString, _T("invalid index in GetMenuLabel") );

 
 

-    return m_menuInfos[pos].GetLabel();
+    return m_menuInfos[pos].GetOriginalLabel();

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -1715,7 +1878,7 @@ void wxMenuBar::RefreshItem(size_t pos)
 void wxMenuBar::DoDraw(wxControlRenderer *renderer)
 {
     wxDC& dc = renderer->GetDC();
 void wxMenuBar::DoDraw(wxControlRenderer *renderer)
 {
     wxDC& dc = renderer->GetDC();

-    dc.SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
+    dc.SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));

 
     // redraw only the items which must be redrawn
 
 
     // redraw only the items which must be redrawn
 


@@ -1800,8 +1963,8 @@ wxSize wxMenuBar::DoGetBestClientSize() const
     if ( GetMenuCount() > 0 )
     {
         wxClientDC dc(wxConstCast(this, wxMenuBar));
     if ( GetMenuCount() > 0 )
     {
         wxClientDC dc(wxConstCast(this, wxMenuBar));

-        dc.SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
-        dc.GetTextExtent(GetLabelTop(0), &size.x, &size.y);
+        dc.SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
+        dc.GetTextExtent(GetMenuLabel(0), &size.x, &size.y);

 
         // adjust for the renderer we use
         size = GetRenderer()->GetMenuBarItemSize(size);
 
         // adjust for the renderer we use
         size = GetRenderer()->GetMenuBarItemSize(size);


@@ -1847,6 +2010,7 @@ int wxMenuBar::GetMenuFromPoint(const wxPoint& pos) const
 void wxMenuBar::SelectMenu(size_t pos)
 {
     SetFocus();
 void wxMenuBar::SelectMenu(size_t pos)
 {
     SetFocus();

+    wxLogTrace(_T("mousecapture"), _T("Capturing mouse from wxMenuBar::SelectMenu"));

     CaptureMouse();
 
     DoSelectMenu(pos);
     CaptureMouse();
 
     DoSelectMenu(pos);


@@ -1866,7 +2030,7 @@ void wxMenuBar::DoSelectMenu(size_t pos)
         if ( IsShowingMenu() )
         {
             // restore m_shouldShowMenu flag after DismissMenu() which resets
         if ( IsShowingMenu() )
         {
             // restore m_shouldShowMenu flag after DismissMenu() which resets

-            // it to FALSE
+            // it to false

             bool old = m_shouldShowMenu;
 
             DismissMenu();
             bool old = m_shouldShowMenu;
 
             DismissMenu();


@@ -1935,13 +2099,14 @@ void wxMenuBar::OnLeftDown(wxMouseEvent& event)
         }
         else // on item
         {
         }
         else // on item
         {

+            wxLogTrace(_T("mousecapture"), _T("Capturing mouse from wxMenuBar::OnLeftDown"));

             CaptureMouse();
 
             // show it as selected
             RefreshItem((size_t)m_current);
 
             // show the menu
             CaptureMouse();
 
             // show it as selected
             RefreshItem((size_t)m_current);
 
             // show the menu

-            PopupCurrentMenu(FALSE /* don't select first item - as Windows does */);
+            PopupCurrentMenu(false /* don't select first item - as Windows does */);

         }
     }
 }
         }
     }
 }


@@ -1968,7 +2133,7 @@ bool wxMenuBar::ProcessMouseEvent(const wxPoint& pt)
     static wxPoint s_ptLast;
     if ( pt == s_ptLast )
     {
     static wxPoint s_ptLast;
     if ( pt == s_ptLast )
     {

-        return FALSE;
+        return false;

     }
 
     s_ptLast = pt;
     }
 
     s_ptLast = pt;


@@ -1977,7 +2142,7 @@ bool wxMenuBar::ProcessMouseEvent(const wxPoint& pt)
     int currentNew = GetMenuFromPoint(pt);
     if ( (currentNew == -1) || (currentNew == m_current) )
     {
     int currentNew = GetMenuFromPoint(pt);
     if ( (currentNew == -1) || (currentNew == m_current) )
     {

-        return FALSE;
+        return false;

     }
 
     // select the new active item
     }
 
     // select the new active item


@@ -1988,10 +2153,10 @@ bool wxMenuBar::ProcessMouseEvent(const wxPoint& pt)
     if ( m_shouldShowMenu && !m_menuShown)
     {
         // open the new menu if the old one we closed had been opened
     if ( m_shouldShowMenu && !m_menuShown)
     {
         // open the new menu if the old one we closed had been opened

-        PopupCurrentMenu(FALSE /* don't select first item - as Windows does */);
+        PopupCurrentMenu(false /* don't select first item - as Windows does */);

     }
 
     }
 

-    return TRUE;
+    return true;

 }
 
 void wxMenuBar::OnKeyDown(wxKeyEvent& event)
 }
 
 void wxMenuBar::OnKeyDown(wxKeyEvent& event)


@@ -2027,7 +2192,7 @@ void wxMenuBar::OnKeyDown(wxKeyEvent& event)
     // the menu when up/down one is
     switch ( key )
     {
     // the menu when up/down one is
     switch ( key )
     {

-        case WXK_MENU:
+        case WXK_ALT:

             // Alt must be processed at wxWindow level too
             event.Skip();
             // fall through
             // Alt must be processed at wxWindow level too
             event.Skip();
             // fall through


@@ -2135,7 +2300,7 @@ void wxMenuBar::OnKeyDown(wxKeyEvent& event)
 
 int wxMenuBar::FindNextItemForAccel(int idxStart, int key, bool *unique) const
 {
 
 int wxMenuBar::FindNextItemForAccel(int idxStart, int key, bool *unique) const
 {

-    if ( !wxIsalnum(key) )
+    if ( !wxIsalnum((wxChar)key) )

     {
         // we only support letters/digits as accels
         return -1;
     {
         // we only support letters/digits as accels
         return -1;


@@ -2143,10 +2308,10 @@ int wxMenuBar::FindNextItemForAccel(int idxStart, int key, bool *unique) const
 
     // do we have more than one item with this accel?
     if ( unique )
 
     // do we have more than one item with this accel?
     if ( unique )

-        *unique = TRUE;
+        *unique = true;

 
     // translate everything to lower case before comparing
 
     // translate everything to lower case before comparing

-    wxChar chAccel = wxTolower(key);
+    wxChar chAccel = (wxChar)wxTolower(key);

 
     // the index of the item with this accel
     int idxFound = -1;
 
     // the index of the item with this accel
     int idxFound = -1;


@@ -2169,8 +2334,7 @@ int wxMenuBar::FindNextItemForAccel(int idxStart, int key, bool *unique) const
 
         int idxAccel = info.GetAccelIndex();
         if ( idxAccel != -1 &&
 
         int idxAccel = info.GetAccelIndex();
         if ( idxAccel != -1 &&

-             wxTolower(info.GetLabel()[(size_t)idxAccel])
-                == chAccel )
+             (wxChar)wxTolower(info.GetLabel()[(size_t)idxAccel]) == chAccel )

         {
             // ok, found an item with this accel
             if ( idxFound == -1 )
         {
             // ok, found an item with this accel
             if ( idxFound == -1 )


@@ -2183,7 +2347,7 @@ int wxMenuBar::FindNextItemForAccel(int idxStart, int key, bool *unique) const
             else // we already had found such item
             {
                 if ( unique )
             else // we already had found such item
             {
                 if ( unique )

-                    *unique = FALSE;
+                    *unique = false;

 
                 // no need to continue further, we won't find
                 // anything we don't already know
 
                 // no need to continue further, we won't find
                 // anything we don't already know


@@ -2214,7 +2378,7 @@ int wxMenuBar::FindNextItemForAccel(int idxStart, int key, bool *unique) const
 bool wxMenuBar::ProcessAccelEvent(const wxKeyEvent& event)
 {
     size_t n = 0;
 bool wxMenuBar::ProcessAccelEvent(const wxKeyEvent& event)
 {
     size_t n = 0;

-    for ( wxMenuList::Node *node = m_menus.GetFirst();
+    for ( wxMenuList::compatibility_iterator node = m_menus.GetFirst();

           node;
           node = node->GetNext(), n++ )
     {
           node;
           node = node->GetNext(), n++ )
     {


@@ -2224,13 +2388,13 @@ bool wxMenuBar::ProcessAccelEvent(const wxKeyEvent& event)
             if ( node->GetData()->ProcessAccelEvent(event) )
             {
                 // menu processed it
             if ( node->GetData()->ProcessAccelEvent(event) )
             {
                 // menu processed it

-                return TRUE;
+                return true;

             }
         }
     }
 
     // not found
             }
         }
     }
 
     // not found

-    return FALSE;
+    return false;

 }
 
 #endif // wxUSE_ACCEL
 }
 
 #endif // wxUSE_ACCEL


@@ -2244,10 +2408,10 @@ void wxMenuBar::PopupCurrentMenu(bool selectFirst)
     wxCHECK_RET( m_current != -1, _T("no menu to popup") );
 
     // forgot to call DismissMenu()?
     wxCHECK_RET( m_current != -1, _T("no menu to popup") );
 
     // forgot to call DismissMenu()?

-    wxASSERT_MSG( !m_menuShown, _T("shouldn't show two menu at once!") );
+    wxASSERT_MSG( !m_menuShown, _T("shouldn't show two menus at once!") );

 
     // in any case, we should show it - even if we won't
 
     // in any case, we should show it - even if we won't

-    m_shouldShowMenu = TRUE;
+    m_shouldShowMenu = true;

 
     if ( IsEnabledTop(m_current) )
     {
 
     if ( IsEnabledTop(m_current) )
     {


@@ -2262,6 +2426,8 @@ void wxMenuBar::PopupCurrentMenu(bool selectFirst)
             // item, not to the right of it
             wxRect rectItem = GetItemRect(m_current);
 
             // item, not to the right of it
             wxRect rectItem = GetItemRect(m_current);
 

+            m_menuShown->SetInvokingWindow(m_frameLast);
+

             m_menuShown->Popup(ClientToScreen(rectItem.GetPosition()),
                                wxSize(0, rectItem.GetHeight()),
                                selectFirst);
             m_menuShown->Popup(ClientToScreen(rectItem.GetPosition()),
                                wxSize(0, rectItem.GetHeight()),
                                selectFirst);


@@ -2285,7 +2451,7 @@ void wxMenuBar::DismissMenu()
 
 void wxMenuBar::OnDismissMenu(bool dismissMenuBar)
 {
 
 void wxMenuBar::OnDismissMenu(bool dismissMenuBar)
 {

-    m_shouldShowMenu = FALSE;
+    m_shouldShowMenu = false;

     m_menuShown = NULL;
     if ( dismissMenuBar )
     {
     m_menuShown = NULL;
     if ( dismissMenuBar )
     {


@@ -2295,7 +2461,8 @@ void wxMenuBar::OnDismissMenu(bool dismissMenuBar)
 
 void wxMenuBar::OnDismiss()
 {
 
 void wxMenuBar::OnDismiss()
 {

-    ReleaseMouse();
+    if ( ReleaseMouseCapture() )
+        wxLogTrace(_T("mousecapture"), _T("Releasing mouse from wxMenuBar::OnDismiss"));

 
     if ( m_current != -1 )
     {
 
     if ( m_current != -1 )
     {


@@ -2308,6 +2475,42 @@ void wxMenuBar::OnDismiss()
     GiveAwayFocus();
 }
 
     GiveAwayFocus();
 }
 

+bool wxMenuBar::ReleaseMouseCapture()
+{
+#ifdef __WXX11__
+    // With wxX11, when a menu is closed by clicking away from it, a control
+    // under the click will still get an event, even though the menu has the
+    // capture (bug?). So that control may already have taken the capture by
+    // this point, preventing us from releasing the menu's capture. So to work
+    // around this, we release both captures, then put back the control's
+    // capture.
+    wxWindow *capture = GetCapture();
+    if ( capture )
+    {
+        capture->ReleaseMouse();
+
+        if ( capture == this )
+            return true;
+
+        bool had = HasCapture();
+
+        if ( had )
+            ReleaseMouse();
+
+        capture->CaptureMouse();
+
+        return had;
+    }
+#else
+    if ( HasCapture() )
+    {
+        ReleaseMouse();
+        return true;
+    }
+#endif
+    return false;
+}
+

 void wxMenuBar::GiveAwayFocus()
 {
     GetFrame()->SetFocus();
 void wxMenuBar::GiveAwayFocus()
 {
     GetFrame()->SetFocus();


@@ -2321,7 +2524,7 @@ wxEventLoop *wxWindow::ms_evtLoopPopup = NULL;
 
 bool wxWindow::DoPopupMenu(wxMenu *menu, int x, int y)
 {
 
 bool wxWindow::DoPopupMenu(wxMenu *menu, int x, int y)
 {

-    wxCHECK_MSG( !ms_evtLoopPopup, FALSE,
+    wxCHECK_MSG( !ms_evtLoopPopup, false,

                  _T("can't show more than one popup menu at a time") );
 
 #ifdef __WXMSW__
                  _T("can't show more than one popup menu at a time") );
 
 #ifdef __WXMSW__


@@ -2338,8 +2541,7 @@ bool wxWindow::DoPopupMenu(wxMenu *menu, int x, int y)
     wxLog::FlushActive();
 
     // some controls update themselves from OnIdle() call - let them do it
     wxLog::FlushActive();
 
     // some controls update themselves from OnIdle() call - let them do it

-    wxIdleEvent event;
-    wxTheApp->ProcessEvent(event);
+    wxTheApp->ProcessIdle();

 
     // if the window hadn't been refreshed yet, the menu can adversely affect
     // its next OnPaint() handler execution - i.e. scrolled window refresh
 
     // if the window hadn't been refreshed yet, the menu can adversely affect
     // its next OnPaint() handler execution - i.e. scrolled window refresh


@@ -2349,7 +2551,10 @@ bool wxWindow::DoPopupMenu(wxMenu *menu, int x, int y)
 #endif // 0
 
     menu->SetInvokingWindow(this);
 #endif // 0
 
     menu->SetInvokingWindow(this);

-    menu->Popup(ClientToScreen(wxPoint(x, y)), wxSize(0, 0));
+
+    // wxLogDebug( "Name of invoking window %s", menu->GetInvokingWindow()->GetName().c_str() );
+
+    menu->Popup(ClientToScreen(wxPoint(x, y)), wxSize(0,0));

 
     // this is not very useful if the menu was popped up because of the mouse
     // click but I think it is nice to do when it appears because of a key
 
     // this is not very useful if the menu was popped up because of the mouse
     // click but I think it is nice to do when it appears because of a key


@@ -2369,7 +2574,7 @@ bool wxWindow::DoPopupMenu(wxMenu *menu, int x, int y)
     ms_evtLoopPopup = NULL;
 
     // remove the handler
     ms_evtLoopPopup = NULL;
 
     // remove the handler

-    PopEventHandler(TRUE /* delete it */);
+    PopEventHandler(true /* delete it */);

 
     menu->SetInvokingWindow(NULL);
 
 
     menu->SetInvokingWindow(NULL);
 


@@ -2377,7 +2582,7 @@ bool wxWindow::DoPopupMenu(wxMenu *menu, int x, int y)
     SetCursor(cursorOld);
 #endif // __WXMSW__
 
     SetCursor(cursorOld);
 #endif // __WXMSW__
 

-    return TRUE;
+    return true;

 }
 
 void wxWindow::DismissPopupMenu()
 }
 
 void wxWindow::DismissPopupMenu()


@@ -2388,4 +2593,3 @@ void wxWindow::DismissPopupMenu()
 }
 
 #endif // wxUSE_MENUS
 }
 
 #endif // wxUSE_MENUS

-