Make it LPNM_UPDOWN, not LPNMUPDOWN, in Borland C++

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

diff --git a/src/msw/menu.cpp b/src/msw/menu.cpp
index 345e930578c455374f137fdf15d2e4d59083eadd..019415a9e85b9f9b3ab7a2da9591a1ee2dd0d330 100644 (file)
--- a/src/msw/menu.cpp
+++ b/src/msw/menu.cpp
@@ -9,6 +9,14 @@
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 

+// ===========================================================================
+// declarations
+// ===========================================================================
+
+// ---------------------------------------------------------------------------
+// headers
+// ---------------------------------------------------------------------------
+

 #ifdef __GNUG__
     #pragma implementation "menu.h"
 #endif
 #ifdef __GNUG__
     #pragma implementation "menu.h"
 #endif


@@ -24,6 +32,7 @@
     #include "wx/frame.h"
     #include "wx/menu.h"
     #include "wx/utils.h"
     #include "wx/frame.h"
     #include "wx/menu.h"
     #include "wx/utils.h"

+    #include "wx/intl.h"

 #endif
 
 #if wxUSE_OWNER_DRAWN
 #endif
 
 #if wxUSE_OWNER_DRAWN


@@ -60,19 +69,18 @@ static const int idMenuTitle = -2;
     IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxEvtHandler)
 #endif
 
     IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxEvtHandler)
 #endif
 

-// convenience macro
-#define GetHMENU()      ((HMENU)GetHMenu())
-

 // ============================================================================
 // implementation
 // ============================================================================
 
 // ============================================================================
 // implementation
 // ============================================================================
 

-// Menus
+// ---------------------------------------------------------------------------
+// wxMenu construction, adding and removing menu items
+// ---------------------------------------------------------------------------

 
 // Construct a menu with optional title (then use append)
 
 // Construct a menu with optional title (then use append)

-wxMenu::wxMenu(const wxString& title, const wxFunction func)
-      : m_title(title)
+void wxMenu::Init(const wxString& title, const wxFunction func )

 {
 {

+    m_title = title;

     m_parent = NULL;
     m_eventHandler = this;
     m_pInvokingWindow = NULL;
     m_parent = NULL;
     m_eventHandler = this;
     m_pInvokingWindow = NULL;


@@ -96,40 +104,23 @@ wxMenu::wxMenu(const wxString& title, const wxFunction func)
 // The wxWindow destructor will take care of deleting the submenus.
 wxMenu::~wxMenu()
 {
 // The wxWindow destructor will take care of deleting the submenus.
 wxMenu::~wxMenu()
 {

-    if (m_hMenu)
-        DestroyMenu((HMENU) m_hMenu);
-    m_hMenu = 0;
+    // free Windows resources
+    if ( m_hMenu )
+    {
+        ::DestroyMenu((HMENU)m_hMenu);
+        m_hMenu = 0;
+    }

 
 

-    // Windows seems really bad on Menu de-allocation...
-    // After many try, here is what I do: RemoveMenu() will ensure
-    // that popup are "disconnected" from their parent; then call
-    // delete method on each child (which in turn do a recursive job),
-    // and finally, DestroyMenu()
-    //
-    // With that, BoundCheckers is happy, and no complaints...
-    /*
-       int N = 0 ;
-       if (m_hMenu)
-       N = GetMenuItemCount(m_hMenu);
-       int i;
-       for (i = N-1; i >= 0; i--)
-       RemoveMenu(m_hMenu, i, MF_BYPOSITION);
-     */
-
-    // How is deleting submenus in this loop any different from deleting
-    // the submenus in the children list, via ~wxWindow ?
-    // I'll reinstate this deletion for now and remove addition
-    // from children list (which doesn't exist now)
-    // Julian 1/3/97
+    // delete submenus

     wxNode *node = m_menuItems.First();
     wxNode *node = m_menuItems.First();

-    while (node)
+    while ( node )

     {
         wxMenuItem *item = (wxMenuItem *)node->Data();
 
         // Delete child menus.
         // Beware: they must not be appended to children list!!!
         // (because order of delete is significant)
     {
         wxMenuItem *item = (wxMenuItem *)node->Data();
 
         // Delete child menus.
         // Beware: they must not be appended to children list!!!
         // (because order of delete is significant)

-        if (item->GetSubMenu())
+        if ( item->IsSubMenu() )

             item->DeleteSubMenu();
 
         wxNode *next = node->Next();
             item->DeleteSubMenu();
 
         wxNode *next = node->Next();


@@ -137,27 +128,85 @@ wxMenu::~wxMenu()
         delete node;
         node = next;
     }
         delete node;
         node = next;
     }

-    /*
-       if (m_hMenu)
-       DestroyMenu(m_hMenu);
-       m_hMenu = 0;
-     */

 }
 
 void wxMenu::Break()
 {
 }
 
 void wxMenu::Break()
 {

-    m_doBreak = TRUE ;
+    m_doBreak = TRUE;

 }
 
 // function appends a new item or submenu to the menu
 void wxMenu::Append(wxMenuItem *pItem)
 {
 }
 
 // function appends a new item or submenu to the menu
 void wxMenu::Append(wxMenuItem *pItem)
 {

-    wxCHECK_RET( pItem != NULL, "can't append NULL item to the menu" );
+    wxCHECK_RET( pItem != NULL, _T("can't append NULL item to the menu") );
+
+#if wxUSE_ACCEL
+    // check for accelerators: they are given after '\t'
+    wxString label = pItem->GetName();
+    int posTab = label.Find(_T('\t'));
+    if ( posTab != wxNOT_FOUND ) {
+        // parse the accelerator string
+        int keyCode = 0;
+        int accelFlags = wxACCEL_NORMAL;
+        wxString current;
+        for ( size_t n = (size_t)posTab + 1; n < label.Len(); n++ ) {
+            if ( (label[n] == '+') || (label[n] == '-') ) {
+                if ( current == _("ctrl") )
+                    accelFlags |= wxACCEL_CTRL;
+                else if ( current == _("alt") )
+                    accelFlags |= wxACCEL_ALT;
+                else if ( current == _("shift") )
+                    accelFlags |= wxACCEL_SHIFT;
+                else {
+                    wxLogDebug(_T("Unknown accel modifier: '%s'"),
+                               current.c_str());
+                }
+
+                current.Empty();
+            }
+            else {
+                current += wxTolower(label[n]);
+            }
+        }

 
 

-    m_menuItems.Append(pItem);
+        if ( current.IsEmpty() ) {
+            wxLogDebug(_T("No accel key found, accel string ignored."));
+        }
+        else {
+            if ( current.Len() == 1 ) {
+                // it's a letter
+                keyCode = wxToupper(current[0U]);
+            }
+            else {
+                // it should be a function key
+                if ( current[0U] == 'f' && isdigit(current[1U]) &&
+                     (current.Len() == 2 ||
+                     (current.Len() == 3 && isdigit(current[2U]))) ) {
+                    int n;
+                    wxSscanf(current.c_str() + 1, _T("%d"), &n);
+
+                    keyCode = VK_F1 + n - 1;
+                }
+                else {
+                    wxLogDebug(_T("Unrecognized accel key '%s', accel "
+                                  "string ignored."), current.c_str());
+                }
+            }
+        }
+
+        if ( keyCode ) {
+            // do add an entry
+            m_accelKeyCodes.Add(keyCode);
+            m_accelFlags.Add(accelFlags);
+            m_accelIds.Add(pItem->GetId());
+        }
+    }
+#endif // wxUSE_ACCEL

 
     UINT flags = 0;
 
 
     UINT flags = 0;
 

+    // if "Break" has just been called, insert a menu break before this item
+    // (and don't forget to reset the flag)

     if ( m_doBreak ) {
         flags |= MF_MENUBREAK;
         m_doBreak = FALSE;
     if ( m_doBreak ) {
         flags |= MF_MENUBREAK;
         m_doBreak = FALSE;


@@ -167,18 +216,18 @@ void wxMenu::Append(wxMenuItem *pItem)
         flags |= MF_SEPARATOR;
     }
 
         flags |= MF_SEPARATOR;
     }
 

-    // id is the numeric id for normal menu items and HMENU for submenus
+    // id is the numeric id for normal menu items and HMENU for submenus as
+    // required by ::AppendMenu() API

     UINT id;
     UINT id;

-    wxMenu *SubMenu = pItem->GetSubMenu();
-    if ( SubMenu != NULL ) {
-        wxASSERT( SubMenu->m_hMenu != (WXHMENU) NULL );
-
-        id = (UINT)SubMenu->m_hMenu;
+    wxMenu *submenu = pItem->GetSubMenu();
+    if ( submenu != NULL ) {
+        wxASSERT( submenu->GetHMenu() != (WXHMENU) NULL );

 
 

-        SubMenu->m_topLevelMenu = m_topLevelMenu;
-        SubMenu->m_parent       = this;
-        SubMenu->m_savehMenu    = (WXHMENU)id;
-        SubMenu->m_hMenu        = 0;
+        id = (UINT)submenu->GetHMenu();
+        submenu->m_topLevelMenu = m_topLevelMenu;
+        submenu->m_parent       = this;
+        submenu->m_savehMenu    = (WXHMENU)id;
+        submenu->m_hMenu        = 0;

 
         flags |= MF_POPUP;
     }
 
         flags |= MF_POPUP;
     }


@@ -186,34 +235,47 @@ void wxMenu::Append(wxMenuItem *pItem)
         id = pItem->GetId();
     }
 
         id = pItem->GetId();
     }
 

-    LPCSTR pData;
+    LPCTSTR pData;

 
 #if wxUSE_OWNER_DRAWN
     if ( pItem->IsOwnerDrawn() ) {  // want to get {Measure|Draw}Item messages?
         // item draws itself, pass pointer to it in data parameter
         flags |= MF_OWNERDRAW;
 
 #if wxUSE_OWNER_DRAWN
     if ( pItem->IsOwnerDrawn() ) {  // want to get {Measure|Draw}Item messages?
         // item draws itself, pass pointer to it in data parameter
         flags |= MF_OWNERDRAW;

-        pData = (LPCSTR)pItem;
+        pData = (LPCTSTR)pItem;

     }
     else
 #endif
     {
         // menu is just a normal string (passed in data parameter)
         flags |= MF_STRING;
     }
     else
 #endif
     {
         // menu is just a normal string (passed in data parameter)
         flags |= MF_STRING;

-        pData = pItem->GetName();
+        pData = label;

     }
 
     }
 

-    // visually select the menu title
-    if ( id == idMenuTitle )
-    {
-        // TODO use SetMenuItemInfo(MFS_DEFAULT) to put it in bold face
-    }
-
-    if ( !AppendMenu(GetHMENU(), flags, id, pData) )
+    if ( !::AppendMenu(GetHmenu(), flags, id, pData) )

     {
         wxLogLastError("AppendMenu");
     }
     {
         wxLogLastError("AppendMenu");
     }

+    else
+    {
+#ifdef __WIN32__
+        if ( id == idMenuTitle )
+        {
+            // visually select the menu title
+            MENUITEMINFO mii;
+            mii.cbSize = sizeof(mii);
+            mii.fMask = MIIM_STATE;
+            mii.fState = MFS_DEFAULT;
+
+            if ( !SetMenuItemInfo(GetHmenu(), (unsigned)id, FALSE, &mii) )
+            {
+                wxLogLastError(_T("SetMenuItemInfo"));
+            }
+        }
+#endif // __WIN32__

 
 

-    m_noItems++;
+        m_menuItems.Append(pItem);
+        m_noItems++;
+    }

 }
 
 void wxMenu::AppendSeparator()
 }
 
 void wxMenu::AppendSeparator()


@@ -222,20 +284,25 @@ void wxMenu::AppendSeparator()
 }
 
 // Pullright item
 }
 
 // Pullright item

-void wxMenu::Append(int Id, const wxString& label,
-                    wxMenu *SubMenu, const wxString& helpString)
+void wxMenu::Append(int id,
+                    const wxString& label,
+                    wxMenu *SubMenu,
+                    const wxString& helpString)

 {
 {

-    Append(new wxMenuItem(this, Id, label, helpString, FALSE, SubMenu));
+    Append(new wxMenuItem(this, id, label, helpString, FALSE, SubMenu));

 }
 
 // Ordinary menu item
 }
 
 // Ordinary menu item

-void wxMenu::Append(int Id, const wxString& label,
-        const wxString& helpString, bool checkable)
+void wxMenu::Append(int id,
+                    const wxString& label,
+                    const wxString& helpString,
+                    bool checkable)

 {
     // 'checkable' parameter is useless for Windows.
 {
     // 'checkable' parameter is useless for Windows.

-    Append(new wxMenuItem(this, Id, label, helpString, checkable));
+    Append(new wxMenuItem(this, id, label, helpString, checkable));

 }
 
 }
 

+// delete item by id

 void wxMenu::Delete(int id)
 {
     wxMenuItem *item = NULL;
 void wxMenu::Delete(int id)
 {
     wxMenuItem *item = NULL;


@@ -248,9 +315,9 @@ void wxMenu::Delete(int id)
             break;
     }
 
             break;
     }
 

-    wxCHECK_RET( node, "wxMenu::Delete(): item doesn't exist" );
+    wxCHECK_RET( node, _T("wxMenu::Delete(): item doesn't exist") );

 
 

-    HMENU menu = GetHMENU();
+    HMENU menu = GetHmenu();

 
     wxMenu *pSubMenu = item->GetSubMenu();
     if ( pSubMenu != NULL ) {
 
     wxMenu *pSubMenu = item->GetSubMenu();
     if ( pSubMenu != NULL ) {


@@ -273,44 +340,114 @@ void wxMenu::Delete(int id)
     delete item;
 }
 
     delete item;
 }
 

-void wxMenu::Enable(int Id, bool Flag)
+#if wxUSE_ACCEL
+
+// ---------------------------------------------------------------------------
+// accelerator helpers
+// ---------------------------------------------------------------------------
+
+// create the wxAcceleratorEntries for our accels and put them into provided
+// array - return the number of accels we have
+size_t wxMenu::CopyAccels(wxAcceleratorEntry *accels) const
+{
+    size_t count = GetAccelCount();
+    for ( size_t n = 0; n < count; n++ )
+    {
+        (*accels++).Set(m_accelFlags[n], m_accelKeyCodes[n], m_accelIds[n]);
+    }
+
+    return count;
+}
+
+#endif // wxUSE_ACCEL
+
+// ---------------------------------------------------------------------------
+// wxMenu functions implemented in wxMenuItem
+// ---------------------------------------------------------------------------
+
+void wxMenu::Enable(int id, bool Flag)

 {
 {

-    wxMenuItem *item = FindItemForId(Id);
-    wxCHECK_RET( item != NULL, "can't enable non-existing menu item" );
+    wxMenuItem *item = FindItemForId(id);
+    wxCHECK_RET( item != NULL, _T("can't enable non-existing menu item") );

 
     item->Enable(Flag);
 }
 
 
     item->Enable(Flag);
 }
 

-bool wxMenu::IsEnabled(int Id) const
+bool wxMenu::IsEnabled(int id) const

 {
 {

-    wxMenuItem *item = FindItemForId(Id);
-    wxCHECK( item != NULL, FALSE, "invalid item id" );
+    wxMenuItem *item = FindItemForId(id);
+    wxCHECK_MSG( item != NULL, FALSE, _T("invalid item id") );

 
     return item->IsEnabled();
 }
 
 
     return item->IsEnabled();
 }
 

-void wxMenu::Check(int Id, bool Flag)
+void wxMenu::Check(int id, bool Flag)

 {
 {

-    wxMenuItem *item = FindItemForId(Id);
-    wxCHECK_RET( item != NULL, "can't get status of non-existing menu item" );
+    wxMenuItem *item = FindItemForId(id);
+    wxCHECK_RET( item != NULL, _T("can't get status of non-existing menu item") );

 
     item->Check(Flag);
 }
 
 
     item->Check(Flag);
 }
 

-bool wxMenu::IsChecked(int Id) const
+bool wxMenu::IsChecked(int id) const

 {
 {

-    wxMenuItem *item = FindItemForId(Id);
-    wxCHECK( item != NULL, FALSE, "invalid item id" );
+    wxMenuItem *item = FindItemForId(id);
+    wxCHECK_MSG( item != NULL, FALSE, _T("invalid item id") );

 
     return item->IsChecked();
 }
 
 
     return item->IsChecked();
 }
 

+void wxMenu::SetLabel(int id, const wxString& label)
+{
+    wxMenuItem *item = FindItemForId(id) ;
+    wxCHECK_RET( item, _T("wxMenu::SetLabel: no such item") );
+
+    item->SetName(label);
+}
+
+wxString wxMenu::GetLabel(int id) const
+{
+    wxString label;
+    wxMenuItem *pItem = FindItemForId(id) ;
+    if (pItem)
+        label = pItem->GetName() ;
+    else
+        wxFAIL_MSG(_T("wxMenu::GetLabel: item doesn't exist"));
+
+    return label;
+}
+
+void wxMenu::SetHelpString(int itemId, const wxString& helpString)
+{
+    wxMenuItem *item = FindItemForId (itemId);
+    if (item)
+        item->SetHelp(helpString);
+    else
+        wxFAIL_MSG(_T("wxMenu::SetHelpString: item doesn't exist"));
+}
+
+wxString wxMenu::GetHelpString (int itemId) const
+{
+    wxString help;
+    wxMenuItem *item = FindItemForId (itemId);
+    if (item)
+        help = item->GetHelp();
+    else
+        wxFAIL_MSG(_T("wxMenu::GetHelpString: item doesn't exist"));
+
+    return help;
+}
+
+// ---------------------------------------------------------------------------
+// wxMenu title
+// ---------------------------------------------------------------------------
+

 void wxMenu::SetTitle(const wxString& label)
 {
     bool hasNoTitle = m_title.IsEmpty();
     m_title = label;
 
 void wxMenu::SetTitle(const wxString& label)
 {
     bool hasNoTitle = m_title.IsEmpty();
     m_title = label;
 

-    HMENU hMenu = GetHMENU();
+    HMENU hMenu = GetHmenu();

 
     if ( hasNoTitle )
     {
 
     if ( hasNoTitle )
     {


@@ -320,7 +457,7 @@ void wxMenu::SetTitle(const wxString& label)
                              (unsigned)idMenuTitle, m_title) ||
                  !InsertMenu(hMenu, 1u, MF_BYPOSITION, (unsigned)-1, NULL) )
             {
                              (unsigned)idMenuTitle, m_title) ||
                  !InsertMenu(hMenu, 1u, MF_BYPOSITION, (unsigned)-1, NULL) )
             {

-                wxLogLastError("InsertMenu");
+                wxLogLastError(_T("InsertMenu"));

             }
         }
     }
             }
         }
     }


@@ -347,7 +484,7 @@ void wxMenu::SetTitle(const wxString& label)
         }
     }
 
         }
     }
 

-#ifndef __WIN16__
+#ifdef __WIN32__

     // put the title string in bold face
     if ( !m_title.IsEmpty() )
     {
     // put the title string in bold face
     if ( !m_title.IsEmpty() )
     {


@@ -369,51 +506,9 @@ const wxString wxMenu::GetTitle() const
     return m_title;
 }
 
     return m_title;
 }
 

-void wxMenu::SetLabel(int Id, const wxString& label)
-{
-    wxMenuItem *item = FindItemForId(Id) ;
-    if (item==NULL)
-        return;
-
-    if (item->GetSubMenu()==NULL)
-    {
-        HMENU hMenu = GetHMENU();
-
-        UINT was_flag = GetMenuState(hMenu, Id, MF_BYCOMMAND);
-        ModifyMenu(hMenu, Id, MF_BYCOMMAND | MF_STRING | was_flag, Id, label);
-    }
-    else
-    {
-        wxMenu *father = item->GetSubMenu()->m_topLevelMenu ;
-        wxNode *node = father->m_menuItems.First() ;
-        int i = 0 ;
-        while (node)
-        {
-            wxMenuItem *matched = (wxMenuItem*)node->Data() ;
-            if (matched==item)
-                break ;
-            i++ ;
-            node = node->Next() ;
-        }
-        // Here, we have the position.
-        ModifyMenu((HMENU)father->m_savehMenu,i,
-                MF_BYPOSITION|MF_STRING|MF_POPUP,
-                (UINT)item->GetSubMenu()->m_savehMenu,(const char *)label) ;
-    }
-    item->SetName(label);
-}
-
-wxString wxMenu::GetLabel(int id) const
-{
-    wxString label;
-    wxMenuItem *pItem = FindItemForId(id) ;
-    if (pItem)
-        label = pItem->GetName() ;
-    else
-        wxFAIL_MSG("wxMenu::GetLabel: item doesn't exist");
-
-    return label;
-}
+// ---------------------------------------------------------------------------
+// event processing
+// ---------------------------------------------------------------------------

 
 bool wxMenu::MSWCommand(WXUINT WXUNUSED(param), WXWORD id)
 {
 
 bool wxMenu::MSWCommand(WXUINT WXUNUSED(param), WXWORD id)
 {


@@ -432,27 +527,53 @@ bool wxMenu::MSWCommand(WXUINT WXUNUSED(param), WXWORD id)
     return TRUE;
 }
 
     return TRUE;
 }
 

+bool wxMenu::ProcessCommand(wxCommandEvent & event)
+{
+    bool processed = FALSE;
+
+    // Try a callback
+    if (m_callback)
+    {
+        (void)(*(m_callback))(*this, event);
+        processed = TRUE;
+    }
+
+    // Try the menu's event handler
+    if ( !processed && GetEventHandler())
+    {
+        processed = GetEventHandler()->ProcessEvent(event);
+    }
+
+    // Try the window the menu was popped up from (and up through the
+    // hierarchy)
+    wxWindow *win = GetInvokingWindow();
+    if ( !processed && win )
+        processed = win->GetEventHandler()->ProcessEvent(event);
+
+    return processed;
+}
+
+// ---------------------------------------------------------------------------
+// Item search
+// ---------------------------------------------------------------------------
+

 // Finds the item id matching the given string, -1 if not found.
 int wxMenu::FindItem (const wxString& itemString) const
 {
 // Finds the item id matching the given string, -1 if not found.
 int wxMenu::FindItem (const wxString& itemString) const
 {

-    // FIXME fixed size buffer
-    char buf1[200];
-    char buf2[200];
-    wxStripMenuCodes ((char *)(const char *)itemString, buf1);
-
-    for (wxNode * node = m_menuItems.First (); node; node = node->Next ())
+    wxString itemLabel = wxStripMenuCodes(itemString);
+    for ( wxNode *node = m_menuItems.First(); node; node = node->Next() )

     {
     {

-        wxMenuItem *item = (wxMenuItem *) node->Data ();
-        if (item->GetSubMenu())
+        wxMenuItem *item = (wxMenuItem *)node->Data();
+        if ( item->IsSubMenu() )

         {
             int ans = item->GetSubMenu()->FindItem(itemString);
         {
             int ans = item->GetSubMenu()->FindItem(itemString);

-            if (ans > -1)
+            if ( ans != wxNOT_FOUND )

                 return ans;
         }
                 return ans;
         }

-        if ( !item->IsSeparator() )
+        else if ( !item->IsSeparator() )

         {
         {

-            wxStripMenuCodes((char *)item->GetName().c_str(), buf2);
-            if (strcmp(buf1, buf2) == 0)
+            wxString label = wxStripMenuCodes(item->GetName());
+            if ( itemLabel == label )

                 return item->GetId();
         }
     }
                 return item->GetId();
         }
     }


@@ -462,100 +583,61 @@ int wxMenu::FindItem (const wxString& itemString) const
 
 wxMenuItem *wxMenu::FindItemForId(int itemId, wxMenu ** itemMenu) const
 {
 
 wxMenuItem *wxMenu::FindItemForId(int itemId, wxMenu ** itemMenu) const
 {

-    if (itemMenu)
+    if ( itemMenu )

         *itemMenu = NULL;
         *itemMenu = NULL;

-    for (wxNode * node = m_menuItems.First (); node; node = node->Next ())
+
+    wxMenuItem *item = NULL;
+    for ( wxNode *node = m_menuItems.First(); node && !item; node = node->Next() )

     {
     {

-        wxMenuItem *item = (wxMenuItem *) node->Data ();
+        item = (wxMenuItem *)node->Data();

 
 

-        if (item->GetId() == itemId)
+        if ( item->GetId() == itemId )

         {
             if (itemMenu)
         {
             if (itemMenu)

-                *itemMenu = (wxMenu *) this;
-            return item;
+                *itemMenu = (wxMenu *)this;

         }
         }

-
-        if (item->GetSubMenu())
+        else if ( item->IsSubMenu() )

         {
         {

-            wxMenuItem *ans = item->GetSubMenu()->FindItemForId (itemId, itemMenu);
-            if (ans)
-                return ans;
+            item = item->GetSubMenu()->FindItemForId(itemId, itemMenu);
+        }
+        else
+        {
+            // don't exit the loop
+            item = NULL;

         }
     }
 
         }
     }
 

-    if (itemMenu)
-        *itemMenu = NULL;
-    return NULL;
+    return item;

 }
 
 }
 

-void wxMenu::SetHelpString(int itemId, const wxString& helpString)
-{
-    wxMenuItem *item = FindItemForId (itemId);
-    if (item)
-        item->SetHelp(helpString);
-    else
-        wxFAIL_MSG("wxMenu::SetHelpString: item doesn't exist");
-}
+// ---------------------------------------------------------------------------
+// other
+// ---------------------------------------------------------------------------

 
 

-wxString wxMenu::GetHelpString (int itemId) const
-{
-    wxString help;
-    wxMenuItem *item = FindItemForId (itemId);
-    if (item)
-        help = item->GetHelp();
-    else
-        wxFAIL_MSG("wxMenu::GetHelpString: item doesn't exist");
-
-    return help;
-}
-
-void wxMenu::ProcessCommand(wxCommandEvent & event)
+void wxMenu::Attach(wxMenuBar *menubar)

 {
 {

-    bool processed = FALSE;
-
-    // Try a callback
-    if (m_callback)
-    {
-        (void)(*(m_callback))(*this, event);
-        processed = TRUE;
-    }
+    // menu can be in at most one menubar because otherwise they would both
+    // delete the menu pointer
+    wxASSERT_MSG( !m_menuBar, _T("menu belongs to 2 menubars, expect a crash") );

 
 

-    // Try the menu's event handler
-    if ( !processed && GetEventHandler())
-    {
-        processed = GetEventHandler()->ProcessEvent(event);
-    }
-
-    // Try the window the menu was popped up from (and up through the
-    // hierarchy)
-    wxWindow *win = GetInvokingWindow();
-    if ( !processed && win )
-        processed = win->GetEventHandler()->ProcessEvent(event);
+    m_menuBar = menubar;
+    m_savehMenu = m_hMenu;
+    m_hMenu = 0;

 }
 
 }
 

-bool wxWindow::PopupMenu(wxMenu *menu, int x, int y)
+void wxMenu::Detach()

 {
 {

-    menu->SetInvokingWindow(this);
-    menu->UpdateUI();
-
-    HWND hWnd = (HWND) GetHWND();
-    HMENU hMenu = (HMENU)menu->m_hMenu;
-    POINT point;
-    point.x = x;
-    point.y = y;
-    ::ClientToScreen(hWnd, &point);
-    wxCurrentPopupMenu = menu;
-    ::TrackPopupMenu(hMenu, TPM_RIGHTBUTTON, point.x, point.y, 0, hWnd, NULL);
-    wxYield();
-    wxCurrentPopupMenu = NULL;
+    wxASSERT_MSG( m_menuBar, _T("can't detach menu if it's not attached") );

 
 

-    menu->SetInvokingWindow(NULL);
-
-    return TRUE;
+    m_hMenu = m_savehMenu;
+    m_savehMenu = 0;

 }
 
 }
 

+// ---------------------------------------------------------------------------

 // Menu Bar
 // Menu Bar

-wxMenuBar::wxMenuBar()
+// ---------------------------------------------------------------------------
+
+void wxMenuBar::Init()

 {
     m_eventHandler = this;
     m_menuCount = 0;
 {
     m_eventHandler = this;
     m_menuCount = 0;


@@ -565,83 +647,94 @@ wxMenuBar::wxMenuBar()
     m_hMenu = 0;
 }
 
     m_hMenu = 0;
 }
 

+wxMenuBar::wxMenuBar()
+{
+    Init();
+}
+

 wxMenuBar::wxMenuBar( long WXUNUSED(style) )
 {
 wxMenuBar::wxMenuBar( long WXUNUSED(style) )
 {

-    m_eventHandler = this;
-    m_menuCount = 0;
-    m_menus = NULL;
-    m_titles = NULL;
-    m_menuBarFrame = NULL;
-    m_hMenu = 0;
+    Init();

 }
 
 }
 

-wxMenuBar::wxMenuBar(int N, wxMenu *Menus[], const wxString Titles[])
+wxMenuBar::wxMenuBar(int count, wxMenu *menus[], const wxString titles[])

 {
 {

-    m_eventHandler = this;
-    m_menuCount = N;
-    m_menus = Menus;
-    m_titles = new wxString[N];
+    Init();
+
+    m_menuCount = count;
+    m_menus = menus;
+    m_titles = new wxString[count];
+

     int i;
     int i;

-    for ( i = 0; i < N; i++ )
-        m_titles[i] = Titles[i];
-    m_menuBarFrame = NULL;
-    for (i = 0; i < N; i++)
-        m_menus[i]->m_menuBar = (wxMenuBar *) this;
+    for ( i = 0; i < count; i++ )
+        m_titles[i] = titles[i];

 
 

-    m_hMenu = 0;
+    for ( i = 0; i < count; i++ )
+        m_menus[i]->Attach(this);

 }
 
 wxMenuBar::~wxMenuBar()
 {
 }
 
 wxMenuBar::~wxMenuBar()
 {

-    // In fact, don't want menu to be destroyed before MDI
-    // shuffling has taken place. Let it be destroyed
-    // automatically when the window is destroyed.
+    for ( int i = 0; i < m_menuCount; i++ )
+    {
+        delete m_menus[i];
+    }
+
+    delete[] m_menus;
+    delete[] m_titles;
+}
+
+// ---------------------------------------------------------------------------
+// wxMenuBar helpers
+// ---------------------------------------------------------------------------
+
+void wxMenuBar::Refresh()
+{
+    wxCHECK_RET( m_menuBarFrame, _T("can't refresh a menubar withotu a frame") );

 
 

-    //  DestroyMenu(menu);
-    //  m_hMenu = NULL;
+    DrawMenuBar((HWND)m_menuBarFrame->GetHWND()) ;
+}

 
 

-    int i;
-    /*
-    // See remarks in ::~wxMenu() method
-    // BEWARE - this may interfere with MDI fixes, so
-    // may need to remove
-    int N = 0 ;
+WXHMENU wxMenuBar::Create()
+{
+    wxCHECK_MSG( !m_hMenu, TRUE, _T("menubar already created") );
+
+    m_hMenu = (WXHMENU)::CreateMenu();

 
 

-    if (m_menuBarFrame && ((m_menuBarFrame->GetWindowStyleFlag() & wxSDI) == wxSDI))
+    if ( !m_hMenu )

     {
     {

-    if (menu)
-    N = GetMenuItemCount(menu) ;
-    for (i = N-1; i >= 0; i--)
-    RemoveMenu(menu, i, MF_BYPOSITION);
+        wxLogLastError("CreateMenu");

     }
     }

-     */
-    for (i = 0; i < m_menuCount; i++)
+    else

     {
     {

-        delete m_menus[i];
+        for ( int i = 0; i < m_menuCount; i++ )
+        {
+            if ( !::AppendMenu((HMENU)m_hMenu, MF_POPUP | MF_STRING,
+                               (UINT)m_menus[i]->GetHMenu(),
+                               m_titles[i]) )
+            {
+                wxLogLastError("AppendMenu");
+            }
+        }

     }
     }

-    delete[] m_menus;
-    delete[] m_titles;

 
 

-    /* Don't destroy menu here, in case we're MDI and
-       need to do some shuffling with VALID menu handles.
-       if (menu)
-       DestroyMenu(menu);
-       m_hMenu = 0;
-     */
+    return m_hMenu;

 }
 
 }
 

+// ---------------------------------------------------------------------------
+// wxMenuBar functions forwarded to wxMenuItem
+// ---------------------------------------------------------------------------
+

 // Must only be used AFTER menu has been attached to frame,
 // otherwise use individual menus to enable/disable items
 // Must only be used AFTER menu has been attached to frame,
 // otherwise use individual menus to enable/disable items

-void wxMenuBar::Enable(int Id, bool enable)
+void wxMenuBar::Enable(int id, bool enable)

 {
 {

-    int flag = enable ? MF_ENABLED : MF_GRAYED;
-

     wxMenu *itemMenu = NULL;
     wxMenu *itemMenu = NULL;

-    wxMenuItem *item = FindItemForId(Id, &itemMenu) ;
+    wxMenuItem *item = FindItemForId(id, &itemMenu) ;

 
 

-    wxCHECK_RET( item, "attempt to enable an item which doesn't exist" );
+    wxCHECK_RET( item, _T("attempt to enable an item which doesn't exist") );

 
 

-    EnableMenuItem(GetHMENU(), Id, MF_BYCOMMAND | flag);
+    item->Enable(enable);

 }
 
 void wxMenuBar::EnableTop(int pos, bool enable)
 }
 
 void wxMenuBar::EnableTop(int pos, bool enable)


@@ -649,132 +742,188 @@ void wxMenuBar::EnableTop(int pos, bool enable)
     int flag = enable ? MF_ENABLED : MF_GRAYED;;
 
     EnableMenuItem((HMENU)m_hMenu, pos, MF_BYPOSITION | flag);
     int flag = enable ? MF_ENABLED : MF_GRAYED;;
 
     EnableMenuItem((HMENU)m_hMenu, pos, MF_BYPOSITION | flag);

-    DrawMenuBar((HWND) m_menuBarFrame->GetHWND()) ;

 }
 
 // Must only be used AFTER menu has been attached to frame,
 // otherwise use individual menus
 }
 
 // Must only be used AFTER menu has been attached to frame,
 // otherwise use individual menus

-void wxMenuBar::Check(int Id, bool check)
+void wxMenuBar::Check(int id, bool check)

 {
     wxMenu *itemMenu = NULL;
 {
     wxMenu *itemMenu = NULL;

-    wxMenuItem *item = FindItemForId(Id, &itemMenu) ;
+    wxMenuItem *item = FindItemForId(id, &itemMenu) ;

 
 

-    wxCHECK_RET( item, "attempt to check an item which doesn't exist" );
-    wxCHECK_RET( item->IsCheckable(), "attempt to check an uncheckable item" );
+    wxCHECK_RET( item, _T("attempt to check an item which doesn't exist") );
+    wxCHECK_RET( item->IsCheckable(), _T("attempt to check an uncheckable item") );

 
 

-    int flag = check ? MF_CHECKED : MF_UNCHECKED;
-    CheckMenuItem(GetHMENU(), Id, MF_BYCOMMAND | flag);
+    item->Check(check);

 }
 
 }
 

-bool wxMenuBar::IsChecked(int Id) const
+bool wxMenuBar::IsChecked(int id) const

 {
     wxMenu *itemMenu = NULL;
 {
     wxMenu *itemMenu = NULL;

-    wxMenuItem *item = FindItemForId(Id, &itemMenu) ;
+    wxMenuItem *item = FindItemForId(id, &itemMenu) ;

 
 

-    wxCHECK_MSG( item, FALSE, "wxMenuItem::IsChecked(): no such item" );
+    wxCHECK_MSG( item, FALSE, _T("wxMenuBar::IsChecked(): no such item") );

 
 

-    int flag = ::GetMenuState(GetHMENU(), Id, MF_BYCOMMAND);
+    int flag = ::GetMenuState(GetHmenuOf(itemMenu), id, MF_BYCOMMAND);

 
     return (flag & MF_CHECKED) != 0;
 }
 
 
     return (flag & MF_CHECKED) != 0;
 }
 

-bool wxMenuBar::IsEnabled(int Id) const
+bool wxMenuBar::IsEnabled(int id) const

 {
     wxMenu *itemMenu = NULL;
 {
     wxMenu *itemMenu = NULL;

-    wxMenuItem *item = FindItemForId(Id, &itemMenu) ;
+    wxMenuItem *item = FindItemForId(id, &itemMenu) ;

 
 

-    wxCHECK_MSG( item, FALSE, "wxMenuItem::IsEnabled(): no such item" );
+    wxCHECK_MSG( item, FALSE, _T("wxMenuBar::IsEnabled(): no such item") );

 
 

-    int flag = ::GetMenuState(GetHMENU(), Id, MF_BYCOMMAND) ;
+    int flag = ::GetMenuState(GetHmenuOf(itemMenu), id, MF_BYCOMMAND) ;

 
     return (flag & MF_ENABLED) != 0;
 }
 
 
     return (flag & MF_ENABLED) != 0;
 }
 

-void wxMenuBar::SetLabel(int Id, const wxString& label)
+void wxMenuBar::SetLabel(int id, const wxString& label)

 {
     wxMenu *itemMenu = NULL;
 {
     wxMenu *itemMenu = NULL;

-    wxMenuItem *item = FindItemForId(Id, &itemMenu) ;
+    wxMenuItem *item = FindItemForId(id, &itemMenu) ;

 
 

-    if (!item)
-        return;
+    wxCHECK_RET( item, _T("wxMenuBar::SetLabel(): no such item") );
+
+    item->SetName(label);
+}
+
+wxString wxMenuBar::GetLabel(int id) const
+{
+    wxMenu *itemMenu = NULL;
+    wxMenuItem *item = FindItemForId(id, &itemMenu) ;
+
+    wxCHECK_MSG( item, _T(""), _T("wxMenuBar::GetLabel(): no such item") );

 
 

-    HMENU hMenu = GetHMENU();
-    UINT was_flag = ::GetMenuState(hMenu, Id, MF_BYCOMMAND);
-    ::ModifyMenu(hMenu, Id, MF_BYCOMMAND | MF_STRING | was_flag, Id, label);
+    return item->GetName();

 }
 
 }
 

-wxString wxMenuBar::GetLabel(int Id) const
+void wxMenuBar::SetHelpString (int id, const wxString& helpString)

 {
     wxMenu *itemMenu = NULL;
 {
     wxMenu *itemMenu = NULL;

-    wxMenuItem *item = FindItemForId(Id, &itemMenu) ;
+    wxMenuItem *item = FindItemForId(id, &itemMenu) ;

 
 

-    wxCHECK_MSG( item, "", "wxMenuItem::GetLabel(): no such item" );
+    wxCHECK_RET( item, _T("wxMenuBar::SetHelpString(): no such item") );

 
 

-    char tmp[128];
-    int len = GetMenuString(GetHMENU(), Id, tmp, WXSIZEOF(tmp), MF_BYCOMMAND);
-    tmp[len] = '\0' ;
+    item->SetHelp(helpString);
+}

 
 

-    return wxString(tmp);
+wxString wxMenuBar::GetHelpString (int id) const
+{
+    wxMenu *itemMenu = NULL;
+    wxMenuItem *item = FindItemForId(id, &itemMenu) ;
+
+    wxCHECK_MSG( item, _T(""), _T("wxMenuBar::GetHelpString(): no such item") );
+
+    return item->GetHelp();

 }
 
 }
 

+// ---------------------------------------------------------------------------
+// wxMenuBar functions to work with the top level submenus
+// ---------------------------------------------------------------------------
+
+// NB: we don't support owner drawn top level items for now, if we do these
+//     functions would have to be changed to use wxMenuItem as well
+

 void wxMenuBar::SetLabelTop(int pos, const wxString& label)
 {
 void wxMenuBar::SetLabelTop(int pos, const wxString& label)
 {

-    UINT was_flag = GetMenuState((HMENU)m_hMenu,pos,MF_BYPOSITION) ;
-    if (was_flag&MF_POPUP)
+    UINT id;
+    UINT flagsOld = ::GetMenuState((HMENU)m_hMenu, pos, MF_BYPOSITION);
+    if ( flagsOld == 0xFFFFFFFF )

     {
     {

-        was_flag &= 0xff ;
-        HMENU popup = GetSubMenu((HMENU)m_hMenu,pos) ;
-        ModifyMenu((HMENU)m_hMenu,pos,MF_BYPOSITION|MF_STRING|was_flag,(UINT)popup,(const char *)label) ;
+        wxLogLastError(_T("GetMenuState"));
+
+        return;
+    }
+
+    if ( flagsOld & MF_POPUP )
+    {
+        // HIBYTE contains the number of items in the submenu in this case
+        flagsOld &= 0xff ;
+        id = (UINT)::GetSubMenu((HMENU)m_hMenu, pos) ;

     }
     else
     }
     else

-        ModifyMenu((HMENU)m_hMenu,pos,MF_BYPOSITION|MF_STRING|was_flag,pos,(const char *)label) ;
+    {
+        id = pos;
+    }
+
+    if ( ::ModifyMenu(GetHmenu(), pos, MF_BYPOSITION | MF_STRING | flagsOld,
+                      id, label) == 0xFFFFFFFF )
+    {
+        wxLogLastError("ModifyMenu");
+    }

 }
 
 wxString wxMenuBar::GetLabelTop(int pos) const
 {
 }
 
 wxString wxMenuBar::GetLabelTop(int pos) const
 {

-    static char tmp[128] ;
-    int len = GetMenuString((HMENU)m_hMenu,pos,tmp,127,MF_BYPOSITION) ;
-    tmp[len] = '\0' ;
-    return wxString(tmp);
+    int len = ::GetMenuString((HMENU)m_hMenu, pos, NULL, 0, MF_BYCOMMAND);
+
+    len++;  // for the NUL character
+    wxString label;
+    ::GetMenuString(GetHmenu(), pos, label.GetWriteBuf(len), len, MF_BYCOMMAND);
+    label.UngetWriteBuf();
+
+    return label;

 }
 
 }
 

+// ---------------------------------------------------------------------------
+// wxMenuBar notifications
+// ---------------------------------------------------------------------------
+

 bool wxMenuBar::OnDelete(wxMenu *a_menu, int pos)
 {
 bool wxMenuBar::OnDelete(wxMenu *a_menu, int pos)
 {

-    if (!m_menuBarFrame)
+    if ( !m_menuBarFrame )

         return TRUE;
 
         return TRUE;
 

-    if (RemoveMenu((HMENU)m_hMenu, (UINT)pos, MF_BYPOSITION)) {
-        m_menus[pos]->m_hMenu = m_menus[pos]->m_savehMenu;
-        m_menus[pos]->m_savehMenu = 0;
+    if ( ::RemoveMenu((HMENU)m_hMenu, (UINT)pos, MF_BYPOSITION) )
+    {
+        // VZ: I'm not sure about what's going on here, so I leave an assert
+        wxASSERT_MSG( m_menus[pos] == a_menu, _T("what is this parameter for??") );

 
 

-        if (m_menuBarFrame) {
-            DrawMenuBar((HWND) m_menuBarFrame->GetHWND()) ;
-        }
+        a_menu->Detach();
+
+        if ( m_menuBarFrame )
+            Refresh();

 
         return TRUE;
     }
 
         return TRUE;
     }

+    else
+    {
+        wxLogLastError("RemoveMenu");
+    }

 
     return FALSE;
 }
 
 
     return FALSE;
 }
 

-bool wxMenuBar::OnAppend(wxMenu *a_menu, const char *title)
+bool wxMenuBar::OnAppend(wxMenu *a_menu, const wxChar *title)

 {
 {

-    if (!a_menu->m_hMenu)
+    WXHMENU submenu = a_menu->GetHMenu();
+    if ( !submenu )

         return FALSE;
 
         return FALSE;
 

-    if (!m_menuBarFrame)
+    if ( !m_menuBarFrame )

         return TRUE;
 
         return TRUE;
 

-    a_menu->m_savehMenu = a_menu->m_hMenu;
-    a_menu->m_hMenu = 0;
+    a_menu->Attach(this);

 
 

-    AppendMenu((HMENU)m_hMenu, MF_POPUP | MF_STRING, (UINT)a_menu->m_savehMenu, title);
+    if ( !::AppendMenu(GetHmenu(), MF_POPUP | MF_STRING,
+                       (UINT)submenu, title) )
+    {
+        wxLogLastError(_T("AppendMenu"));
+    }

 
 

-    DrawMenuBar((HWND)m_menuBarFrame->GetHWND());
+    Refresh();

 
     return TRUE;
 }
 
 
     return TRUE;
 }
 

+// ---------------------------------------------------------------------------
+// wxMenuBar construction
+// ---------------------------------------------------------------------------
+

 void wxMenuBar::Append (wxMenu * menu, const wxString& title)
 {
     if (!OnAppend(menu, title))
 void wxMenuBar::Append (wxMenu * menu, const wxString& title)
 {
     if (!OnAppend(menu, title))


@@ -790,7 +939,7 @@ void wxMenuBar::Append (wxMenu * menu, const wxString& title)
         new_menus[i] = m_menus[i];
         m_menus[i] = NULL;
         new_titles[i] = m_titles[i];
         new_menus[i] = m_menus[i];
         m_menus[i] = NULL;
         new_titles[i] = m_titles[i];

-        m_titles[i] = "";
+        m_titles[i] = _T("");

     }
     if (m_menus)
     {
     }
     if (m_menus)
     {


@@ -803,8 +952,7 @@ void wxMenuBar::Append (wxMenu * menu, const wxString& title)
     m_menus[m_menuCount - 1] = (wxMenu *)menu;
     m_titles[m_menuCount - 1] = title;
 
     m_menus[m_menuCount - 1] = (wxMenu *)menu;
     m_titles[m_menuCount - 1] = title;
 

-    ((wxMenu *)menu)->m_menuBar = (wxMenuBar *) this;
-    ((wxMenu *)menu)->SetParent(this);
+    menu->SetParent(this);

 }
 
 void wxMenuBar::Delete(wxMenu * menu, int i)
 }
 
 void wxMenuBar::Delete(wxMenu * menu, int i)


@@ -837,70 +985,73 @@ void wxMenuBar::Delete(wxMenu * menu, int i)
     }
 }
 
     }
 }
 

-// Find the menu menuString, item itemString, and return the item id.
-// Returns -1 if none found.
-int wxMenuBar::FindMenuItem (const wxString& menuString, const wxString& itemString) const
+void wxMenuBar::Attach(wxFrame *frame)

 {
 {

-    char buf1[200];
-    char buf2[200];
-    wxStripMenuCodes ((char *)(const char *)menuString, buf1);
+    wxASSERT_MSG( !m_menuBarFrame, _T("menubar already attached!") );
+
+    m_menuBarFrame = frame;
+
+#if wxUSE_ACCEL
+    // create the accel table - we consider that the menubar construction is
+    // finished
+    size_t nAccelCount = 0;

     int i;
     int i;

-    for (i = 0; i < m_menuCount; i++)
+    for ( i = 0; i < m_menuCount; i++ )

     {
     {

-        wxStripMenuCodes ((char *)(const char *)m_titles[i], buf2);
-        if (strcmp (buf1, buf2) == 0)
-            return m_menus[i]->FindItem (itemString);
+        nAccelCount += m_menus[i]->GetAccelCount();

     }
     }

-    return -1;
-}

 
 

-wxMenuItem *wxMenuBar::FindItemForId (int Id, wxMenu ** itemMenu) const
-{
-    if (itemMenu)
-        *itemMenu = NULL;
-
-    wxMenuItem *item = NULL;
-    int i;
-    for (i = 0; i < m_menuCount; i++)
+    if ( nAccelCount )

     {
     {

-        item = m_menus[i]->FindItemForId (Id, itemMenu);
-        if (item)
-            return item;
+        wxAcceleratorEntry *accelEntries = new wxAcceleratorEntry[nAccelCount];
+
+        nAccelCount = 0;
+        for ( i = 0; i < m_menuCount; i++ )
+        {
+            nAccelCount += m_menus[i]->CopyAccels(&accelEntries[nAccelCount]);
+        }
+
+        m_accelTable = wxAcceleratorTable(nAccelCount, accelEntries);
+
+        delete [] accelEntries;

     }
     }

-    return NULL;
+#endif // wxUSE_ACCEL

 }
 
 }
 

-void wxMenuBar::SetHelpString (int Id, const wxString& helpString)
+// ---------------------------------------------------------------------------
+// wxMenuBar searching for menu items
+// ---------------------------------------------------------------------------
+
+// Find the itemString in menuString, and return the item id or wxNOT_FOUND
+int wxMenuBar::FindMenuItem(const wxString& menuString,
+                            const wxString& itemString) const

 {
 {

-    int i;
-    for (i = 0; i < m_menuCount; i++)
+    wxString menuLabel = wxStripMenuCodes(menuString);
+    for ( int i = 0; i < m_menuCount; i++ )

     {
     {

-        if (m_menus[i]->FindItemForId (Id))
-        {
-            m_menus[i]->SetHelpString (Id, helpString);
-            return;
-        }
+        wxString title = wxStripMenuCodes(m_titles[i]);
+        if ( menuString == title )
+            return m_menus[i]->FindItem(itemString);

     }
     }

+
+    return wxNOT_FOUND;

 }
 
 }
 

-wxString wxMenuBar::GetHelpString (int Id) const
+wxMenuItem *wxMenuBar::FindItemForId (int id, wxMenu **itemMenu) const

 {
 {

-    wxString helpString;
+    if ( itemMenu )
+        *itemMenu = NULL;

 
 

-    for (int i = 0; i < m_menuCount; i++)
+    wxMenuItem *item = NULL;
+    for ( int i = 0; !item && (i < m_menuCount); i++ )

     {
     {

-        wxMenuItem *item = m_menus[i]->FindItemForId(Id);
-        if ( item )
-        {
-            helpString = item->GetHelp();
-
-            break;
-        }
+        item = m_menus[i]->FindItemForId(id, itemMenu);

     }
 
     }
 

-    return helpString;
+    return item;

 }
 
 }
 

+

 // ----------------------------------------------------------------------------
 // helper functions
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // helper functions
 // ----------------------------------------------------------------------------


@@ -910,7 +1061,7 @@ wxWindow *wxMenu::GetWindow() const
     if ( m_pInvokingWindow != NULL )
         return m_pInvokingWindow;
     else if ( m_menuBar != NULL)
     if ( m_pInvokingWindow != NULL )
         return m_pInvokingWindow;
     else if ( m_menuBar != NULL)

-        return m_menuBar->m_menuBarFrame;
+        return m_menuBar->GetFrame();

 
     return NULL;
 }
 
     return NULL;
 }


@@ -922,7 +1073,7 @@ WXHMENU wxMenu::GetHMenu() const
     else if ( m_savehMenu != 0 )
         return m_savehMenu;
 
     else if ( m_savehMenu != 0 )
         return m_savehMenu;
 

-    wxFAIL_MSG("wxMenu without HMENU");
+    wxFAIL_MSG(_T("wxMenu without HMENU"));

 
     return 0;
 }
 
     return 0;
 }