src/univ/menu.cpp

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