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