src/univ/menu.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        univ/menu.cpp
   3 // Purpose:     wxMenuItem, wxMenu and wxMenuBar implementation
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     25.08.00
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "univmenuitem.h"
  22     #pragma implementation "univmenu.h"
  23 #endif
  24
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/dynarray.h"
  33     #include "wx/control.h"      // for FindAccelIndex()
  34     #include "wx/menu.h"
  35     #include "wx/settings.h"
  36     #include "wx/accel.h"
  37     #include "wx/log.h"
  38 #endif // WX_PRECOMP
  39
  40 #if wxUSE_MENUS
  41
  42 #include "wx/popupwin.h"
  43 #include "wx/evtloop.h"
  44 #include "wx/dcclient.h"
  45 #include "wx/frame.h"
  46
  47 #include "wx/univ/renderer.h"
  48
  49 #ifdef __WXMSW__
  50     #include "wx/msw/private.h"
  51 #endif // __WXMSW__
  52
  53 // ----------------------------------------------------------------------------
  54 // wxMenuInfo contains all extra information about top level menus we need
  55 // ----------------------------------------------------------------------------
  56
  57 class WXDLLEXPORT wxMenuInfo
  58 {
  59 public:
  60     // ctor
  61     wxMenuInfo(const wxString& text)
  62     {
  63         SetLabel(text);
  64         SetEnabled();
  65     }
  66
  67     // modifiers
  68
  69     void SetLabel(const wxString& text)
  70     {
  71         // remember the accel char (may be -1 if none)
  72         m_indexAccel = wxControl::FindAccelIndex(text, &m_label);
  73
  74         // calculate the width later, after the menu bar is created
  75         m_width = 0;
  76     }
  77
  78     void SetEnabled(bool enabled = TRUE) { m_isEnabled = enabled; }
  79
  80     // accessors
  81
  82     const wxString& GetLabel() const { return m_label; }
  83     bool IsEnabled() const { return m_isEnabled; }
  84     wxCoord GetWidth(wxMenuBar *menubar) const
  85     {
  86         if ( !m_width )
  87         {
  88             wxConstCast(this, wxMenuInfo)->CalcWidth(menubar);
  89         }
  90
  91         return m_width;
  92     }
  93
  94     int GetAccelIndex() const { return m_indexAccel; }
  95
  96 private:
  97     void CalcWidth(wxMenuBar *menubar)
  98     {
  99         wxSize size;
 100         wxClientDC dc(menubar);
 101         dc.SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
 102         dc.GetTextExtent(m_label, &size.x, &size.y);
 103
 104         // adjust for the renderer we use and store the width
 105         m_width = menubar->GetRenderer()->GetMenuBarItemSize(size).x;
 106     }
 107
 108     wxString m_label;
 109     wxCoord m_width;
 110     int m_indexAccel;
 111     bool m_isEnabled;
 112 };
 113
 114 #include "wx/arrimpl.cpp"
 115
 116 WX_DEFINE_OBJARRAY(wxMenuInfoArray);
 117
 118 // ----------------------------------------------------------------------------
 119 // wxPopupMenuWindow: a popup window showing a menu
 120 // ----------------------------------------------------------------------------
 121
 122 class wxPopupMenuWindow : public wxPopupTransientWindow
 123 {
 124 public:
 125     wxPopupMenuWindow(wxWindow *parent, wxMenu *menu);
 126
 127     // override the base class version to select the first item initially
 128     virtual void Popup(wxWindow *focus = NULL);
 129
 130     // override the base class version to dismiss any open submenus
 131     virtual void Dismiss();
 132
 133     // notify the menu when the window disappears from screen
 134     virtual void OnDismiss();
 135
 136     // called when a submenu is dismissed
 137     void OnSubmenuDismiss() { m_hasOpenSubMenu = FALSE; }
 138
 139     // get the currently selected item (may be NULL)
 140     wxMenuItem *GetCurrentItem() const
 141     {
 142         return m_nodeCurrent ? m_nodeCurrent->GetData() : NULL;
 143     }
 144
 145     // find the menu item at given position
 146     wxMenuItemList::Node *GetMenuItemFromPoint(const wxPoint& pt) const;
 147
 148     // refresh the given item
 149     void RefreshItem(wxMenuItem *item);
 150
 151     // preselect the first item
 152     void SelectFirst() { SetCurrent(m_menu->GetMenuItems().GetFirst()); }
 153
 154     // process the key event, return TRUE if done
 155     bool ProcessKeyDown(int key);
 156
 157     // process mouse move event
 158     void ProcessMouseMove(const wxPoint& pt);
 159
 160     // don't dismiss the popup window if the parent menu was clicked
 161     virtual bool ProcessLeftDown(wxMouseEvent& event);
 162
 163 protected:
 164     // how did we perform this operation?
 165     enum InputMethod
 166     {
 167         WithKeyboard,
 168         WithMouse
 169     };
 170
 171     // draw the menu inside this window
 172     virtual void DoDraw(wxControlRenderer *renderer);
 173
 174     // event handlers
 175     void OnLeftUp(wxMouseEvent& event);
 176     void OnMouseMove(wxMouseEvent& event);
 177     void OnMouseLeave(wxMouseEvent& event);
 178     void OnKeyDown(wxKeyEvent& event);
 179
 180     // reset the current item and node
 181     void ResetCurrent();
 182
 183     // set the current node and item withotu refreshing anything
 184     void SetCurrent(wxMenuItemList::Node *node);
 185
 186     // change the current item refreshing the old and new items
 187     void ChangeCurrent(wxMenuItemList::Node *node);
 188
 189     // activate item, i.e. call either ClickItem() or OpenSubmenu() depending
 190     // on what it is, return TRUE if something was done (i.e. it's not a
 191     // separator...)
 192     bool ActivateItem(wxMenuItem *item, InputMethod how = WithKeyboard);
 193
 194     // send the event about the item click
 195     void ClickItem(wxMenuItem *item);
 196
 197     // show the submenu for this item
 198     void OpenSubmenu(wxMenuItem *item, InputMethod how = WithKeyboard);
 199
 200     // can this tiem be opened?
 201     bool CanOpen(wxMenuItem *item)
 202     {
 203         return item && item->IsEnabled() && item->IsSubMenu();
 204     }
 205
 206     // dismiss the menu and all parent menus too
 207     void DismissAndNotify();
 208
 209     // react to dimissing this menu and also dismiss the parent if
 210     // dismissParent
 211     void HandleDismiss(bool dismissParent);
 212
 213     // do we have an open submenu?
 214     bool HasOpenSubmenu() const { return m_hasOpenSubMenu; }
 215
 216     // get previous node after the current one
 217     wxMenuItemList::Node *GetPrevNode() const;
 218
 219     // get previous node before the given one, wrapping if it's the first one
 220     wxMenuItemList::Node *GetPrevNode(wxMenuItemList::Node *node) const;
 221
 222     // get next node after the current one
 223     wxMenuItemList::Node *GetNextNode() const;
 224
 225     // get next node after the given one, wrapping if it's the last one
 226     wxMenuItemList::Node *GetNextNode(wxMenuItemList::Node *node) const;
 227
 228 private:
 229     // the menu we show
 230     wxMenu *m_menu;
 231
 232     // the menu node corresponding to the current item
 233     wxMenuItemList::Node *m_nodeCurrent;
 234
 235     // do we currently have an opened submenu?
 236     bool m_hasOpenSubMenu;
 237
 238     DECLARE_EVENT_TABLE()
 239 };
 240
 241 // ----------------------------------------------------------------------------
 242 // wxMenuKbdRedirector: an event handler which redirects kbd input to wxMenu
 243 // ----------------------------------------------------------------------------
 244
 245 class wxMenuKbdRedirector : public wxEvtHandler
 246 {
 247 public:
 248     wxMenuKbdRedirector(wxMenu *menu) { m_menu = menu; }
 249
 250     virtual bool ProcessEvent(wxEvent& event)
 251     {
 252         if ( event.GetEventType() == wxEVT_KEY_DOWN )
 253         {
 254             return m_menu->ProcessKeyDown(((wxKeyEvent &)event).GetKeyCode());
 255         }
 256         else
 257         {
 258             return wxEvtHandler::ProcessEvent(event);
 259         }
 260     }
 261
 262 private:
 263     wxMenu *m_menu;
 264 };
 265
 266 // ----------------------------------------------------------------------------
 267 // wxWin macros
 268 // ----------------------------------------------------------------------------
 269
 270 IMPLEMENT_DYNAMIC_CLASS(wxMenu, wxEvtHandler)
 271 IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxWindow)
 272 IMPLEMENT_DYNAMIC_CLASS(wxMenuItem, wxObject)
 273
 274 BEGIN_EVENT_TABLE(wxPopupMenuWindow, wxPopupTransientWindow)
 275     EVT_KEY_DOWN(wxPopupMenuWindow::OnKeyDown)
 276
 277     EVT_LEFT_UP(wxPopupMenuWindow::OnLeftUp)
 278     EVT_MOTION(wxPopupMenuWindow::OnMouseMove)
 279     EVT_LEAVE_WINDOW(wxPopupMenuWindow::OnMouseLeave)
 280 END_EVENT_TABLE()
 281
 282 BEGIN_EVENT_TABLE(wxMenuBar, wxMenuBarBase)
 283     EVT_KILL_FOCUS(wxMenuBar::OnKillFocus)
 284
 285     EVT_KEY_DOWN(wxMenuBar::OnKeyDown)
 286
 287     EVT_LEFT_DOWN(wxMenuBar::OnLeftDown)
 288     EVT_MOTION(wxMenuBar::OnMouseMove)
 289 END_EVENT_TABLE()
 290
 291 // ============================================================================
 292 // implementation
 293 // ============================================================================
 294
 295 // ----------------------------------------------------------------------------
 296 // wxPopupMenuWindow
 297 // ----------------------------------------------------------------------------
 298
 299 wxPopupMenuWindow::wxPopupMenuWindow(wxWindow *parent, wxMenu *menu)
 300 {
 301     m_menu = menu;
 302     m_hasOpenSubMenu = FALSE;
 303
 304     ResetCurrent();
 305
 306     (void)Create(parent, wxBORDER_RAISED);
 307
 308     SetCursor(wxCURSOR_ARROW);
 309 }
 310
 311 // ----------------------------------------------------------------------------
 312 // wxPopupMenuWindow current item/node handling
 313 // ----------------------------------------------------------------------------
 314
 315 void wxPopupMenuWindow::ResetCurrent()
 316 {
 317     SetCurrent(NULL);
 318 }
 319
 320 void wxPopupMenuWindow::SetCurrent(wxMenuItemList::Node *node)
 321 {
 322     m_nodeCurrent = node;
 323 }
 324
 325 void wxPopupMenuWindow::ChangeCurrent(wxMenuItemList::Node *node)
 326 {
 327     if ( node != m_nodeCurrent )
 328     {
 329         wxMenuItemList::Node *nodeOldCurrent = m_nodeCurrent;
 330
 331         m_nodeCurrent = node;
 332
 333         if ( nodeOldCurrent )
 334         {
 335             wxMenuItem *item = nodeOldCurrent->GetData();
 336             wxCHECK_RET( item, _T("no current item?") );
 337
 338             // if it was the currently opened menu, close it
 339             if ( item->IsSubMenu() && item->GetSubMenu()->IsShown() )
 340             {
 341                 item->GetSubMenu()->Dismiss();
 342                 OnSubmenuDismiss();
 343             }
 344
 345             RefreshItem(item);
 346         }
 347
 348         if ( m_nodeCurrent )
 349             RefreshItem(m_nodeCurrent->GetData());
 350     }
 351 }
 352
 353 wxMenuItemList::Node *wxPopupMenuWindow::GetPrevNode() const
 354 {
 355     wxMenuItemList::Node *node = m_nodeCurrent;
 356     if ( !node )
 357     {
 358         // start from the end if no current item
 359         node = m_menu->GetMenuItems().GetLast();
 360     }
 361
 362     return GetPrevNode(node);
 363 }
 364
 365 wxMenuItemList::Node *
 366 wxPopupMenuWindow::GetPrevNode(wxMenuItemList::Node *node) const
 367 {
 368     if ( node )
 369     {
 370         node = node->GetPrevious();
 371         if ( !node )
 372         {
 373             node = m_menu->GetMenuItems().GetLast();
 374         }
 375     }
 376     //else: the menu is empty
 377
 378     return node;
 379 }
 380
 381 wxMenuItemList::Node *wxPopupMenuWindow::GetNextNode() const
 382 {
 383     wxMenuItemList::Node *node = m_nodeCurrent;
 384     if ( !node )
 385     {
 386         // start from the beginning if no current item
 387         node = m_menu->GetMenuItems().GetFirst();
 388     }
 389
 390     return GetNextNode(node);
 391 }
 392
 393 wxMenuItemList::Node *
 394 wxPopupMenuWindow::GetNextNode(wxMenuItemList::Node *node) const
 395 {
 396     if ( node )
 397     {
 398         node = node->GetNext();
 399         if ( !node )
 400         {
 401             node = m_menu->GetMenuItems().GetFirst();
 402         }
 403     }
 404     //else: the menu is empty
 405
 406     return node;
 407 }
 408
 409 // ----------------------------------------------------------------------------
 410 // wxPopupMenuWindow popup/dismiss
 411 // ----------------------------------------------------------------------------
 412
 413 void wxPopupMenuWindow::Popup(wxWindow *focus)
 414 {
 415     // check that the current item had been properly reset before
 416     wxASSERT_MSG( !m_nodeCurrent ||
 417                   m_nodeCurrent == m_menu->GetMenuItems().GetFirst(),
 418                   _T("menu current item preselected incorrectly") );
 419
 420     wxPopupTransientWindow::Popup(focus);
 421
 422 #ifdef __WXMSW__
 423     // ensure that this window is really on top of everything: without using
 424     // SetWindowPos() it can be covered by its parent menu which is not
 425     // really what we want
 426     wxMenu *menuParent = m_menu->GetParent();
 427     if ( menuParent )
 428     {
 429         wxPopupMenuWindow *win = menuParent->m_popupMenu;
 430
 431         // if we're shown, the parent menu must be also shown
 432         wxCHECK_RET( win, _T("parent menu is not shown?") );
 433
 434         if ( !::SetWindowPos(GetHwndOf(win), GetHwnd(),
 435                              0, 0, 0, 0,
 436                              SWP_NOMOVE | SWP_NOSIZE | SWP_NOREDRAW) )
 437         {
 438             wxLogLastError(_T("SetWindowPos(HWND_TOP)"));
 439         }
 440
 441         Refresh();
 442     }
 443 #endif // __WXMSW__
 444 }
 445
 446 void wxPopupMenuWindow::Dismiss()
 447 {
 448     if ( HasOpenSubmenu() )
 449     {
 450         wxMenuItem *item = GetCurrentItem();
 451         wxCHECK_RET( item && item->IsSubMenu(), _T("where is our open submenu?") );
 452
 453         wxPopupMenuWindow *win = item->GetSubMenu()->m_popupMenu;
 454         wxCHECK_RET( win, _T("opened submenu is not opened?") );
 455
 456         win->Dismiss();
 457         OnSubmenuDismiss();
 458     }
 459
 460     wxPopupTransientWindow::Dismiss();
 461 }
 462
 463 void wxPopupMenuWindow::OnDismiss()
 464 {
 465     // when we are dismissed because the user clicked elsewhere or we lost
 466     // focus in any other way, hide the parent menu as well
 467     HandleDismiss(TRUE);
 468 }
 469
 470 void wxPopupMenuWindow::HandleDismiss(bool dismissParent)
 471 {
 472     ResetCurrent();
 473
 474     m_menu->OnDismiss(dismissParent);
 475 }
 476
 477 void wxPopupMenuWindow::DismissAndNotify()
 478 {
 479     Dismiss();
 480     HandleDismiss(TRUE);
 481 }
 482
 483 // ----------------------------------------------------------------------------
 484 // wxPopupMenuWindow geometry
 485 // ----------------------------------------------------------------------------
 486
 487 wxMenuItemList::Node *
 488 wxPopupMenuWindow::GetMenuItemFromPoint(const wxPoint& pt) const
 489 {
 490     // we only use the y coord normally, but still check x in case the point is
 491     // outside the window completely
 492     if ( wxWindow::HitTest(pt) == wxHT_WINDOW_INSIDE )
 493     {
 494         wxCoord y = 0;
 495         for ( wxMenuItemList::Node *node = m_menu->GetMenuItems().GetFirst();
 496               node;
 497               node = node->GetNext() )
 498         {
 499             wxMenuItem *item = node->GetData();
 500             y += item->GetHeight();
 501             if ( y > pt.y )
 502             {
 503                 // found
 504                 return node;
 505             }
 506         }
 507     }
 508
 509     return NULL;
 510 }
 511
 512 // ----------------------------------------------------------------------------
 513 // wxPopupMenuWindow drawing
 514 // ----------------------------------------------------------------------------
 515
 516 void wxPopupMenuWindow::RefreshItem(wxMenuItem *item)
 517 {
 518     wxCHECK_RET( item, _T("can't refresh NULL item") );
 519
 520     wxASSERT_MSG( IsShown(), _T("can't refresh menu which is not shown") );
 521
 522     // FIXME: -1 here because of SetLogicalOrigin(1, 1) in DoDraw()
 523     RefreshRect(wxRect(0, item->GetPosition() - 1,
 524                 m_menu->GetGeometryInfo().GetSize().x, item->GetHeight()));
 525 }
 526
 527 void wxPopupMenuWindow::DoDraw(wxControlRenderer *renderer)
 528 {
 529     // no clipping so far - do we need it? I don't think so as the menu is
 530     // never partially covered as it is always on top of everything
 531
 532     wxDC& dc = renderer->GetDC();
 533     dc.SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
 534
 535     // FIXME: this should be done in the renderer, however when it is fixed
 536     //        wxPopupMenuWindow::RefreshItem() should be changed too!
 537     dc.SetLogicalOrigin(1, 1);
 538
 539     wxRenderer *rend = renderer->GetRenderer();
 540
 541     wxCoord y = 0;
 542     const wxMenuGeometryInfo& gi = m_menu->GetGeometryInfo();
 543     for ( wxMenuItemList::Node *node = m_menu->GetMenuItems().GetFirst();
 544           node;
 545           node = node->GetNext() )
 546     {
 547         wxMenuItem *item = node->GetData();
 548
 549         if ( item->IsSeparator() )
 550         {
 551             rend->DrawMenuSeparator(dc, y, gi);
 552         }
 553         else // not a separator
 554         {
 555             int flags = 0;
 556             if ( item->IsCheckable() )
 557             {
 558                 flags |= wxCONTROL_CHECKABLE;
 559
 560                 if ( item->IsChecked() )
 561                 {
 562                     flags |= wxCONTROL_CHECKED;
 563                 }
 564             }
 565
 566             if ( !item->IsEnabled() )
 567                 flags |= wxCONTROL_DISABLED;
 568
 569             if ( item->IsSubMenu() )
 570                 flags |= wxCONTROL_ISSUBMENU;
 571
 572             if ( item == GetCurrentItem() )
 573                 flags |= wxCONTROL_SELECTED;
 574
 575             rend->DrawMenuItem
 576                   (
 577                      dc,
 578                      y,
 579                      gi,
 580                      item->GetLabel(),
 581                      item->GetAccelString(),
 582                      // strangely enough, for unchecked item we use the
 583                      // "checked" bitmap because this is the default one - this
 584                      // explains this strange boolean expression
 585                      item->GetBitmap(!item->IsCheckable() || item->IsChecked()),
 586                      flags,
 587                      item->GetAccelIndex()
 588                   );
 589         }
 590
 591         y += item->GetHeight();
 592     }
 593 }
 594
 595 // ----------------------------------------------------------------------------
 596 // wxPopupMenuWindow actions
 597 // ----------------------------------------------------------------------------
 598
 599 void wxPopupMenuWindow::ClickItem(wxMenuItem *item)
 600 {
 601     wxCHECK_RET( item, _T("can't click NULL item") );
 602
 603     wxASSERT_MSG( !item->IsSeparator() && !item->IsSubMenu(),
 604                   _T("can't click this item") );
 605
 606     wxMenu* menu = m_menu;
 607
 608     // close all menus
 609     DismissAndNotify();
 610
 611     menu->ClickItem(item);
 612 }
 613
 614 void wxPopupMenuWindow::OpenSubmenu(wxMenuItem *item, InputMethod how)
 615 {
 616     wxCHECK_RET( item, _T("can't open NULL submenu") );
 617
 618     wxMenu *submenu = item->GetSubMenu();
 619     wxCHECK_RET( submenu, _T("can only open submenus!") );
 620
 621     // FIXME: should take into account the border width
 622     submenu->Popup(ClientToScreen(wxPoint(0, item->GetPosition())),
 623                    wxSize(m_menu->GetGeometryInfo().GetSize().x, 0),
 624                    how == WithKeyboard /* preselect first item then */);
 625
 626     m_hasOpenSubMenu = TRUE;
 627 }
 628
 629 bool wxPopupMenuWindow::ActivateItem(wxMenuItem *item, InputMethod how)
 630 {
 631     // don't activate disabled items
 632     if ( !item || !item->IsEnabled() )
 633     {
 634         return FALSE;
 635     }
 636
 637     // normal menu items generate commands, submenus can be opened and
 638     // the separators don't do anything
 639     if ( item->IsSubMenu() )
 640     {
 641         OpenSubmenu(item, how);
 642     }
 643     else if ( !item->IsSeparator() )
 644     {
 645         ClickItem(item);
 646     }
 647     else // separator, can't activate
 648     {
 649         return FALSE;
 650     }
 651
 652     return TRUE;
 653 }
 654
 655 // ----------------------------------------------------------------------------
 656 // wxPopupMenuWindow input handling
 657 // ----------------------------------------------------------------------------
 658
 659 bool wxPopupMenuWindow::ProcessLeftDown(wxMouseEvent& event)
 660 {
 661     // wxPopupWindowHandler dismisses the window when the mouse is clicked
 662     // outside it which is usually just fine, but there is one case when we
 663     // don't want to do it: if the mouse was clicked on the parent submenu item
 664     // which opens this menu, so check for it
 665
 666     wxPoint pos = event.GetPosition();
 667     if ( HitTest(pos.x, pos.y) == wxHT_WINDOW_OUTSIDE )
 668     {
 669         wxMenu *menu = m_menu->GetParent();
 670         if ( menu )
 671         {
 672             wxPopupMenuWindow *win = menu->m_popupMenu;
 673
 674             wxCHECK_MSG( win, FALSE, _T("parent menu not shown?") );
 675
 676             pos = ClientToScreen(pos);
 677             if ( win->GetMenuItemFromPoint(win->ScreenToClient(pos)) )
 678             {
 679                 // eat the event
 680                 return TRUE;
 681             }
 682             //else: it is outside the parent menu as well, do dismiss this one
 683         }
 684     }
 685
 686     return FALSE;
 687 }
 688
 689 void wxPopupMenuWindow::OnLeftUp(wxMouseEvent& event)
 690 {
 691     wxMenuItemList::Node *node = GetMenuItemFromPoint(event.GetPosition());
 692     if ( node )
 693     {
 694         ActivateItem(node->GetData(), WithMouse);
 695     }
 696 }
 697
 698 void wxPopupMenuWindow::OnMouseMove(wxMouseEvent& event)
 699 {
 700     const wxPoint pt = event.GetPosition();
 701
 702     // we need to ignore extra mouse events: example when this happens is when
 703     // the mouse is on the menu and we open a submenu from keyboard - Windows
 704     // then sends us a dummy mouse move event, we (correctly) determine that it
 705     // happens in the parent menu and so immediately close the just opened
 706     // submenu!
 707 #ifdef __WXMSW__
 708     static wxPoint s_ptLast;
 709     wxPoint ptCur = ClientToScreen(pt);
 710     if ( ptCur == s_ptLast )
 711     {
 712         return;
 713     }
 714
 715     s_ptLast = ptCur;
 716 #endif // __WXMSW__
 717
 718     ProcessMouseMove(pt);
 719
 720     event.Skip();
 721 }
 722
 723 void wxPopupMenuWindow::ProcessMouseMove(const wxPoint& pt)
 724 {
 725     wxMenuItemList::Node *node = GetMenuItemFromPoint(pt);
 726
 727     // don't reset current to NULL here, we only do it when the mouse leaves
 728     // the window (see below)
 729     if ( node )
 730     {
 731         if ( node != m_nodeCurrent )
 732         {
 733             ChangeCurrent(node);
 734
 735             wxMenuItem *item = GetCurrentItem();
 736             if ( CanOpen(item) )
 737             {
 738                 OpenSubmenu(item, WithMouse);
 739             }
 740         }
 741         //else: same item, nothing to do
 742     }
 743     else // not on an item
 744     {
 745         // the last open submenu forwards the mouse move messages to its
 746         // parent, so if the mouse moves to another item of the parent menu,
 747         // this menu is closed and this other item is selected - in the similar
 748         // manner, the top menu forwards the mouse moves to the menubar which
 749         // allows to select another top level menu by just moving the mouse
 750
 751         // we need to translate our client coords to the client coords of the
 752         // window we forward this event to
 753         wxPoint ptScreen = ClientToScreen(pt);
 754
 755         // if the mouse is outside this menu, let the parent one to
 756         // process it
 757         wxMenu *menuParent = m_menu->GetParent();
 758         if ( menuParent )
 759         {
 760             wxPopupMenuWindow *win = menuParent->m_popupMenu;
 761
 762             // if we're shown, the parent menu must be also shown
 763             wxCHECK_RET( win, _T("parent menu is not shown?") );
 764
 765             win->ProcessMouseMove(win->ScreenToClient(ptScreen));
 766         }
 767         else // no parent menu
 768         {
 769             wxMenuBar *menubar = m_menu->GetMenuBar();
 770             if ( menubar )
 771             {
 772                 if ( menubar->ProcessMouseEvent(
 773                             menubar->ScreenToClient(ptScreen)) )
 774                 {
 775                     // menubar has closed this menu and opened another one, probably
 776                     return;
 777                 }
 778             }
 779         }
 780         //else: top level popup menu, no other processing to do
 781     }
 782 }
 783
 784 void wxPopupMenuWindow::OnMouseLeave(wxMouseEvent& event)
 785 {
 786     // due to the artefact of mouse events generation under MSW, we actually
 787     // may get the mouse leave event after the menu had been already dismissed
 788     // and calling ChangeCurrent() would then assert, so don't do it
 789     if ( IsShown() )
 790     {
 791         // we shouldn't change the current them if our submenu is opened and
 792         // mouse moved there, in this case the submenu is responsable for
 793         // handling it
 794         bool resetCurrent;
 795         if ( HasOpenSubmenu() )
 796         {
 797             wxMenuItem *item = GetCurrentItem();
 798             wxCHECK_RET( CanOpen(item), _T("where is our open submenu?") );
 799
 800             wxPopupMenuWindow *win = item->GetSubMenu()->m_popupMenu;
 801             wxCHECK_RET( win, _T("submenu is opened but not shown?") );
 802
 803             // only handle this event if the mouse is not inside the submenu
 804             wxPoint pt = ClientToScreen(event.GetPosition());
 805             resetCurrent =
 806                 win->HitTest(win->ScreenToClient(pt)) == wxHT_WINDOW_OUTSIDE;
 807         }
 808         else
 809         {
 810             // this menu is the last opened
 811             resetCurrent = TRUE;
 812         }
 813
 814         if ( resetCurrent )
 815         {
 816             ChangeCurrent(NULL);
 817         }
 818     }
 819
 820     event.Skip();
 821 }
 822
 823 void wxPopupMenuWindow::OnKeyDown(wxKeyEvent& event)
 824 {
 825     if ( !ProcessKeyDown(event.GetKeyCode()) )
 826     {
 827         event.Skip();
 828     }
 829 }
 830
 831 bool wxPopupMenuWindow::ProcessKeyDown(int key)
 832 {
 833     wxMenuItem *item = GetCurrentItem();
 834
 835     // first let the opened submenu to have it (no test for IsEnabled() here,
 836     // the keys navigate even in a disabled submenu if we had somehow managed
 837     // to open it inspit of this)
 838     if ( HasOpenSubmenu() )
 839     {
 840         wxCHECK_MSG( CanOpen(item), FALSE,
 841                      _T("has open submenu but another item selected?") );
 842
 843         if ( item->GetSubMenu()->ProcessKeyDown(key) )
 844             return TRUE;
 845     }
 846
 847     bool processed = TRUE;
 848
 849     // handle the up/down arrows, home, end, esc and return here, pass the
 850     // left/right arrows to the menu bar except when the right arrow can be
 851     // used to open a submenu
 852     switch ( key )
 853     {
 854         case WXK_LEFT:
 855             // if we're not a top level menu, close us, else leave this to the
 856             // menubar
 857             if ( !m_menu->GetParent() )
 858             {
 859                 processed = FALSE;
 860                 break;
 861             }
 862
 863             // fall through
 864
 865         case WXK_ESCAPE:
 866             // close just this menu
 867             Dismiss();
 868             HandleDismiss(FALSE);
 869             break;
 870
 871         case WXK_RETURN:
 872             processed = ActivateItem(item);
 873             break;
 874
 875         case WXK_HOME:
 876             ChangeCurrent(m_menu->GetMenuItems().GetFirst());
 877             break;
 878
 879         case WXK_END:
 880             ChangeCurrent(m_menu->GetMenuItems().GetLast());
 881             break;
 882
 883         case WXK_UP:
 884         case WXK_DOWN:
 885             {
 886                 bool up = key == WXK_UP;
 887
 888                 wxMenuItemList::Node *nodeStart = up ? GetPrevNode()
 889                                                      : GetNextNode(),
 890                                      *node = nodeStart;
 891                 while ( node && node->GetData()->IsSeparator() )
 892                 {
 893                     node = up ? GetPrevNode(node) : GetNextNode(node);
 894
 895                     if ( node == nodeStart )
 896                     {
 897                         // nothing but separators and disabled items in this
 898                         // menu, break out
 899                         node = NULL;
 900                     }
 901                 }
 902
 903                 if ( node )
 904                 {
 905                     ChangeCurrent(node);
 906                 }
 907                 else
 908                 {
 909                     processed = FALSE;
 910                 }
 911             }
 912             break;
 913
 914         case WXK_RIGHT:
 915             // don't try to reopen an already opened menu
 916             if ( !HasOpenSubmenu() && CanOpen(item) )
 917             {
 918                 OpenSubmenu(item);
 919             }
 920             else
 921             {
 922                 processed = FALSE;
 923             }
 924             break;
 925
 926         default:
 927             // look for the menu item starting with this letter
 928             if ( wxIsalnum(key) )
 929             {
 930                 // we want to start from the item after this one because
 931                 // if we're already on the item with the given accel we want to
 932                 // go to the next one, not to stay in place
 933                 wxMenuItemList::Node *nodeStart = GetNextNode();
 934
 935                 // do we have more than one item with this accel?
 936                 bool notUnique = FALSE;
 937
 938                 // translate everything to lower case before comparing
 939                 wxChar chAccel = wxTolower(key);
 940
 941                 // loop through all items searching for the item with this
 942                 // accel
 943                 wxMenuItemList::Node *node = nodeStart,
 944                                      *nodeFound = NULL;
 945                 for ( ;; )
 946                 {
 947                     item = node->GetData();
 948
 949                     int idxAccel = item->GetAccelIndex();
 950                     if ( idxAccel != -1 &&
 951                          wxTolower(item->GetLabel()[(size_t)idxAccel])
 952                             == chAccel )
 953                     {
 954                         // ok, found an item with this accel
 955                         if ( !nodeFound )
 956                         {
 957                             // store it but continue searching as we need to
 958                             // know if it's the only item with this accel or if
 959                             // there are more
 960                             nodeFound = node;
 961                         }
 962                         else // we already had found such item
 963                         {
 964                             notUnique = TRUE;
 965
 966                             // no need to continue further, we won't find
 967                             // anything we don't already know
 968                             break;
 969                         }
 970                     }
 971
 972                     // we want to iterate over all items wrapping around if
 973                     // necessary
 974                     node = GetNextNode(node);
 975                     if ( node == nodeStart )
 976                     {
 977                         // we've seen all nodes
 978                         break;
 979                     }
 980                 }
 981
 982                 if ( nodeFound )
 983                 {
 984                     item = nodeFound->GetData();
 985
 986                     // go to this item anyhow
 987                     ChangeCurrent(nodeFound);
 988
 989                     if ( !notUnique && item->IsEnabled() )
 990                     {
 991                         // unique item with this accel - activate it
 992                         processed = ActivateItem(item);
 993                     }
 994                     //else: just select it but don't activate as the user might
 995                     //      have wanted to activate another item
 996
 997                     // skip "processed = FALSE" below
 998                     break;
 999                 }
1000             }
1001
1002             processed = FALSE;
1003     }
1004
1005     return processed;
1006 }
1007
1008 // ----------------------------------------------------------------------------
1009 // wxMenu
1010 // ----------------------------------------------------------------------------
1011
1012 void wxMenu::Init()
1013 {
1014     m_geometry = NULL;
1015
1016     m_popupMenu = NULL;
1017 }
1018
1019 wxMenu::~wxMenu()
1020 {
1021     delete m_geometry;
1022     delete m_popupMenu;
1023 }
1024
1025 // ----------------------------------------------------------------------------
1026 // wxMenu and wxMenuGeometryInfo
1027 // ----------------------------------------------------------------------------
1028
1029 wxMenuGeometryInfo::~wxMenuGeometryInfo()
1030 {
1031 }
1032
1033 const wxMenuGeometryInfo& wxMenu::GetGeometryInfo() const
1034 {
1035     if ( !m_geometry )
1036     {
1037         if ( m_popupMenu )
1038         {
1039             wxConstCast(this, wxMenu)->m_geometry =
1040                 m_popupMenu->GetRenderer()->GetMenuGeometry(m_popupMenu, *this);
1041         }
1042         else
1043         {
1044             wxFAIL_MSG( _T("can't get geometry without window") );
1045         }
1046     }
1047
1048     return *m_geometry;
1049 }
1050
1051 void wxMenu::InvalidateGeometryInfo()
1052 {
1053     if ( m_geometry )
1054     {
1055         delete m_geometry;
1056         m_geometry = NULL;
1057     }
1058 }
1059
1060 // ----------------------------------------------------------------------------
1061 // wxMenu adding/removing items
1062 // ----------------------------------------------------------------------------
1063
1064 void wxMenu::OnItemAdded(wxMenuItem *item)
1065 {
1066     InvalidateGeometryInfo();
1067
1068 #if wxUSE_ACCEL
1069     AddAccelFor(item);
1070 #endif // wxUSE_ACCEL
1071
1072     // the submenus of a popup menu should have the same invoking window as it
1073     // has
1074     if ( m_invokingWindow && item->IsSubMenu() )
1075     {
1076         item->GetSubMenu()->SetInvokingWindow(m_invokingWindow);
1077     }
1078 }
1079
1080 bool wxMenu::DoAppend(wxMenuItem *item)
1081 {
1082     if ( !wxMenuBase::DoAppend(item) )
1083         return FALSE;
1084
1085     OnItemAdded(item);
1086
1087     return TRUE;
1088 }
1089
1090 bool wxMenu::DoInsert(size_t pos, wxMenuItem *item)
1091 {
1092     if ( !wxMenuBase::DoInsert(pos, item) )
1093         return FALSE;
1094
1095     OnItemAdded(item);
1096
1097     return TRUE;
1098 }
1099
1100 wxMenuItem *wxMenu::DoRemove(wxMenuItem *item)
1101 {
1102     wxMenuItem *itemOld = wxMenuBase::DoRemove(item);
1103
1104     if ( itemOld )
1105     {
1106         InvalidateGeometryInfo();
1107
1108 #if wxUSE_ACCEL
1109         RemoveAccelFor(item);
1110 #endif // wxUSE_ACCEL
1111     }
1112
1113     return itemOld;
1114 }
1115
1116 // ----------------------------------------------------------------------------
1117 // wxMenu attaching/detaching
1118 // ----------------------------------------------------------------------------
1119
1120 void wxMenu::Attach(wxMenuBarBase *menubar)
1121 {
1122     wxMenuBase::Attach(menubar);
1123
1124     wxCHECK_RET( m_menuBar, _T("menubar can't be NULL after attaching") );
1125
1126     // unfortunately, we can't use m_menuBar->GetEventHandler() here because,
1127     // if the menubar is currently showing a menu, its event handler is a
1128     // temporary one installed by wxPopupWindow and so will disappear soon any
1129     // any attempts to use it from the newly attached menu would result in a
1130     // crash
1131     //
1132     // so we use the menubar itself, even if it's a pity as it means we can't
1133     // redirect all menu events by changing the menubar handler (FIXME)
1134     SetNextHandler(m_menuBar);
1135 }
1136
1137 void wxMenu::Detach()
1138 {
1139     wxMenuBase::Detach();
1140 }
1141
1142 // ----------------------------------------------------------------------------
1143 // wxMenu misc functions
1144 // ----------------------------------------------------------------------------
1145
1146 wxWindow *wxMenu::GetRootWindow() const
1147 {
1148     if ( m_menuBar )
1149     {
1150         // simple case - a normal menu attached to the menubar
1151         return m_menuBar;
1152     }
1153
1154     // we're a popup menu but the trouble is that only the top level popup menu
1155     // has a pointer to the invoking window, so we must walk up the menu chain
1156     // if needed
1157     wxWindow *win = GetInvokingWindow();
1158     if ( win )
1159     {
1160         // we already have it
1161         return win;
1162     }
1163
1164     wxMenu *menu = GetParent();
1165     while ( menu )
1166     {
1167         win = menu->GetInvokingWindow();
1168         if ( win )
1169             break;
1170
1171         menu = menu->GetParent();
1172     }
1173
1174     // we're probably going to crash in the caller anyhow, but try to detect
1175     // this error as soon as possible
1176     wxASSERT_MSG( win, _T("menu without any associated window?") );
1177
1178     // also remember it in this menu so that we don't have to search for it the
1179     // next time
1180     wxConstCast(this, wxMenu)->m_invokingWindow = win;
1181
1182     return win;
1183 }
1184
1185 wxRenderer *wxMenu::GetRenderer() const
1186 {
1187     // we're going to crash without renderer!
1188     wxCHECK_MSG( m_popupMenu, NULL, _T("neither popup nor menubar menu?") );
1189
1190     return m_popupMenu->GetRenderer();
1191 }
1192
1193 void wxMenu::RefreshItem(wxMenuItem *item)
1194 {
1195     // the item geometry changed, so our might have changed as well
1196     InvalidateGeometryInfo();
1197
1198     if ( IsShown() )
1199     {
1200         // this would be a bug in IsShown()
1201         wxCHECK_RET( m_popupMenu, _T("must have popup window if shown!") );
1202
1203         // recalc geometry to update the item height and such
1204         (void)GetGeometryInfo();
1205
1206         m_popupMenu->RefreshItem(item);
1207     }
1208 }
1209
1210 // ----------------------------------------------------------------------------
1211 // wxMenu showing and hiding
1212 // ----------------------------------------------------------------------------
1213
1214 bool wxMenu::IsShown() const
1215 {
1216     return m_popupMenu && m_popupMenu->IsShown();
1217 }
1218
1219 void wxMenu::OnDismiss(bool dismissParent)
1220 {
1221     if ( m_menuParent )
1222     {
1223         // always notify the parent about submenu disappearance
1224         wxPopupMenuWindow *win = m_menuParent->m_popupMenu;
1225         if ( win )
1226         {
1227             win->OnSubmenuDismiss();
1228         }
1229         else
1230         {
1231             wxFAIL_MSG( _T("parent menu not shown?") );
1232         }
1233
1234         // and if we dismiss everything, propagate to parent
1235         if ( dismissParent )
1236         {
1237             // dismissParent is recursive
1238             m_menuParent->Dismiss();
1239             m_menuParent->OnDismiss(TRUE);
1240         }
1241     }
1242     else // no parent menu
1243     {
1244         // notify the menu bar if we're a top level menu
1245         if ( m_menuBar )
1246         {
1247             m_menuBar->OnDismissMenu(dismissParent);
1248         }
1249         else // popup menu
1250         {
1251             wxCHECK_RET( m_invokingWindow, _T("what kind of menu is this?") );
1252
1253             m_invokingWindow->DismissPopupMenu();
1254             SetInvokingWindow(NULL);
1255         }
1256     }
1257 }
1258
1259 void wxMenu::Popup(const wxPoint& pos, const wxSize& size, bool selectFirst)
1260 {
1261     // create the popup window if not done yet
1262     if ( !m_popupMenu )
1263     {
1264         m_popupMenu = new wxPopupMenuWindow(GetRootWindow(), this);
1265     }
1266
1267     // select the first item unless disabled
1268     if ( selectFirst )
1269     {
1270         m_popupMenu->SelectFirst();
1271     }
1272
1273     // the geometry might have changed since the last time we were shown, so
1274     // always resize
1275     m_popupMenu->SetClientSize(GetGeometryInfo().GetSize());
1276
1277     // position it as specified
1278     m_popupMenu->Position(pos, size);
1279
1280     // the menu can't have the focus itself (it is a Windows limitation), so
1281     // always keep the focus at the originating window
1282     wxWindow *focus = GetRootWindow();
1283
1284     wxASSERT_MSG( focus, _T("no window to keep focus on?") );
1285
1286     // and show it
1287     m_popupMenu->Popup(focus);
1288 }
1289
1290 void wxMenu::Dismiss()
1291 {
1292     wxCHECK_RET( IsShown(), _T("can't dismiss hidden menu") );
1293
1294     m_popupMenu->Dismiss();
1295 }
1296
1297 // ----------------------------------------------------------------------------
1298 // wxMenu event processing
1299 // ----------------------------------------------------------------------------
1300
1301 bool wxMenu::ProcessKeyDown(int key)
1302 {
1303     wxCHECK_MSG( m_popupMenu, FALSE,
1304                  _T("can't process key events if not shown") );
1305
1306     return m_popupMenu->ProcessKeyDown(key);
1307 }
1308
1309 bool wxMenu::ClickItem(wxMenuItem *item)
1310 {
1311     int isChecked;
1312     if ( item->IsCheckable() )
1313     {
1314         // update the item state
1315         isChecked = !item->IsChecked();
1316
1317         item->Check(isChecked != 0);
1318     }
1319     else
1320     {
1321         // not applicabled
1322         isChecked = -1;
1323     }
1324
1325     return SendEvent(item->GetId(), isChecked);
1326 }
1327
1328 // ----------------------------------------------------------------------------
1329 // wxMenu accel support
1330 // ----------------------------------------------------------------------------
1331
1332 #if wxUSE_ACCEL
1333
1334 bool wxMenu::ProcessAccelEvent(const wxKeyEvent& event)
1335 {
1336     // do we have an item for this accel?
1337     wxMenuItem *item = m_accelTable.GetMenuItem(event);
1338     if ( item && item->IsEnabled() )
1339     {
1340         return ClickItem(item);
1341     }
1342
1343     // try our submenus
1344     for ( wxMenuItemList::Node *node = GetMenuItems().GetFirst();
1345           node;
1346           node = node->GetNext() )
1347     {
1348         const wxMenuItem *item = node->GetData();
1349         if ( item->IsSubMenu() && item->IsEnabled() )
1350         {
1351             // try its elements
1352             if ( item->GetSubMenu()->ProcessAccelEvent(event) )
1353             {
1354                 return TRUE;
1355             }
1356         }
1357     }
1358
1359     return FALSE;
1360 }
1361
1362 void wxMenu::AddAccelFor(wxMenuItem *item)
1363 {
1364     wxAcceleratorEntry *accel = item->GetAccel();
1365     if ( accel )
1366     {
1367         accel->SetMenuItem(item);
1368
1369         m_accelTable.Add(*accel);
1370
1371         delete accel;
1372     }
1373 }
1374
1375 void wxMenu::RemoveAccelFor(wxMenuItem *item)
1376 {
1377     wxAcceleratorEntry *accel = item->GetAccel();
1378     if ( accel )
1379     {
1380         m_accelTable.Remove(*accel);
1381
1382         delete accel;
1383     }
1384 }
1385
1386 #endif // wxUSE_ACCEL
1387
1388 // ----------------------------------------------------------------------------
1389 // wxMenuItem construction
1390 // ----------------------------------------------------------------------------
1391
1392 wxMenuItem::wxMenuItem(wxMenu *parentMenu,
1393                        int id,
1394                        const wxString& text,
1395                        const wxString& help,
1396                        bool isCheckable,
1397                        wxMenu *subMenu)
1398 {
1399     m_id = id;
1400     m_parentMenu = parentMenu;
1401     m_subMenu = subMenu;
1402
1403     m_text = text;
1404     m_help = help;
1405
1406     m_isCheckable = isCheckable;
1407     m_isEnabled = TRUE;
1408     m_isChecked = FALSE;
1409
1410     m_posY =
1411     m_height = -1;
1412
1413     UpdateAccelInfo();
1414 }
1415
1416 wxMenuItem::~wxMenuItem()
1417 {
1418 }
1419
1420 // ----------------------------------------------------------------------------
1421 // wxMenuItemBase methods implemented here
1422 // ----------------------------------------------------------------------------
1423
1424 /* static */
1425 wxMenuItem *wxMenuItemBase::New(wxMenu *parentMenu,
1426                                 int id,
1427                                 const wxString& name,
1428                                 const wxString& help,
1429                                 bool isCheckable,
1430                                 wxMenu *subMenu)
1431 {
1432     return new wxMenuItem(parentMenu, id, name, help, isCheckable, subMenu);
1433 }
1434
1435 /* static */
1436 wxString wxMenuItemBase::GetLabelFromText(const wxString& text)
1437 {
1438     return wxStripMenuCodes(text);
1439 }
1440
1441 // ----------------------------------------------------------------------------
1442 // wxMenuItem operations
1443 // ----------------------------------------------------------------------------
1444
1445 void wxMenuItem::NotifyMenu()
1446 {
1447     m_parentMenu->RefreshItem(this);
1448 }
1449
1450 void wxMenuItem::UpdateAccelInfo()
1451 {
1452     m_indexAccel = wxControl::FindAccelIndex(m_text);
1453
1454     // will be empty if the text contains no TABs - ok
1455     m_strAccel = m_text.AfterFirst(_T('\t'));
1456 }
1457
1458 void wxMenuItem::SetText(const wxString& text)
1459 {
1460     if ( text != m_text )
1461     {
1462         // first call the base class version to change m_text
1463         wxMenuItemBase::SetText(text);
1464
1465         UpdateAccelInfo();
1466
1467         NotifyMenu();
1468     }
1469 }
1470
1471 void wxMenuItem::SetCheckable(bool checkable)
1472 {
1473     if ( checkable != m_isCheckable )
1474     {
1475         wxMenuItemBase::SetCheckable(checkable);
1476
1477         NotifyMenu();
1478     }
1479 }
1480
1481 void wxMenuItem::SetBitmaps(const wxBitmap& bmpChecked,
1482                             const wxBitmap& bmpUnchecked)
1483 {
1484     m_bmpChecked = bmpChecked;
1485     m_bmpUnchecked = bmpUnchecked;
1486
1487     NotifyMenu();
1488 }
1489
1490 void wxMenuItem::Enable(bool enable)
1491 {
1492     if ( enable != m_isEnabled )
1493     {
1494         wxMenuItemBase::Enable(enable);
1495
1496         NotifyMenu();
1497     }
1498 }
1499
1500 void wxMenuItem::Check(bool check)
1501 {
1502     if ( check != m_isChecked )
1503     {
1504         wxMenuItemBase::Check(check);
1505
1506         NotifyMenu();
1507     }
1508 }
1509
1510 // ----------------------------------------------------------------------------
1511 // wxMenuBar creation
1512 // ----------------------------------------------------------------------------
1513
1514 void wxMenuBar::Init()
1515 {
1516     m_frameLast = NULL;
1517
1518     m_current = -1;
1519
1520     m_menuShown = NULL;
1521
1522     m_shouldShowMenu = FALSE;
1523 }
1524
1525 void wxMenuBar::Attach(wxFrame *frame)
1526 {
1527     // maybe you really wanted to call Detach()?
1528     wxCHECK_RET( frame, _T("wxMenuBar::Attach(NULL) called") );
1529
1530     wxMenuBarBase::Attach(frame);
1531
1532     if ( IsCreated() )
1533     {
1534         // reparent if necessary
1535         if ( m_frameLast != frame )
1536         {
1537             Reparent(frame);
1538         }
1539
1540         // show it back - was hidden by Detach()
1541         Show();
1542     }
1543     else // not created yet, do it now
1544     {
1545         // we have no way to return the error from here anyhow :-(
1546         (void)Create(frame, -1);
1547
1548         SetCursor(wxCURSOR_ARROW);
1549
1550         SetFont(wxSystemSettings::GetSystemFont(wxSYS_SYSTEM_FONT));
1551
1552         // calculate and set our height (it won't be changed any more)
1553         SetSize(-1, GetBestSize().y);
1554     }
1555
1556     // remember the last frame which had us to avoid unnecessarily reparenting
1557     // above
1558     m_frameLast = frame;
1559 }
1560
1561 void wxMenuBar::Detach()
1562 {
1563     // don't delete the window because we may be reattached later, just hide it
1564     if ( m_frameLast )
1565     {
1566         Hide();
1567     }
1568
1569     wxMenuBarBase::Detach();
1570 }
1571
1572 wxMenuBar::~wxMenuBar()
1573 {
1574 }
1575
1576 // ----------------------------------------------------------------------------
1577 // wxMenuBar adding/removing items
1578 // ----------------------------------------------------------------------------
1579
1580 bool wxMenuBar::Append(wxMenu *menu, const wxString& title)
1581 {
1582     return Insert(GetCount(), menu, title);
1583 }
1584
1585 bool wxMenuBar::Insert(size_t pos, wxMenu *menu, const wxString& title)
1586 {
1587     if ( !wxMenuBarBase::Insert(pos, menu, title) )
1588         return FALSE;
1589
1590     wxMenuInfo *info = new wxMenuInfo(title);
1591     m_menuInfos.Insert(info, pos);
1592
1593     RefreshAllItemsAfter(pos);
1594
1595     return TRUE;
1596 }
1597
1598 wxMenu *wxMenuBar::Replace(size_t pos, wxMenu *menu, const wxString& title)
1599 {
1600     wxMenu *menuOld = wxMenuBarBase::Replace(pos, menu, title);
1601
1602     if ( menuOld )
1603     {
1604         wxMenuInfo& info = m_menuInfos[pos];
1605
1606         info.SetLabel(title);
1607
1608         // even if the old menu was disabled, the new one is not any more
1609         info.SetEnabled();
1610
1611         // even if we change only this one, the new label has different width,
1612         // so we need to refresh everything beyond this item as well
1613         RefreshAllItemsAfter(pos);
1614     }
1615
1616     return menuOld;
1617 }
1618
1619 wxMenu *wxMenuBar::Remove(size_t pos)
1620 {
1621     wxMenu *menuOld = wxMenuBarBase::Remove(pos);
1622
1623     if ( menuOld )
1624     {
1625         m_menuInfos.RemoveAt(pos);
1626
1627         // this doesn't happen too often, so don't try to be too smart - just
1628         // refresh everything
1629         Refresh();
1630     }
1631
1632     return menuOld;
1633 }
1634
1635 // ----------------------------------------------------------------------------
1636 // wxMenuBar top level menus access
1637 // ----------------------------------------------------------------------------
1638
1639 wxCoord wxMenuBar::GetItemWidth(size_t pos) const
1640 {
1641     return m_menuInfos[pos].GetWidth(wxConstCast(this, wxMenuBar));
1642 }
1643
1644 void wxMenuBar::EnableTop(size_t pos, bool enable)
1645 {
1646     wxCHECK_RET( pos < GetCount(), _T("invalid index in EnableTop") );
1647
1648     if ( enable != m_menuInfos[pos].IsEnabled() )
1649     {
1650         m_menuInfos[pos].SetEnabled(enable);
1651
1652         RefreshItem(pos);
1653     }
1654     //else: nothing to do
1655 }
1656
1657 bool wxMenuBar::IsEnabledTop(size_t pos) const
1658 {
1659     wxCHECK_MSG( pos < GetCount(), FALSE, _T("invalid index in IsEnabledTop") );
1660
1661     return m_menuInfos[pos].IsEnabled();
1662 }
1663
1664 void wxMenuBar::SetLabelTop(size_t pos, const wxString& label)
1665 {
1666     wxCHECK_RET( pos < GetCount(), _T("invalid index in EnableTop") );
1667
1668     if ( label != m_menuInfos[pos].GetLabel() )
1669     {
1670         m_menuInfos[pos].SetLabel(label);
1671
1672         RefreshItem(pos);
1673     }
1674     //else: nothing to do
1675 }
1676
1677 wxString wxMenuBar::GetLabelTop(size_t pos) const
1678 {
1679     wxCHECK_MSG( pos < GetCount(), _T(""), _T("invalid index in GetLabelTop") );
1680
1681     return m_menuInfos[pos].GetLabel();
1682 }
1683
1684 // ----------------------------------------------------------------------------
1685 // wxMenuBar drawing
1686 // ----------------------------------------------------------------------------
1687
1688 void wxMenuBar::RefreshAllItemsAfter(size_t pos)
1689 {
1690     if ( !IsCreated() )
1691     {
1692         // no need to refresh if nothing is shown yet
1693         return;
1694     }
1695
1696     wxRect rect = GetItemRect(pos);
1697     rect.width = GetClientSize().x - rect.x;
1698     RefreshRect(rect);
1699 }
1700
1701 void wxMenuBar::RefreshItem(size_t pos)
1702 {
1703     wxCHECK_RET( pos != (size_t)-1,
1704                  _T("invalid item in wxMenuBar::RefreshItem") );
1705
1706     if ( !IsCreated() )
1707     {
1708         // no need to refresh if nothing is shown yet
1709         return;
1710     }
1711
1712     RefreshRect(GetItemRect(pos));
1713 }
1714
1715 void wxMenuBar::DoDraw(wxControlRenderer *renderer)
1716 {
1717     wxDC& dc = renderer->GetDC();
1718     dc.SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
1719
1720     // redraw only the items which must be redrawn
1721
1722     // we don't have to use GetUpdateClientRect() here because our client rect
1723     // is the same as total one
1724     wxRect rectUpdate = GetUpdateRegion().GetBox();
1725
1726     int flagsMenubar = GetStateFlags();
1727
1728     wxRect rect;
1729     rect.y = 0;
1730     rect.height = GetClientSize().y;
1731
1732     wxCoord x = 0;
1733     size_t count = GetCount();
1734     for ( size_t n = 0; n < count; n++ )
1735     {
1736         if ( x > rectUpdate.GetRight() )
1737         {
1738             // all remaining items are to the right of rectUpdate
1739             break;
1740         }
1741
1742         rect.x = x;
1743         rect.width = GetItemWidth(n);
1744         x += rect.width;
1745         if ( x < rectUpdate.x )
1746         {
1747             // this item is still to the left of rectUpdate
1748             continue;
1749         }
1750
1751         int flags = flagsMenubar;
1752         if ( m_current != -1 && n == (size_t)m_current )
1753         {
1754             flags |= wxCONTROL_SELECTED;
1755         }
1756
1757         if ( !IsEnabledTop(n) )
1758         {
1759             flags |= wxCONTROL_DISABLED;
1760         }
1761
1762         GetRenderer()->DrawMenuBarItem
1763                        (
1764                             dc,
1765                             rect,
1766                             m_menuInfos[n].GetLabel(),
1767                             flags,
1768                             m_menuInfos[n].GetAccelIndex()
1769                        );
1770     }
1771 }
1772
1773 // ----------------------------------------------------------------------------
1774 // wxMenuBar geometry
1775 // ----------------------------------------------------------------------------
1776
1777 wxRect wxMenuBar::GetItemRect(size_t pos) const
1778 {
1779     wxASSERT_MSG( pos < GetCount(), _T("invalid menu bar item index") );
1780     wxASSERT_MSG( IsCreated(), _T("can't call this method yet") );
1781
1782     wxRect rect;
1783     rect.x =
1784     rect.y = 0;
1785     rect.height = GetClientSize().y;
1786
1787     for ( size_t n = 0; n < pos; n++ )
1788     {
1789         rect.x += GetItemWidth(n);
1790     }
1791
1792     rect.width = GetItemWidth(pos);
1793
1794     return rect;
1795 }
1796
1797 wxSize wxMenuBar::DoGetBestClientSize() const
1798 {
1799     wxSize size;
1800     if ( GetMenuCount() > 0 )
1801     {
1802         wxClientDC dc(wxConstCast(this, wxMenuBar));
1803         dc.SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
1804         dc.GetTextExtent(GetLabelTop(0), &size.x, &size.y);
1805
1806         // adjust for the renderer we use
1807         size = GetRenderer()->GetMenuBarItemSize(size);
1808     }
1809     else // empty menubar
1810     {
1811         size.x =
1812         size.y = 0;
1813     }
1814
1815     // the width is arbitrary, of course, for horizontal menubar
1816     size.x = 100;
1817
1818     return size;
1819 }
1820
1821 int wxMenuBar::GetMenuFromPoint(const wxPoint& pos) const
1822 {
1823     if ( pos.x < 0 || pos.y < 0 || pos.y > GetClientSize().y )
1824         return -1;
1825
1826     // do find it
1827     wxCoord x = 0;
1828     size_t count = GetCount();
1829     for ( size_t item = 0; item < count; item++ )
1830     {
1831         x += GetItemWidth(item);
1832
1833         if ( x > pos.x )
1834         {
1835             return item;
1836         }
1837     }
1838
1839     // to the right of the last menu item
1840     return -1;
1841 }
1842
1843 // ----------------------------------------------------------------------------
1844 // wxMenuBar menu operations
1845 // ----------------------------------------------------------------------------
1846
1847 void wxMenuBar::SelectMenu(size_t pos)
1848 {
1849     SetFocus();
1850     CaptureMouse();
1851
1852     DoSelectMenu(pos);
1853 }
1854
1855 void wxMenuBar::DoSelectMenu(size_t pos)
1856 {
1857     wxCHECK_RET( pos < GetCount(), _T("invalid menu index in DoSelectMenu") );
1858
1859     int posOld = m_current;
1860
1861     m_current = pos;
1862
1863     if ( posOld != -1 )
1864     {
1865         // close the previous menu
1866         if ( IsShowingMenu() )
1867         {
1868             // restore m_shouldShowMenu flag after DismissMenu() which resets
1869             // it to FALSE
1870             bool old = m_shouldShowMenu;
1871
1872             DismissMenu();
1873
1874             m_shouldShowMenu = old;
1875         }
1876
1877         RefreshItem((size_t)posOld);
1878     }
1879
1880     RefreshItem(pos);
1881 }
1882
1883 void wxMenuBar::PopupMenu(size_t pos)
1884 {
1885     wxCHECK_RET( pos < GetCount(), _T("invalid menu index in PopupCurrentMenu") );
1886
1887     SetFocus();
1888     DoSelectMenu(pos);
1889     PopupCurrentMenu();
1890 }
1891
1892 // ----------------------------------------------------------------------------
1893 // wxMenuBar input handing
1894 // ----------------------------------------------------------------------------
1895
1896 /*
1897    Note that wxMenuBar doesn't use wxInputHandler but handles keyboard and
1898    mouse in the same way under all platforms. This is because it doesn't derive
1899    from wxControl (which works with input handlers) but directly from wxWindow.
1900
1901    Also, menu bar input handling is rather simple, so maybe it's not really
1902    worth making it themeable - at least I've decided against doing it now as it
1903    would merging the changes back into trunk more difficult. But it still could
1904    be done later if really needed.
1905  */
1906
1907 void wxMenuBar::OnKillFocus(wxFocusEvent& event)
1908 {
1909     if ( m_current != -1 )
1910     {
1911         RefreshItem((size_t)m_current);
1912
1913         m_current = -1;
1914     }
1915
1916     event.Skip();
1917 }
1918
1919 void wxMenuBar::OnLeftDown(wxMouseEvent& event)
1920 {
1921     if ( HasCapture() )
1922     {
1923         OnDismiss();
1924
1925         event.Skip();
1926     }
1927     else // we didn't have mouse capture, capture it now
1928     {
1929         m_current = GetMenuFromPoint(event.GetPosition());
1930         if ( m_current == -1 )
1931         {
1932             // unfortunately, we can't prevent wxMSW from giving us the focus,
1933             // so we can only give it back
1934             GiveAwayFocus();
1935         }
1936         else // on item
1937         {
1938             CaptureMouse();
1939
1940             // show it as selected
1941             RefreshItem((size_t)m_current);
1942
1943             // show the menu
1944             PopupCurrentMenu(FALSE /* don't select first item - as Windows does */);
1945         }
1946     }
1947 }
1948
1949 void wxMenuBar::OnMouseMove(wxMouseEvent& event)
1950 {
1951     if ( HasCapture() )
1952     {
1953         (void)ProcessMouseEvent(event.GetPosition());
1954     }
1955     else
1956     {
1957         event.Skip();
1958     }
1959 }
1960
1961 bool wxMenuBar::ProcessMouseEvent(const wxPoint& pt)
1962 {
1963     // a hack to ignore the extra mouse events MSW sends us: this is similar to
1964     // wxUSE_MOUSEEVENT_HACK in wxWin itself but it isn't enough for us here as
1965     // we get the messages from different windows (old and new popup menus for
1966     // example)
1967 #ifdef __WXMSW__
1968     static wxPoint s_ptLast;
1969     if ( pt == s_ptLast )
1970     {
1971         return FALSE;
1972     }
1973
1974     s_ptLast = pt;
1975 #endif // __WXMSW__
1976
1977     int currentNew = GetMenuFromPoint(pt);
1978     if ( (currentNew == -1) || (currentNew == m_current) )
1979     {
1980         return FALSE;
1981     }
1982
1983     // select the new active item
1984     DoSelectMenu(currentNew);
1985
1986     // show the menu if we know that we should, even if we hadn't been showing
1987     // it before (this may happen if the previous menu was disabled)
1988     if ( m_shouldShowMenu && !m_menuShown)
1989     {
1990         // open the new menu if the old one we closed had been opened
1991         PopupCurrentMenu(FALSE /* don't select first item - as Windows does */);
1992     }
1993
1994     return TRUE;
1995 }
1996
1997 void wxMenuBar::OnKeyDown(wxKeyEvent& event)
1998 {
1999     // ensure that we have a current item - we might not have it if we're
2000     // given the focus with Alt or F10 press (and under GTK+ the menubar
2001     // somehow gets the keyboard events even when it doesn't have focus...)
2002     if ( m_current == -1 )
2003     {
2004         if ( !HasCapture() )
2005         {
2006             SelectMenu(0);
2007         }
2008         else // we do have capture
2009         {
2010             // we always maintain a valid current item while we're in modal
2011             // state (i.e. have the capture)
2012             wxFAIL_MSG( _T("how did we manage to lose current item?") );
2013
2014             return;
2015         }
2016     }
2017
2018     int key = event.GetKeyCode();
2019
2020     // first let the menu have it
2021     if ( IsShowingMenu() && m_menuShown->ProcessKeyDown(key) )
2022     {
2023         return;
2024     }
2025
2026     // cycle through the menu items when left/right arrows are pressed and open
2027     // the menu when up/down one is
2028     switch ( key )
2029     {
2030         case WXK_MENU:
2031             // Alt must be processed at wxWindow level too
2032             event.Skip();
2033             // fall through
2034
2035         case WXK_ESCAPE:
2036             // remove the selection and give the focus away
2037             if ( m_current != -1 )
2038             {
2039                 if ( IsShowingMenu() )
2040                 {
2041                     DismissMenu();
2042                 }
2043
2044                 OnDismiss();
2045             }
2046             break;
2047
2048         case WXK_LEFT:
2049         case WXK_RIGHT:
2050             {
2051                 size_t count = GetCount();
2052                 if ( count == 1 )
2053                 {
2054                     // the item won't change anyhow
2055                     break;
2056                 }
2057                 //else: otherwise, it will
2058
2059                 // remember if we were showing a menu - if we did, we should
2060                 // show the new menu after changing the item
2061                 bool wasMenuOpened = IsShowingMenu();
2062                 if ( wasMenuOpened )
2063                 {
2064                     DismissMenu();
2065                 }
2066
2067                 // cast is safe as we tested for -1 above
2068                 size_t currentNew = (size_t)m_current;
2069
2070                 if ( key == WXK_LEFT )
2071                 {
2072                     if ( currentNew-- == 0 )
2073                         currentNew = count - 1;
2074                 }
2075                 else // right
2076                 {
2077                     if ( ++currentNew == count )
2078                         currentNew = 0;
2079                 }
2080
2081                 DoSelectMenu(currentNew);
2082
2083                 if ( wasMenuOpened )
2084                 {
2085                     PopupCurrentMenu();
2086                 }
2087             }
2088             break;
2089
2090         case WXK_DOWN:
2091         case WXK_UP:
2092         case WXK_RETURN:
2093             // open the menu
2094             PopupCurrentMenu();
2095             break;
2096
2097         default:
2098             // letters open the corresponding menu
2099             {
2100                 bool unique;
2101                 int idxFound = FindNextItemForAccel(m_current, key, &unique);
2102
2103                 if ( idxFound != -1 )
2104                 {
2105                     if ( IsShowingMenu() )
2106                     {
2107                         DismissMenu();
2108                     }
2109
2110                     DoSelectMenu((size_t)idxFound);
2111
2112                     // if the item is not unique, just select it but don't
2113                     // activate as the user might have wanted to activate
2114                     // another item
2115                     //
2116                     // also, don't try to open a disabled menu
2117                     if ( unique && IsEnabledTop((size_t)idxFound) )
2118                     {
2119                         // open the menu
2120                         PopupCurrentMenu();
2121                     }
2122
2123                     // skip the "event.Skip()" below
2124                     break;
2125                 }
2126             }
2127
2128             event.Skip();
2129     }
2130 }
2131
2132 // ----------------------------------------------------------------------------
2133 // wxMenuBar accel handling
2134 // ----------------------------------------------------------------------------
2135
2136 int wxMenuBar::FindNextItemForAccel(int idxStart, int key, bool *unique) const
2137 {
2138     if ( !wxIsalnum(key) )
2139     {
2140         // we only support letters/digits as accels
2141         return -1;
2142     }
2143
2144     // do we have more than one item with this accel?
2145     if ( unique )
2146         *unique = TRUE;
2147
2148     // translate everything to lower case before comparing
2149     wxChar chAccel = wxTolower(key);
2150
2151     // the index of the item with this accel
2152     int idxFound = -1;
2153
2154     // loop through all items searching for the item with this
2155     // accel starting at the item after the current one
2156     int count = GetCount();
2157     int n = idxStart == -1 ? 0 : idxStart + 1;
2158
2159     if ( n == count )
2160     {
2161         // wrap
2162         n = 0;
2163     }
2164
2165     idxStart = n;
2166     for ( ;; )
2167     {
2168         const wxMenuInfo& info = m_menuInfos[n];
2169
2170         int idxAccel = info.GetAccelIndex();
2171         if ( idxAccel != -1 &&
2172              wxTolower(info.GetLabel()[(size_t)idxAccel])
2173                 == chAccel )
2174         {
2175             // ok, found an item with this accel
2176             if ( idxFound == -1 )
2177             {
2178                 // store it but continue searching as we need to
2179                 // know if it's the only item with this accel or if
2180                 // there are more
2181                 idxFound = n;
2182             }
2183             else // we already had found such item
2184             {
2185                 if ( unique )
2186                     *unique = FALSE;
2187
2188                 // no need to continue further, we won't find
2189                 // anything we don't already know
2190                 break;
2191             }
2192         }
2193
2194         // we want to iterate over all items wrapping around if
2195         // necessary
2196         if ( ++n == count )
2197         {
2198             // wrap
2199             n = 0;
2200         }
2201
2202         if ( n == idxStart )
2203         {
2204             // we've seen all items
2205             break;
2206         }
2207     }
2208
2209     return idxFound;
2210 }
2211
2212 #if wxUSE_ACCEL
2213
2214 bool wxMenuBar::ProcessAccelEvent(const wxKeyEvent& event)
2215 {
2216     size_t n = 0;
2217     for ( wxMenuList::Node *node = m_menus.GetFirst();
2218           node;
2219           node = node->GetNext(), n++ )
2220     {
2221         // accels of the items in the disabled menus shouldn't work
2222         if ( m_menuInfos[n].IsEnabled() )
2223         {
2224             if ( node->GetData()->ProcessAccelEvent(event) )
2225             {
2226                 // menu processed it
2227                 return TRUE;
2228             }
2229         }
2230     }
2231
2232     // not found
2233     return FALSE;
2234 }
2235
2236 #endif // wxUSE_ACCEL
2237
2238 // ----------------------------------------------------------------------------
2239 // wxMenuBar menus showing
2240 // ----------------------------------------------------------------------------
2241
2242 void wxMenuBar::PopupCurrentMenu(bool selectFirst)
2243 {
2244     wxCHECK_RET( m_current != -1, _T("no menu to popup") );
2245
2246     // forgot to call DismissMenu()?
2247     wxASSERT_MSG( !m_menuShown, _T("shouldn't show two menu at once!") );
2248
2249     // in any case, we should show it - even if we won't
2250     m_shouldShowMenu = TRUE;
2251
2252     if ( IsEnabledTop(m_current) )
2253     {
2254         // remember the menu we show
2255         m_menuShown = GetMenu(m_current);
2256
2257         // we don't show the menu at all if it has no items
2258         if ( !m_menuShown->IsEmpty() )
2259         {
2260             // position it correctly: note that we must use screen coords and
2261             // that we pass 0 as width to position the menu exactly below the
2262             // item, not to the right of it
2263             wxRect rectItem = GetItemRect(m_current);
2264
2265             m_menuShown->Popup(ClientToScreen(rectItem.GetPosition()),
2266                                wxSize(0, rectItem.GetHeight()),
2267                                selectFirst);
2268         }
2269         else
2270         {
2271             // reset it back as no menu is shown
2272             m_menuShown = NULL;
2273         }
2274     }
2275     //else: don't show disabled menu
2276 }
2277
2278 void wxMenuBar::DismissMenu()
2279 {
2280     wxCHECK_RET( m_menuShown, _T("can't dismiss menu if none is shown") );
2281
2282     m_menuShown->Dismiss();
2283     OnDismissMenu();
2284 }
2285
2286 void wxMenuBar::OnDismissMenu(bool dismissMenuBar)
2287 {
2288     m_shouldShowMenu = FALSE;
2289     m_menuShown = NULL;
2290     if ( dismissMenuBar )
2291     {
2292         OnDismiss();
2293     }
2294 }
2295
2296 void wxMenuBar::OnDismiss()
2297 {
2298     if ( GetCapture() )
2299         GetCapture()->ReleaseMouse();
2300
2301     if ( m_current != -1 )
2302     {
2303         size_t current = m_current;
2304         m_current = -1;
2305
2306         RefreshItem(current);
2307     }
2308
2309     GiveAwayFocus();
2310 }
2311
2312 void wxMenuBar::GiveAwayFocus()
2313 {
2314     GetFrame()->SetFocus();
2315 }
2316
2317 // ----------------------------------------------------------------------------
2318 // popup menu support
2319 // ----------------------------------------------------------------------------
2320
2321 wxEventLoop *wxWindow::ms_evtLoopPopup = NULL;
2322
2323 bool wxWindow::DoPopupMenu(wxMenu *menu, int x, int y)
2324 {
2325     wxCHECK_MSG( !ms_evtLoopPopup, FALSE,
2326                  _T("can't show more than one popup menu at a time") );
2327
2328 #ifdef __WXMSW__
2329     // we need to change the cursor before showing the menu as, apparently, no
2330     // cursor changes took place while the mouse is captured
2331     wxCursor cursorOld = GetCursor();
2332     SetCursor(wxCURSOR_ARROW);
2333 #endif // __WXMSW__
2334
2335 #if 0
2336     // flash any delayed log messages before showing the menu, otherwise it
2337     // could be dismissed (because it would lose focus) immediately after being
2338     // shown
2339     wxLog::FlushActive();
2340
2341     // some controls update themselves from OnIdle() call - let them do it
2342     wxIdleEvent event;
2343     wxTheApp->ProcessEvent(event);
2344
2345     // if the window hadn't been refreshed yet, the menu can adversely affect
2346     // its next OnPaint() handler execution - i.e. scrolled window refresh
2347     // logic breaks then as it scrolls part of the menu which hadn't been there
2348     // when the update event was generated into view
2349     Update();
2350 #endif // 0
2351
2352     menu->SetInvokingWindow(this);
2353     menu->Popup(ClientToScreen(wxPoint(x, y)), wxSize(0, 0));
2354
2355     // this is not very useful if the menu was popped up because of the mouse
2356     // click but I think it is nice to do when it appears because of a key
2357     // press (i.e. Windows menu key)
2358     //
2359     // Windows itself doesn't do it, but IMHO this is nice
2360     WarpPointer(x, y);
2361
2362     // we have to redirect all keyboard input to the menu temporarily
2363     PushEventHandler(new wxMenuKbdRedirector(menu));
2364
2365     // enter the local modal loop
2366     ms_evtLoopPopup = new wxEventLoop;
2367     ms_evtLoopPopup->Run();
2368
2369     delete ms_evtLoopPopup;
2370     ms_evtLoopPopup = NULL;
2371
2372     // remove the handler
2373     PopEventHandler(TRUE /* delete it */);
2374
2375     menu->SetInvokingWindow(NULL);
2376
2377 #ifdef __WXMSW__
2378     SetCursor(cursorOld);
2379 #endif // __WXMSW__
2380
2381     return TRUE;
2382 }
2383
2384 void wxWindow::DismissPopupMenu()
2385 {
2386     wxCHECK_RET( ms_evtLoopPopup, _T("no popup menu shown") );
2387
2388     ms_evtLoopPopup->Exit();
2389 }
2390
2391 #endif // wxUSE_MENUS
2392