]> git.saurik.com Git - wxWidgets.git/blobdiff - src/os2/menu.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fix minor typo in wxDV_VERT_RULES documentation.
[wxWidgets.git] / src / os2 / menu.cpp
diff --git a/src/os2/menu.cpp b/src/os2/menu.cpp
index 8ff449298fbe16a47a29ad05915dcbe3eac60995..73b5a56cfaa36e8b1e556a2dc38c252bfb731464 100644 (file)
--- a/src/os2/menu.cpp
+++ b/src/os2/menu.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
-// Name:        menu.cpp
+// Name:        src/os2/menu.cpp
 // Purpose:     wxMenu, wxMenuBar, wxMenuItem
 // Author:      David Webster
 // Modified by:
 // Purpose:     wxMenu, wxMenuBar, wxMenuItem
 // Author:      David Webster
 // Modified by:
@@ -9,16 +9,14 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
-#ifdef __GNUG__
-    #pragma implementation "menu.h"
-#endif
-
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
+#include "wx/menu.h"
+
 #ifndef WX_PRECOMP
 #ifndef WX_PRECOMP
+    #include "wx/app.h"
     #include "wx/frame.h"
     #include "wx/frame.h"
-    #include "wx/menu.h"
     #include "wx/utils.h"
     #include "wx/intl.h"
     #include "wx/log.h"
     #include "wx/utils.h"
     #include "wx/intl.h"
     #include "wx/log.h"
@@ -46,15 +44,17 @@ extern wxMenu*                      wxCurrentPopupMenu;
 //
 // The (popup) menu title has this special id
 //
 //
 // The (popup) menu title has this special id
 //
-static const int                    idMenuTitle = -2;
+static const int                    idMenuTitle = -3;
+
+//
+// The unique ID for Menus
+//
+USHORT                              wxMenu::m_nextMenuId = 0;
 
 // ----------------------------------------------------------------------------
 // macros
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // macros
 // ----------------------------------------------------------------------------
 
-    IMPLEMENT_DYNAMIC_CLASS(wxMenu, wxEvtHandler)
-    IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxEvtHandler)
-
 // ============================================================================
 // implementation
 // ============================================================================
 // ============================================================================
 // implementation
 // ============================================================================
@@ -68,13 +68,14 @@ static const int                    idMenuTitle = -2;
 //
 void wxMenu::Init()
 {
 //
 void wxMenu::Init()
 {
-    m_bDoBreak = FALSE;
+    m_bDoBreak = false;
+    m_nStartRadioGroup = -1;
 
     //
     // Create the menu (to be used as a submenu or a popup)
     //
     if ((m_hMenu =  ::WinCreateWindow( HWND_DESKTOP
 
     //
     // Create the menu (to be used as a submenu or a popup)
     //
     if ((m_hMenu =  ::WinCreateWindow( HWND_DESKTOP
-                                      ,(const wxChar*)WC_MENU
+                                      ,WC_MENU
                                       ,"Menu"
                                       ,0L
                                       ,0L
                                       ,"Menu"
                                       ,0L
                                       ,0L
@@ -86,18 +87,26 @@ void wxMenu::Init()
                                       ,0L
                                       ,NULL
                                       ,NULL
                                       ,0L
                                       ,NULL
                                       ,NULL
-                                     )) != 0)
+                                     )) == 0)
     {
     {
-        wxLogLastError("WinLoadMenu");
+        wxLogLastError(wxT("WinLoadMenu"));
     }
     }
+    m_vMenuData.iPosition   = 0;
+    m_vMenuData.afStyle     = MIS_SUBMENU | MIS_TEXT;
+    m_vMenuData.afAttribute = (USHORT)0;
+    m_vMenuData.id          = m_nextMenuId++;
+    m_vMenuData.hwndSubMenu = m_hMenu;
+    m_vMenuData.hItem       = NULLHANDLE;
 
     //
     // If we have a title, insert it in the beginning of the menu
     //
 
     //
     // If we have a title, insert it in the beginning of the menu
     //
-    if (!m_title.IsEmpty())
+    if (!m_title.empty())
     {
         Append( idMenuTitle
                ,m_title
     {
         Append( idMenuTitle
                ,m_title
+               ,wxEmptyString
+               ,wxITEM_NORMAL
               );
         AppendSeparator();
     }
               );
         AppendSeparator();
     }
@@ -116,7 +125,7 @@ wxMenu::~wxMenu()
     {
         if (!::WinDestroyWindow((HWND)GetHmenu()) )
         {
     {
         if (!::WinDestroyWindow((HWND)GetHmenu()) )
         {
-            wxLogLastError("WinDestroyWindow");
+            wxLogLastError(wxT("WinDestroyWindow"));
         }
     }
 
         }
     }
 
@@ -131,9 +140,17 @@ wxMenu::~wxMenu()
 void wxMenu::Break()
 {
     // this will take effect during the next call to Append()
 void wxMenu::Break()
 {
     // this will take effect during the next call to Append()
-    m_bDoBreak = TRUE;
+    m_bDoBreak = true;
 } // end of wxMenu::Break
 
 } // end of wxMenu::Break
 
+void wxMenu::Attach(
+  wxMenuBarBase*                    pMenubar
+)
+{
+    wxMenuBase::Attach(pMenubar);
+    EndRadioGroup();
+} // end of wxMenu::Break;
+
 #if wxUSE_ACCEL
 
 int wxMenu::FindAccel(
 #if wxUSE_ACCEL
 
 int wxMenu::FindAccel(
@@ -144,10 +161,8 @@ int wxMenu::FindAccel(
     size_t                          nCount = m_vAccels.GetCount();
 
     for (n = 0; n < nCount; n++)
     size_t                          nCount = m_vAccels.GetCount();
 
     for (n = 0; n < nCount; n++)
-    {
         if (m_vAccels[n]->m_command == nId)
             return n;
         if (m_vAccels[n]->m_command == nId)
             return n;
-    }
     return wxNOT_FOUND;
 } // end of wxMenu::FindAccel
 
     return wxNOT_FOUND;
 } // end of wxMenu::FindAccel
 
@@ -155,45 +170,70 @@ void wxMenu::UpdateAccel(
   wxMenuItem*                       pItem
 )
 {
   wxMenuItem*                       pItem
 )
 {
-    //
-    // Find the (new) accel for this item
-    //
-    wxAcceleratorEntry*             pAccel = wxGetAccelFromString(pItem->GetText());
-
-    if (pAccel)
-        pAccel->m_command = pItem->GetId();
-
-    //
-    // Find the old one
-    //
-    int                             n = FindAccel(pItem->GetId());
+    if (pItem->IsSubMenu())
+    {
+        wxMenu*                     pSubmenu = pItem->GetSubMenu();
+        wxMenuItemList::compatibility_iterator node = pSubmenu->GetMenuItems().GetFirst();
 
 
-    if (n == wxNOT_FOUND)
+        while (node)
+        {
+            UpdateAccel(node->GetData());
+            node = node->GetNext();
+        }
+    }
+    else if (!pItem->IsSeparator())
     {
         //
     {
         //
-        // No old, add new if any
+        // Recurse upwards: we should only modify m_accels of the top level
+        // menus, not of the submenus as wxMenuBar doesn't look at them
+        // (alternative and arguable cleaner solution would be to recurse
+        // downwards in GetAccelCount() and CopyAccels())
         //
         //
-        if (pAccel)
-            m_vAccels.Add(pAccel);
-        else
-            return;     // skipping RebuildAccelTable() below
-    }
-    else
-    {
+        if (GetParent())
+        {
+            GetParent()->UpdateAccel(pItem);
+            return;
+        }
+
         //
         //
-        // Replace old with new or just remove the old one if no new
+        // Find the (new) accel for this item
         //
         //
-        delete                      m_vAccels[n];
+        wxAcceleratorEntry*         pAccel = wxAcceleratorEntry::Create(pItem->GetItemLabel());
 
         if (pAccel)
 
         if (pAccel)
-            m_vAccels[n] = pAccel;
+            pAccel->m_command = pItem->GetId();
+
+        //
+        // Find the old one
+        //
+        size_t                      n = FindAccel(pItem->GetId());
+
+        if (n == (size_t)wxNOT_FOUND)
+        {
+            //
+            // No old, add new if any
+            //
+            if (pAccel)
+                m_vAccels.Add(pAccel);
+            else
+                return;
+        }
         else
         else
-            m_vAccels.Remove(n);
-    }
+        {
+            //
+            // Replace old with new or just remove the old one if no new
+            //
+            delete m_vAccels[n];
+            if (pAccel)
+                m_vAccels[n] = pAccel;
+            else
+                m_vAccels.RemoveAt(n);
+        }
 
 
-    if (IsAttached())
-    {
-        m_menuBar->RebuildAccelTable();
+        if (IsAttached())
+        {
+            GetMenuBar()->RebuildAccelTable();
+        }
     }
 } // wxMenu::UpdateAccel
 
     }
 } // wxMenu::UpdateAccel
 
@@ -202,11 +242,16 @@ void wxMenu::UpdateAccel(
 //
 // Append a new item or submenu to the menu
 //
 //
 // Append a new item or submenu to the menu
 //
-bool wxMenu::DoInsertOrAppend(
-  wxMenuItem*                       pItem
-, size_t                            nPos
-)
+bool wxMenu::DoInsertOrAppend( wxMenuItem* pItem,
+                               size_t      nPos )
 {
 {
+    wxMenu*    pSubmenu = pItem->GetSubMenu();
+    MENUITEM&  rItem = (pSubmenu != NULL)?pSubmenu->m_vMenuData:
+                       pItem->m_vMenuData;
+
+    ERRORID    vError;
+    wxString   sError;
+
 #if wxUSE_ACCEL
     UpdateAccel(pItem);
 #endif // wxUSE_ACCEL
 #if wxUSE_ACCEL
     UpdateAccel(pItem);
 #endif // wxUSE_ACCEL
@@ -217,129 +262,205 @@ bool wxMenu::DoInsertOrAppend(
     //
     if (m_bDoBreak)
     {
     //
     if (m_bDoBreak)
     {
-        m_vMenuData.afStyle |= MIS_BREAK;
-        m_bDoBreak = FALSE;
-    }
-
-    if (pItem->IsSeparator())
-    {
-        m_vMenuData.afStyle |= MIS_SEPARATOR;
+        rItem.afStyle |= MIS_BREAK;
+        m_bDoBreak = false;
     }
 
     //
     // Id is the numeric id for normal menu items and HMENU for submenus as
     }
 
     //
     // Id is the numeric id for normal menu items and HMENU for submenus as
-    // required by ::WinInsertMenu() API
+    // required by ::MM_INSERTITEM message API
     //
     //
-
-    wxMenu*                         pSubmenu = pItem->GetSubMenu();
-
     if (pSubmenu != NULL)
     {
         wxASSERT_MSG(pSubmenu->GetHMenu(), wxT("invalid submenu"));
         pSubmenu->SetParent(this);
 
     if (pSubmenu != NULL)
     {
         wxASSERT_MSG(pSubmenu->GetHMenu(), wxT("invalid submenu"));
         pSubmenu->SetParent(this);
 
-        m_vMenuData.iPosition = 0; // submenus have a 0 position
-        m_vMenuData.id = (USHORT)pSubmenu->GetHMenu();
-        m_vMenuData.afStyle |= MIS_SUBMENU;
+        rItem.iPosition = 0; // submenus have a 0 position
+        rItem.id        = (USHORT)pSubmenu->GetHMenu();
+        rItem.afStyle  |= MIS_SUBMENU | MIS_TEXT;
     }
     else
     {
     }
     else
     {
-        m_vMenuData.id = pItem->GetId();
+        rItem.id = (USHORT)pItem->GetId();
     }
 
     }
 
-    BYTE*                           pData;
+    char *pData = NULL;
 
 #if wxUSE_OWNER_DRAWN
     if (pItem->IsOwnerDrawn())
     {
         //
         // Want to get {Measure|Draw}Item messages?
 
 #if wxUSE_OWNER_DRAWN
     if (pItem->IsOwnerDrawn())
     {
         //
         // Want to get {Measure|Draw}Item messages?
-        // item draws itself, pass pointer to it in data parameter
-        // Will eventually need to set the image handle somewhere into m_vMenuData.hItem
+        // item draws itself, passing pointer to data doesn't work in OS/2
+        // Will eventually need to set the image handle somewhere into vItem.hItem
         //
         //
-        m_vMenuData.afStyle |= MIS_OWNERDRAW;
-        pData = (BYTE*)pItem;
+        rItem.afStyle             |= MIS_OWNERDRAW;
+        pData                      = NULL;
+        rItem.hItem                = (HBITMAP)pItem->GetBitmap().GetHBITMAP();
+        pItem->m_vMenuData.afStyle = rItem.afStyle;
+        pItem->m_vMenuData.hItem   = rItem.hItem;
     }
     else
 #endif
     }
     else
 #endif
+    if (pItem->IsSeparator())
     {
     {
-        //
-        // Menu is just a normal string (passed in data parameter)
-        //
-        m_vMenuData.afStyle |= MIS_TEXT;
-        pData = (char*)pItem->GetText().c_str();
+        rItem.afStyle = MIS_SEPARATOR;
+    }
+    else
+    {
+        if (pItem->GetId() == idMenuTitle)
+        {
+            // Item is an unselectable title to be passed via pData
+            rItem.afStyle = MIS_STATIC;
+        }
+        else
+        {
+            //
+            // Menu is just a normal string (passed in data parameter)
+            //
+            rItem.afStyle |= MIS_TEXT;
+        }
+        pData = (char*) pItem->GetItemLabel().wx_str();
+    }
+
+    if (nPos == (size_t)-1)
+    {
+        rItem.iPosition = MIT_END;
+    }
+    else
+    {
+        rItem.iPosition = (SHORT)nPos;
+    }
+
+    APIRET                          rc;
+
+    rc = (APIRET)::WinSendMsg( GetHmenu()
+                              ,MM_INSERTITEM
+                              ,(MPARAM)&rItem
+                              ,(MPARAM)pData
+                             );
+#if wxUSE_OWNER_DRAWN
+    if (pItem->IsOwnerDrawn())
+    {
+        MENUITEM                   vMenuItem;
+
+        ::WinSendMsg( GetHmenu()
+                     ,MM_QUERYITEM
+                     ,MPFROM2SHORT( (USHORT)pItem->GetId()
+                                   ,(USHORT)(FALSE)
+                                  )
+                     ,&vMenuItem
+                    );
+    }
+#endif
+
+    if (rc == (APIRET)MIT_MEMERROR || rc == (APIRET)MIT_ERROR)
+    {
+        vError = ::WinGetLastError(vHabmain);
+        sError = wxPMErrorToStr(vError);
+        wxLogError(wxT("Error inserting or appending a menuitem. Error: %s\n"), sError.c_str());
+        wxLogLastError(wxT("Insert or AppendMenu"));
+        return false;
+    }
+
+    //
+    // If we're already attached to the menubar, we must update it
+    //
+    if (IsAttached() && GetMenuBar()->IsAttached())
+    {
+        GetMenuBar()->Refresh();
     }
 
     }
 
-    BOOL                            bOk;
+    return true;
+} // end of wxMenu::DoInsertOrAppend
 
 
+void wxMenu::EndRadioGroup()
+{
     //
     //
-    // -1 means this is a sub menu not a menuitem.  We must create a window for it.
-    // Submenus are also attached to a menubar so its parent and owner should be the handle of the menubar.
+    // We're not inside a radio group any longer
     //
     //
-    if (nPos == (size_t)-1)
+    m_nStartRadioGroup = -1;
+} // end of wxMenu::EndRadioGroup
+
+wxMenuItem* wxMenu::DoAppend( wxMenuItem* pItem )
+{
+    wxCHECK_MSG( pItem, NULL, wxT("NULL item in wxMenu::DoAppend") );
+
+    bool bCheck = false;
+
+    if (pItem->GetKind() == wxITEM_RADIO)
     {
     {
-        HWND                        hSubMenu = ::WinCreateWindow( GetWinHwnd(m_menuBar) // parent
-                                                                 ,WC_MENU               // type
-                                                                 ,"Menu"                // a generic name
-                                                                 ,0L                    // no style flag
-                                                                 ,0L,0L,0L,0L           // no position
-                                                                 ,GetWinHwnd(m_menuBar) // no owner
-                                                                 ,HWND_TOP              // always on top
-                                                                 ,0L                    // no ID needed for dynamic creation
-                                                                 ,NULL                  // no control data
-                                                                 ,NULL                  // no presentation params
-                                                                );
+        int                         nCount = GetMenuItemCount();
+
+        if (m_nStartRadioGroup == -1)
+        {
+            //
+            // Start a new radio group
+            //
+            m_nStartRadioGroup = nCount;
 
 
-        m_vMenuData.iPosition   = 0;
-        m_vMenuData.hwndSubMenu = hSubMenu;
-        m_vMenuData.hItem       = NULLHANDLE;
+            //
+            // For now it has just one element
+            //
+            pItem->SetAsRadioGroupStart();
+            pItem->SetRadioGroupEnd(m_nStartRadioGroup);
 
 
-        bOk = (bool)::WinSendMsg(GetHmenu(), MM_INSERTITEM, (MPARAM)&m_vMenuData, (MPARAM)pItem->GetText().c_str());
+            //
+            // Ensure that we have a checked item in the radio group
+            //
+            bCheck = true;
+        }
+        else // extend the current radio group
+        {
+            //
+            // We need to update its end item
+            //
+            pItem->SetRadioGroupStart(m_nStartRadioGroup);
+
+            wxMenuItemList::compatibility_iterator node = GetMenuItems().Item(m_nStartRadioGroup);
+
+            if (node)
+            {
+                node->GetData()->SetRadioGroupEnd(nCount);
+            }
+            else
+            {
+                wxFAIL_MSG( wxT("where is the radio group start item?") );
+            }
+        }
     }
     }
-    else
+    else // not a radio item
     {
     {
-        m_vMenuData.iPosition   = nPos;
-        m_vMenuData.hwndSubMenu = NULLHANDLE;
-        m_vMenuData.hItem       = NULLHANDLE;
-        bOk = (bool)::WinSendMsg(GetHmenu(), MM_INSERTITEM, (MPARAM)&m_vMenuData, (MPARAM)pItem->GetText().c_str());
+        EndRadioGroup();
     }
 
     }
 
-    if (!bOk)
+    if (!wxMenuBase::DoAppend(pItem) || !DoInsertOrAppend(pItem))
     {
     {
-        wxLogLastError("Insert or AppendMenu");
-        return FALSE;
+        return NULL;
     }
     }
-    else
+    if (bCheck)
     {
         //
     {
         //
-        // If we're already attached to the menubar, we must update it
+        // Check the item initially
         //
         //
-        if (IsAttached())
-        {
-            m_menuBar->Refresh();
-        }
-        return TRUE;
+        pItem->Check(true);
     }
     }
-    return FALSE;
-} // end of wxMenu::DoInsertOrAppend
-
-bool wxMenu::DoAppend(
-  wxMenuItem*                       pItem
-)
-{
-    return wxMenuBase::DoAppend(pItem) && DoInsertOrAppend(pItem);
-}
+    return pItem;
+} // end of wxMenu::DoAppend
 
 
-bool wxMenu::DoInsert(
+wxMenuItem* wxMenu::DoInsert(
   size_t                            nPos
 , wxMenuItem*                       pItem
 )
 {
   size_t                            nPos
 , wxMenuItem*                       pItem
 )
 {
-    return ( wxMenuBase::DoInsert( nPos
-                                  ,pItem) &&
+    if ( wxMenuBase::DoInsert( nPos
+                               ,pItem) &&
              DoInsertOrAppend( pItem
                               ,nPos
              DoInsertOrAppend( pItem
                               ,nPos
-                             ));
+                 ))
+         return pItem;
+    else
+        return NULL;
 } // end of wxMenu::DoInsert
 
 wxMenuItem* wxMenu::DoRemove(
 } // end of wxMenu::DoInsert
 
 wxMenuItem* wxMenu::DoRemove(
@@ -350,19 +471,19 @@ wxMenuItem* wxMenu::DoRemove(
     // We need to find the items position in the child list
     //
     size_t                          nPos;
     // We need to find the items position in the child list
     //
     size_t                          nPos;
-    wxMenuItemList::Node*           pNode = GetMenuItems().GetFirst();
+    wxMenuItemList::compatibility_iterator node = GetMenuItems().GetFirst();
 
 
-    for (nPos = 0; pNode; nPos++)
+    for (nPos = 0; node; nPos++)
     {
     {
-        if (pNode->GetData() == pItem)
+        if (node->GetData() == pItem)
             break;
             break;
-        pNode = pNode->GetNext();
+        node = node->GetNext();
     }
 
     //
     // DoRemove() (unlike Remove) can only be called for existing item!
     //
     }
 
     //
     // DoRemove() (unlike Remove) can only be called for existing item!
     //
-    wxCHECK_MSG(pNode, NULL, wxT("bug in wxMenu::Remove logic"));
+    wxCHECK_MSG(node, NULL, wxT("bug in wxMenu::Remove logic"));
 
 #if wxUSE_ACCEL
     //
 
 #if wxUSE_ACCEL
     //
@@ -373,7 +494,7 @@ wxMenuItem* wxMenu::DoRemove(
     if (n != wxNOT_FOUND)
     {
         delete m_vAccels[n];
     if (n != wxNOT_FOUND)
     {
         delete m_vAccels[n];
-        m_vAccels.Remove(n);
+        m_vAccels.RemoveAt(n);
     }
 
 #endif // wxUSE_ACCEL
     }
 
 #endif // wxUSE_ACCEL
@@ -385,12 +506,12 @@ wxMenuItem* wxMenu::DoRemove(
                  ,MPFROM2SHORT(pItem->GetId(), TRUE)
                  ,(MPARAM)0
                 );
                  ,MPFROM2SHORT(pItem->GetId(), TRUE)
                  ,(MPARAM)0
                 );
-    if (IsAttached())
+    if (IsAttached() && GetMenuBar()->IsAttached())
     {
         //
         // Otherwise, the chane won't be visible
         //
     {
         //
         // Otherwise, the chane won't be visible
         //
-        m_menuBar->Refresh();
+        GetMenuBar()->Refresh();
     }
 
     //
     }
 
     //
@@ -428,27 +549,25 @@ size_t wxMenu::CopyAccels(
 // set wxMenu title
 // ---------------------------------------------------------------------------
 
 // set wxMenu title
 // ---------------------------------------------------------------------------
 
-void wxMenu::SetTitle(
-  const wxString&                   rLabel
-)
+void wxMenu::SetTitle( const wxString& rLabel )
 {
 {
-    bool                            bHasNoTitle = m_title.IsEmpty();
-    HWND                            hMenu = GetHmenu();
+    bool bHasNoTitle = m_title.empty();
+    HWND hMenu = GetHmenu();
 
     m_title = rLabel;
     if (bHasNoTitle)
     {
 
     m_title = rLabel;
     if (bHasNoTitle)
     {
-        if (!rLabel.IsEmpty())
+        if (!rLabel.empty())
         {
             if (!::WinSetWindowText(hMenu, rLabel.c_str()))
             {
         {
             if (!::WinSetWindowText(hMenu, rLabel.c_str()))
             {
-                wxLogLastError("SetMenuTitle");
+                wxLogLastError(wxT("SetMenuTitle"));
             }
         }
     }
     else
     {
             }
         }
     }
     else
     {
-        if (rLabel.IsEmpty() )
+        if (rLabel.empty() )
         {
             ::WinSendMsg( GetHmenu()
                          ,MM_REMOVEITEM
         {
             ::WinSendMsg( GetHmenu()
                          ,MM_REMOVEITEM
@@ -463,7 +582,7 @@ void wxMenu::SetTitle(
             //
             if (!::WinSetWindowText(hMenu, rLabel.c_str()))
             {
             //
             if (!::WinSetWindowText(hMenu, rLabel.c_str()))
             {
-                wxLogLastError("SetMenuTitle");
+                wxLogLastError(wxT("SetMenuTitle"));
             }
         }
     }
             }
         }
     }
@@ -473,10 +592,8 @@ void wxMenu::SetTitle(
 // event processing
 // ---------------------------------------------------------------------------
 
 // event processing
 // ---------------------------------------------------------------------------
 
-bool wxMenu::OS2Command(
-  WXUINT                            WXUNUSED(uParam)
-, WXWORD                            vId
-)
+bool wxMenu::OS2Command( WXUINT WXUNUSED(uParam),
+                         WXWORD vId )
 {
     //
     // Ignore commands from the menu title
 {
     //
     // Ignore commands from the menu title
@@ -484,83 +601,72 @@ bool wxMenu::OS2Command(
 
     if (vId != (WXWORD)idMenuTitle)
     {
 
     if (vId != (WXWORD)idMenuTitle)
     {
-        wxCommandEvent              vEvent(wxEVT_COMMAND_MENU_SELECTED);
-
-        vEvent.SetEventObject(this);
-        vEvent.SetId(vId);
-        vEvent.SetInt(vId);
-        ProcessCommand(vEvent);
+        SendEvent( vId
+                  ,(int)::WinSendMsg( GetHmenu()
+                                     ,MM_QUERYITEMATTR
+                                     ,MPFROMSHORT(vId)
+                                     ,(MPARAM)MIA_CHECKED
+                                    )
+                 );
     }
     }
-    return TRUE;
+    return true;
 } // end of wxMenu::OS2Command
 
 } // end of wxMenu::OS2Command
 
-bool wxMenu::ProcessCommand(
-  wxCommandEvent&                   rEvent
-)
-{
-    bool                            bProcessed = FALSE;
-
-#if wxUSE_MENU_CALLBACK
-    //
-    // Try a callback
-    //
-    if (m_callback)
-    {
-        (void)(*(m_callback))(*this, rEvent);
-        bProcessed = TRUE;
-    }
-#endif // wxUSE_MENU_CALLBACK
-
-    //
-    // Try the menu's event handler
-    //
-    if (!bProcessed && GetEventHandler())
-    {
-        bProcessed = GetEventHandler()->ProcessEvent(rEvent);
-    }
-
-    //
-    // Try the window the menu was popped up from (and up through the
-    // hierarchy)
-    wxWindow*                       pWin = GetInvokingWindow();
-
-    if (!bProcessed && pWin)
-        bProcessed = pWin->GetEventHandler()->ProcessEvent(rEvent);
-    return bProcessed;
-} // end of wxMenu::ProcessCommand
-
 // ---------------------------------------------------------------------------
 // other
 // ---------------------------------------------------------------------------
 
 // ---------------------------------------------------------------------------
 // other
 // ---------------------------------------------------------------------------
 
-void wxMenu::Attach(
-  wxMenuBar*                        pMenubar
-)
-{
-    //
-    // Menu can be in at most one menubar because otherwise they would both
-    // delete the menu pointer
-    //
-    wxASSERT_MSG(!m_menuBar, wxT("menu belongs to 2 menubars, expect a crash"));
-    m_menuBar = pMenubar;
-} // end of
-
-void wxMenu::Detach()
-{
-    wxASSERT_MSG( m_menuBar, wxT("can't detach menu if it's not attached") );
-    m_menuBar = NULL;
-} // end of wxMenu::Detach
-
 wxWindow* wxMenu::GetWindow() const
 {
     if (m_invokingWindow != NULL)
         return m_invokingWindow;
 wxWindow* wxMenu::GetWindow() const
 {
     if (m_invokingWindow != NULL)
         return m_invokingWindow;
-    else if ( m_menuBar != NULL)
-        return m_menuBar->GetFrame();
+    else if ( GetMenuBar() != NULL)
+        return GetMenuBar()->GetFrame();
 
     return NULL;
 } // end of wxMenu::GetWindow
 
 
     return NULL;
 } // end of wxMenu::GetWindow
 
+// recursive search for item by id
+wxMenuItem* wxMenu::FindItem(
+  int                               nItemId
+, ULONG                             hItem
+, wxMenu**                          ppItemMenu
+) const
+{
+    if ( ppItemMenu )
+        *ppItemMenu = NULL;
+
+    wxMenuItem*                     pItem = NULL;
+
+    for ( wxMenuItemList::compatibility_iterator node = m_items.GetFirst();
+          node && !pItem;
+          node = node->GetNext() )
+    {
+        pItem = node->GetData();
+
+        if ( pItem->GetId() == nItemId && pItem->m_vMenuData.hItem == hItem)
+        {
+            if ( ppItemMenu )
+                *ppItemMenu = (wxMenu *)this;
+        }
+        else if ( pItem->IsSubMenu() )
+        {
+            pItem = pItem->GetSubMenu()->FindItem( nItemId
+                                                  ,hItem
+                                                  ,ppItemMenu
+                                                 );
+            if (pItem)
+                break;
+        }
+        else
+        {
+            // don't exit the loop
+            pItem = NULL;
+        }
+    }
+    return pItem;
+} // end of wxMenu::FindItem
+
 // ---------------------------------------------------------------------------
 // Menu Bar
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // Menu Bar
 // ---------------------------------------------------------------------------
@@ -568,7 +674,7 @@ wxWindow* wxMenu::GetWindow() const
 void wxMenuBar::Init()
 {
     m_eventHandler = this;
 void wxMenuBar::Init()
 {
     m_eventHandler = this;
-    m_pMenuBarFrame = NULL;
+    m_menuBarFrame = NULL;
     m_hMenu = 0;
 } // end of wxMenuBar::Init
 
     m_hMenu = 0;
 } // end of wxMenuBar::Init
 
@@ -588,6 +694,7 @@ wxMenuBar::wxMenuBar(
   int                               nCount
 , wxMenu*                           vMenus[]
 , const wxString                    sTitles[]
   int                               nCount
 , wxMenu*                           vMenus[]
 , const wxString                    sTitles[]
+, long                              WXUNUSED(lStyle)
 )
 {
     Init();
 )
 {
     Init();
@@ -603,6 +710,15 @@ wxMenuBar::wxMenuBar(
 
 wxMenuBar::~wxMenuBar()
 {
 
 wxMenuBar::~wxMenuBar()
 {
+    //
+    // We should free PM's resources only if PM doesn't do it for us
+    // which happens if we're attached to a frame
+    //
+    if (m_hMenu && !IsAttached())
+    {
+        ::WinDestroyWindow((HMENU)m_hMenu);
+        m_hMenu = (WXHMENU)NULL;
+    }
 } // end of wxMenuBar::~wxMenuBar
 
 // ---------------------------------------------------------------------------
 } // end of wxMenuBar::~wxMenuBar
 
 // ---------------------------------------------------------------------------
@@ -613,13 +729,12 @@ void wxMenuBar::Refresh()
 {
     wxCHECK_RET( IsAttached(), wxT("can't refresh unatteched menubar") );
 
 {
     wxCHECK_RET( IsAttached(), wxT("can't refresh unatteched menubar") );
 
-    WinSendMsg(GetWinHwnd(m_pMenuBarFrame), WM_UPDATEFRAME, (MPARAM)FCF_MENU, (MPARAM)0);
+    WinSendMsg(GetWinHwnd(m_menuBarFrame), WM_UPDATEFRAME, (MPARAM)FCF_MENU, (MPARAM)0);
 } // end of wxMenuBar::Refresh
 
 WXHMENU wxMenuBar::Create()
 {
 } // end of wxMenuBar::Refresh
 
 WXHMENU wxMenuBar::Create()
 {
-    MENUITEM                        vItem;
-    HWND                            hFrame;
+    HWND hFrame;
 
     if (m_hMenu != 0 )
         return m_hMenu;
 
     if (m_hMenu != 0 )
         return m_hMenu;
@@ -629,44 +744,71 @@ WXHMENU wxMenuBar::Create()
     //
     // Menubars should be associated with a frame otherwise they are popups
     //
     //
     // Menubars should be associated with a frame otherwise they are popups
     //
-    if (m_pMenuBarFrame != NULL)
-        hFrame = GetWinHwnd(m_pMenuBarFrame);
+    if (m_menuBarFrame != NULL)
+        hFrame = GetWinHwnd(m_menuBarFrame);
     else
         hFrame = HWND_DESKTOP;
     //
     // Create an empty menu and then fill it with insertions
     //
     else
         hFrame = HWND_DESKTOP;
     //
     // Create an empty menu and then fill it with insertions
     //
-    if (!wxWindow::OS2Create( hFrame
-                             ,WC_MENU
-                             ,"Menu"
-                             ,MS_ACTIONBAR | WS_SYNCPAINT | WS_VISIBLE
-                             ,0L
-                             ,0L
-                             ,0L
-                             ,0L
-                             ,hFrame
-                             ,HWND_TOP
-                             ,FID_MENU
-                             ,(PVOID)NULL
-                             ,(PVOID)NULL
-                            ))
-    {
-        wxLogLastError("CreateMenu");
+    if ((m_hMenu =  ::WinCreateWindow( hFrame
+                                      ,WC_MENU
+                                      ,NULL
+                                      ,MS_ACTIONBAR | WS_SYNCPAINT | WS_VISIBLE
+                                      ,0L
+                                      ,0L
+                                      ,0L
+                                      ,0L
+                                      ,hFrame
+                                      ,HWND_TOP
+                                      ,FID_MENU
+                                      ,NULL
+                                      ,NULL
+                                     )) == 0)
+    {
+        wxLogLastError(wxT("WinLoadMenu"));
     }
     else
     {
     }
     else
     {
-        size_t                      nCount = GetMenuCount();
-
-        for (size_t i = 0; i < nCount; i++)
+        size_t nCount = GetMenuCount(), i;
+        wxMenuList::iterator it;
+        for (i = 0, it = m_menus.begin(); i < nCount; i++, it++)
         {
         {
-            vItem.iPosition   = 0;
-            vItem.afStyle     = MIS_SUBMENU | MIS_TEXT;
-            vItem.afAttribute = (USHORT)0;
-            vItem.id          = (USHORT)0;
-            vItem.hwndSubMenu = m_menus[i]->GetHMenu();
-            vItem.hItem       = NULLHANDLE;
-
-            ::WinSendMsg(GetHmenu(), MM_INSERTITEM, (MPARAM)&vItem, (MPARAM)m_titles[i].c_str());
+            APIRET   rc;
+            ERRORID  vError;
+            wxString sError;
+            HWND     hSubMenu;
+
+            //
+            // Set the parent and owner of the submenues to be the menubar, not the desktop
+            //
+            hSubMenu = (*it)->m_vMenuData.hwndSubMenu;
+            if (!::WinSetParent((*it)->m_vMenuData.hwndSubMenu, m_hMenu, FALSE))
+            {
+                vError = ::WinGetLastError(vHabmain);
+                sError = wxPMErrorToStr(vError);
+                wxLogError(wxT("Error setting parent for submenu. Error: %s\n"), sError.c_str());
+                return NULLHANDLE;
+            }
+
+            if (!::WinSetOwner((*it)->m_vMenuData.hwndSubMenu, m_hMenu))
+            {
+                vError = ::WinGetLastError(vHabmain);
+                sError = wxPMErrorToStr(vError);
+                wxLogError(wxT("Error setting parent for submenu. Error: %s\n"), sError.c_str());
+                return NULLHANDLE;
+            }
+
+            (*it)->m_vMenuData.iPosition = (SHORT)i;
+
+            rc = (APIRET)::WinSendMsg(m_hMenu, MM_INSERTITEM, (MPARAM)&(*it)->m_vMenuData, (MPARAM)m_titles[i].wx_str());
+            if (rc == (APIRET)MIT_MEMERROR || rc == (APIRET)MIT_ERROR)
+            {
+                vError = ::WinGetLastError(vHabmain);
+                sError = wxPMErrorToStr(vError);
+                wxLogError(wxT("Error inserting or appending a menuitem. Error: %s\n"), sError.c_str());
+                return NULLHANDLE;
+            }
         }
     }
     return m_hMenu;
         }
     }
     return m_hMenu;
@@ -695,14 +837,14 @@ void wxMenuBar::EnableTop(
     nId = SHORT1FROMMR(::WinSendMsg((HWND)m_hMenu, MM_ITEMIDFROMPOSITION, MPFROMSHORT(nPos), (MPARAM)0));
     if (nId == MIT_ERROR)
     {
     nId = SHORT1FROMMR(::WinSendMsg((HWND)m_hMenu, MM_ITEMIDFROMPOSITION, MPFROMSHORT(nPos), (MPARAM)0));
     if (nId == MIT_ERROR)
     {
-        wxLogLastError("LogLastError");
+        wxLogLastError(wxT("LogLastError"));
         return;
     }
         return;
     }
-    ::WinSendMsg((HWND)m_hMenu, MM_SETITEMATTR, MPFROM2SHORT(nId, TRUE), MPFROM2SHORT(uFlag, uFlag));
+    ::WinSendMsg((HWND)m_hMenu, MM_SETITEMATTR, MPFROM2SHORT(nId, TRUE), MPFROM2SHORT(MIA_DISABLED, uFlag));
     Refresh();
 } // end of wxMenuBar::EnableTop
 
     Refresh();
 } // end of wxMenuBar::EnableTop
 
-void wxMenuBar::SetLabelTop(
+void wxMenuBar::SetMenuLabel(
   size_t                            nPos
 , const wxString&                   rLabel
 )
   size_t                            nPos
 , const wxString&                   rLabel
 )
@@ -721,7 +863,7 @@ void wxMenuBar::SetLabelTop(
     nId = SHORT1FROMMR(::WinSendMsg((HWND)m_hMenu, MM_ITEMIDFROMPOSITION, MPFROMSHORT(nPos), (MPARAM)0));
     if (nId == MIT_ERROR)
     {
     nId = SHORT1FROMMR(::WinSendMsg((HWND)m_hMenu, MM_ITEMIDFROMPOSITION, MPFROMSHORT(nPos), (MPARAM)0));
     if (nId == MIT_ERROR)
     {
-        wxLogLastError("LogLastError");
+        wxLogLastError(wxT("LogLastError"));
         return;
     }
     if(!::WinSendMsg( (HWND)m_hMenu
         return;
     }
     if(!::WinSendMsg( (HWND)m_hMenu
@@ -730,25 +872,25 @@ void wxMenuBar::SetLabelTop(
                      ,MPARAM(&vItem)
                     ))
     {
                      ,MPARAM(&vItem)
                     ))
     {
-        wxLogLastError("QueryItem");
+        wxLogLastError(wxT("QueryItem"));
     }
     nId = vItem.id;
 
     }
     nId = vItem.id;
 
-    if (::WinSendMsg(GetHmenu(), MM_SETITEMTEXT, MPFROMSHORT(nId), (MPARAM)rLabel.c_str()));
+    if (::WinSendMsg(GetHmenu(), MM_SETITEMTEXT, MPFROMSHORT(nId), (MPARAM)rLabel.wx_str()));
     {
     {
-        wxLogLastError("ModifyMenu");
+        wxLogLastError(wxT("ModifyMenu"));
     }
     Refresh();
     }
     Refresh();
-} // end of wxMenuBar::SetLabelTop
+} // end of wxMenuBar::SetMenuLabel
 
 
-wxString wxMenuBar::GetLabelTop(
+wxString wxMenuBar::GetMenuLabel(
   size_t                            nPos
 ) const
 {
     wxCHECK_MSG( nPos < GetMenuCount(), wxEmptyString,
   size_t                            nPos
 ) const
 {
     wxCHECK_MSG( nPos < GetMenuCount(), wxEmptyString,
-                 wxT("invalid menu index in wxMenuBar::GetLabelTop") );
+                 wxT("invalid menu index in wxMenuBar::GetMenuLabel") );
     return m_titles[nPos];
     return m_titles[nPos];
-} // end of wxMenuBar::GetLabelTop
+} // end of wxMenuBar::GetMenuLabel
 
 // ---------------------------------------------------------------------------
 // wxMenuBar construction
 
 // ---------------------------------------------------------------------------
 // wxMenuBar construction
@@ -761,25 +903,26 @@ wxMenu* wxMenuBar::Replace(
 )
 {
     SHORT                            nId;
 )
 {
     SHORT                            nId;
+    wxString                         sTitle = wxPMTextToLabel(rTitle);
     wxMenu*                          pMenuOld = wxMenuBarBase::Replace( nPos
                                                                        ,pMenu
     wxMenu*                          pMenuOld = wxMenuBarBase::Replace( nPos
                                                                        ,pMenu
-                                                                       ,rTitle
+                                                                       ,sTitle
                                                                       );
 
 
     nId = SHORT1FROMMR(::WinSendMsg((HWND)m_hMenu, MM_ITEMIDFROMPOSITION, MPFROMSHORT(nPos), (MPARAM)0));
     if (nId == MIT_ERROR)
     {
                                                                       );
 
 
     nId = SHORT1FROMMR(::WinSendMsg((HWND)m_hMenu, MM_ITEMIDFROMPOSITION, MPFROMSHORT(nPos), (MPARAM)0));
     if (nId == MIT_ERROR)
     {
-        wxLogLastError("LogLastError");
+        wxLogLastError(wxT("LogLastError"));
         return NULL;
     }
     if (!pMenuOld)
         return NULL;
     }
     if (!pMenuOld)
-        return FALSE;
-    m_titles[nPos] = rTitle;
+        return NULL;
+    m_titles[nPos] = sTitle;
     if (IsAttached())
     {
     if (IsAttached())
     {
-        ::WinSendMsg((HWND)m_hMenu, MM_DELETEITEM, MPFROM2SHORT(nId, TRUE), (MPARAM)0);
-        ::WinSendMsg((HWND)m_hMenu, MM_INSERTITEM, (MPARAM)&pMenu->m_vMenuData, (MPARAM)rTitle.c_str());
+        ::WinSendMsg((HWND)m_hMenu, MM_REMOVEITEM, MPFROM2SHORT(nId, TRUE), (MPARAM)0);
+        ::WinSendMsg((HWND)m_hMenu, MM_INSERTITEM, (MPARAM)&pMenu->m_vMenuData, (MPARAM)sTitle.wx_str());
 
 #if wxUSE_ACCEL
         if (pMenuOld->HasAccels() || pMenu->HasAccels())
 
 #if wxUSE_ACCEL
         if (pMenuOld->HasAccels() || pMenu->HasAccels())
@@ -795,27 +938,25 @@ wxMenu* wxMenuBar::Replace(
     return pMenuOld;
 } // end of wxMenuBar::Replace
 
     return pMenuOld;
 } // end of wxMenuBar::Replace
 
-bool wxMenuBar::Insert(
-  size_t                            nPos
-, wxMenu*                           pMenu
-, const wxString&                   rTitle
-)
+bool wxMenuBar::Insert( size_t          nPos,
+                        wxMenu*         pMenu,
+                        const wxString& rTitle )
 {
 {
-    if (!wxMenuBarBase::Insert( nPos
-                               ,pMenu
-                               ,rTitle
-                              ))
-        return FALSE;
+    wxString sTitle = wxPMTextToLabel(rTitle);
 
 
-    m_titles.Insert( rTitle
-                    ,nPos
-                   );
+    if (!wxMenuBarBase::Insert( nPos, pMenu, sTitle ))
+        return false;
 
 
-    pMenu->Attach(this);
+    m_titles.Insert( sTitle, nPos );
 
     if (IsAttached())
     {
 
     if (IsAttached())
     {
-        ::WinSendMsg((HWND)m_hMenu, MM_INSERTITEM, (MPARAM)&pMenu->m_vMenuData, (MPARAM)rTitle.c_str());
+        pMenu->m_vMenuData.iPosition = (SHORT)nPos;
+        ::WinSendMsg( (HWND)m_hMenu
+                     ,MM_INSERTITEM
+                     ,(MPARAM)&pMenu->m_vMenuData
+                     ,(MPARAM)sTitle.wx_str()
+                    );
 #if wxUSE_ACCEL
         if (pMenu->HasAccels())
         {
 #if wxUSE_ACCEL
         if (pMenu->HasAccels())
         {
@@ -825,28 +966,28 @@ bool wxMenuBar::Insert(
 #endif // wxUSE_ACCEL
         Refresh();
     }
 #endif // wxUSE_ACCEL
         Refresh();
     }
-    return TRUE;
+
+    return true;
 } // end of wxMenuBar::Insert
 
 } // end of wxMenuBar::Insert
 
-bool wxMenuBar::Append(
-  wxMenu*                           pMenu
-, const wxString&                   rTitle
-)
+bool wxMenuBar::Append( wxMenu* pMenu,
+                        const wxString& rsTitle )
 {
 {
-    WXHMENU                         hSubmenu = pMenu ? pMenu->GetHMenu() : 0;
+    WXHMENU hSubmenu = pMenu ? pMenu->GetHMenu() : 0;
 
 
-    wxCHECK_MSG(hSubmenu, FALSE, wxT("can't append invalid menu to menubar"));
+    wxCHECK_MSG(hSubmenu, false, wxT("can't append invalid menu to menubar"));
 
 
-    if (!wxMenuBarBase::Append(pMenu, rTitle))
-        return FALSE;
+    wxString sTitle = wxPMTextToLabel(rsTitle);
 
 
-    pMenu->Attach(this);
-    m_titles.Add(rTitle);
+    if (!wxMenuBarBase::Append(pMenu, sTitle))
+        return false;
+
+    m_titles.Add(sTitle);
 
     if ( IsAttached() )
     {
         pMenu->m_vMenuData.iPosition = MIT_END;
 
     if ( IsAttached() )
     {
         pMenu->m_vMenuData.iPosition = MIT_END;
-        ::WinSendMsg((HWND)m_hMenu, MM_INSERTITEM, (MPARAM)&pMenu->m_vMenuData, (MPARAM)rTitle.c_str());
+        ::WinSendMsg((HWND)m_hMenu, MM_INSERTITEM, (MPARAM)&pMenu->m_vMenuData, (MPARAM)sTitle.wx_str());
 #if wxUSE_ACCEL
         if (pMenu->HasAccels())
         {
 #if wxUSE_ACCEL
         if (pMenu->HasAccels())
         {
@@ -858,7 +999,7 @@ bool wxMenuBar::Append(
 #endif // wxUSE_ACCEL
         Refresh();
     }
 #endif // wxUSE_ACCEL
         Refresh();
     }
-    return TRUE;
+    return true;
 } // end of wxMenuBar::Append
 
 wxMenu* wxMenuBar::Remove(
 } // end of wxMenuBar::Append
 
 wxMenu* wxMenuBar::Remove(
@@ -871,16 +1012,23 @@ wxMenu* wxMenuBar::Remove(
     if (!pMenu)
         return NULL;
 
     if (!pMenu)
         return NULL;
 
-    nId = SHORT1FROMMR(::WinSendMsg((HWND)GetHmenu(), MM_ITEMIDFROMPOSITION, MPFROMSHORT(nPos), (MPARAM)0));
+    nId = SHORT1FROMMR(::WinSendMsg( (HWND)GetHmenu()
+                                    ,MM_ITEMIDFROMPOSITION
+                                    ,MPFROMSHORT(nPos)
+                                    ,(MPARAM)0)
+                                   );
     if (nId == MIT_ERROR)
     {
     if (nId == MIT_ERROR)
     {
-        wxLogLastError("LogLastError");
+        wxLogLastError(wxT("LogLastError"));
         return NULL;
     }
     if (IsAttached())
     {
         return NULL;
     }
     if (IsAttached())
     {
-        ::WinSendMsg((HWND)GetHmenu(), MM_DELETEITEM, MPFROM2SHORT(nId, TRUE), (MPARAM)0);
-        pMenu->Detach();
+        ::WinSendMsg( (HWND)GetHmenu()
+                     ,MM_REMOVEITEM
+                     ,MPFROM2SHORT(nId, TRUE)
+                     ,(MPARAM)0
+                    );
 
 #if wxUSE_ACCEL
         if (pMenu->HasAccels())
 
 #if wxUSE_ACCEL
         if (pMenu->HasAccels())
@@ -893,7 +1041,7 @@ wxMenu* wxMenuBar::Remove(
 #endif // wxUSE_ACCEL
         Refresh();
     }
 #endif // wxUSE_ACCEL
         Refresh();
     }
-    m_titles.Remove(nPos);
+    m_titles.RemoveAt(nPos);
     return pMenu;
 } // end of wxMenuBar::Remove
 
     return pMenu;
 } // end of wxMenuBar::Remove
 
@@ -907,10 +1055,10 @@ void wxMenuBar::RebuildAccelTable()
     size_t                          nAccelCount = 0;
     size_t                          i;
     size_t                          nCount = GetMenuCount();
     size_t                          nAccelCount = 0;
     size_t                          i;
     size_t                          nCount = GetMenuCount();
-
-    for (i = 0; i < nCount; i++)
+    wxMenuList::iterator it;
+    for (i = 0, it = m_menus.begin(); i < nCount; i++, it++)
     {
     {
-        nAccelCount += m_menus[i]->GetAccelCount();
+        nAccelCount += (*it)->GetAccelCount();
     }
 
     if (nAccelCount)
     }
 
     if (nAccelCount)
@@ -918,9 +1066,9 @@ void wxMenuBar::RebuildAccelTable()
         wxAcceleratorEntry*         pAccelEntries = new wxAcceleratorEntry[nAccelCount];
 
         nAccelCount = 0;
         wxAcceleratorEntry*         pAccelEntries = new wxAcceleratorEntry[nAccelCount];
 
         nAccelCount = 0;
-        for (i = 0; i < nCount; i++)
+        for (i = 0, it = m_menus.begin(); i < nCount; i++, it++)
         {
         {
-            nAccelCount += m_menus[i]->CopyAccels(&pAccelEntries[nAccelCount]);
+            nAccelCount += (*it)->CopyAccels(&pAccelEntries[nAccelCount]);
         }
         m_vAccelTable = wxAcceleratorTable( nAccelCount
                                            ,pAccelEntries
         }
         m_vAccelTable = wxAcceleratorTable( nAccelCount
                                            ,pAccelEntries
@@ -935,11 +1083,20 @@ void wxMenuBar::Attach(
   wxFrame*                          pFrame
 )
 {
   wxFrame*                          pFrame
 )
 {
-    wxASSERT_MSG( !IsAttached(), wxT("menubar already attached!") );
-    m_pMenuBarFrame = pFrame;
+    wxMenuBarBase::Attach(pFrame);
 
 #if wxUSE_ACCEL
     RebuildAccelTable();
 
 #if wxUSE_ACCEL
     RebuildAccelTable();
+    //
+    // Ensure the accelerator table is set to the frame (not the client!)
+    //
+    if (!::WinSetAccelTable( vHabmain
+                            ,m_vAccelTable.GetHACCEL()
+                            ,(HWND)pFrame->GetFrame()
+                           ))
+    {
+        wxLogLastError(wxT("WinSetAccelTable"));
+    }
 #endif // wxUSE_ACCEL
 } // end of wxMenuBar::Attach
 
 #endif // wxUSE_ACCEL
 } // end of wxMenuBar::Attach
 
@@ -947,7 +1104,7 @@ void wxMenuBar::Detach()
 {
     ::WinDestroyWindow((HWND)m_hMenu);
     m_hMenu = (WXHMENU)NULL;
 {
     ::WinDestroyWindow((HWND)m_hMenu);
     m_hMenu = (WXHMENU)NULL;
-    m_pMenuBarFrame = NULL;
+    m_menuBarFrame = NULL;
 } // end of wxMenuBar::Detach
 
 // ---------------------------------------------------------------------------
 } // end of wxMenuBar::Detach
 
 // ---------------------------------------------------------------------------
@@ -963,14 +1120,14 @@ int wxMenuBar::FindMenuItem(
 ) const
 {
     wxString                        sMenuLabel = wxStripMenuCodes(rMenuString);
 ) const
 {
     wxString                        sMenuLabel = wxStripMenuCodes(rMenuString);
-    size_t                          nCount = GetMenuCount();
-
-    for (size_t i = 0; i < nCount; i++)
+    size_t                          nCount = GetMenuCount(), i;
+    wxMenuList::const_iterator it;
+    for (i = 0, it = m_menus.begin(); i < nCount; i++, it++)
     {
         wxString                    sTitle = wxStripMenuCodes(m_titles[i]);
 
         if (rMenuString == sTitle)
     {
         wxString                    sTitle = wxStripMenuCodes(m_titles[i]);
 
         if (rMenuString == sTitle)
-            return m_menus[i]->FindItem(rItemString);
+            return (*it)->FindItem(rItemString);
     }
     return wxNOT_FOUND;
 } // end of wxMenuBar::FindMenuItem
     }
     return wxNOT_FOUND;
 } // end of wxMenuBar::FindMenuItem
@@ -984,14 +1141,35 @@ wxMenuItem* wxMenuBar::FindItem(
         *ppItemMenu = NULL;
 
     wxMenuItem*                     pItem = NULL;
         *ppItemMenu = NULL;
 
     wxMenuItem*                     pItem = NULL;
-    size_t                          nCount = GetMenuCount();
-
-    for (size_t i = 0; !pItem && (i < nCount); i++)
+    size_t                          nCount = GetMenuCount(), i;
+    wxMenuList::const_iterator it;
+    for (i = 0, it = m_menus.begin(); !pItem && (i < nCount); i++, it++)
     {
     {
-        pItem = m_menus[i]->FindItem( nId
-                                     ,ppItemMenu
-                                    );
+        pItem = (*it)->FindItem( nId
+                                ,ppItemMenu
+                               );
     }
     return pItem;
 } // end of wxMenuBar::FindItem
 
     }
     return pItem;
 } // end of wxMenuBar::FindItem
 
+wxMenuItem* wxMenuBar::FindItem(
+  int                               nId
+, ULONG                             hItem
+, wxMenu**                          ppItemMenu
+) const
+{
+    if (ppItemMenu)
+        *ppItemMenu = NULL;
+
+    wxMenuItem*                     pItem = NULL;
+    size_t                          nCount = GetMenuCount(), i;
+    wxMenuList::const_iterator it;
+    for (i = 0, it = m_menus.begin(); !pItem && (i < nCount); i++, it++)
+    {
+        pItem = (*it)->FindItem( nId
+                                ,hItem
+                                ,ppItemMenu
+                               );
+    }
+    return pItem;
+} // end of wxMenuBar::FindItem
wxWidgets (Impactor)