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