]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/univ/menu.cpp
removed obsolete and incorrect comment
[wxWidgets.git] / src / univ / menu.cpp
... / ...
CommitLineData
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
50typedef wxMenuItemList::compatibility_iterator wxMenuItemIter;
51
52// ----------------------------------------------------------------------------
53// wxMenuInfo contains all extra information about top level menus we need
54// ----------------------------------------------------------------------------
55
56class WXDLLEXPORT wxMenuInfo
57{
58public:
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
95private:
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
115WX_DEFINE_OBJARRAY(wxMenuInfoArray);
116
117// ----------------------------------------------------------------------------
118// wxPopupMenuWindow: a popup window showing a menu
119// ----------------------------------------------------------------------------
120
121class wxPopupMenuWindow : public wxPopupTransientWindow
122{
123public:
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
168protected:
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
236private:
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
253class wxMenuKbdRedirector : public wxEvtHandler
254{
255public:
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
272private:
273 wxMenu *m_menu;
274};
275
276// ----------------------------------------------------------------------------
277// wxWin macros
278// ----------------------------------------------------------------------------
279
280IMPLEMENT_DYNAMIC_CLASS(wxMenu, wxEvtHandler)
281IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxWindow)
282IMPLEMENT_DYNAMIC_CLASS(wxMenuItem, wxObject)
283
284BEGIN_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
293END_EVENT_TABLE()
294
295BEGIN_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)
302END_EVENT_TABLE()
303
304// ============================================================================
305// implementation
306// ============================================================================
307
308// ----------------------------------------------------------------------------
309// wxPopupMenuWindow
310// ----------------------------------------------------------------------------
311
312wxPopupMenuWindow::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
324wxPopupMenuWindow::~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
338void wxPopupMenuWindow::ResetCurrent()
339{
340 SetCurrentItem(wxMenuItemIter());
341}
342
343void wxPopupMenuWindow::SetCurrentItem(wxMenuItemIter node)
344{
345 m_nodeCurrent = node;
346}
347
348void 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
376wxMenuItemIter 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
383wxMenuItemIter
384wxPopupMenuWindow::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
399wxMenuItemIter 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
406wxMenuItemIter
407wxPopupMenuWindow::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
426void 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
464void 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
483void 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
490void wxPopupMenuWindow::OnSubmenuDismiss(bool WXUNUSED(dismissParent))
491{
492 m_hasOpenSubMenu = false;
493}
494
495void wxPopupMenuWindow::HandleDismiss(bool dismissParent)
496{
497 m_menu->OnDismiss(dismissParent);
498}
499
500void wxPopupMenuWindow::DismissAndNotify()
501{
502 Dismiss();
503 HandleDismiss(true);
504}
505
506// ----------------------------------------------------------------------------
507// wxPopupMenuWindow geometry
508// ----------------------------------------------------------------------------
509
510wxMenuItemIter
511wxPopupMenuWindow::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
539void 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
550void 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
634void 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
649void 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
664bool 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
694bool 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
724void wxPopupMenuWindow::OnLeftUp(wxMouseEvent& event)
725{
726 wxMenuItemIter node = GetMenuItemFromPoint(event.GetPosition());
727 if ( node )
728 {
729 ActivateItem(node->GetData(), WithMouse);
730 }
731}
732
733void 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
758void 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
819void 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
858void 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
872bool 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
1052void wxMenu::Init()
1053{
1054 m_geometry = NULL;
1055
1056 m_popupMenu = NULL;
1057
1058 m_startRadioGroup = -1;
1059}
1060
1061wxMenu::~wxMenu()
1062{
1063 delete m_geometry;
1064 delete m_popupMenu;
1065}
1066
1067// ----------------------------------------------------------------------------
1068// wxMenu and wxMenuGeometryInfo
1069// ----------------------------------------------------------------------------
1070
1071wxMenuGeometryInfo::~wxMenuGeometryInfo()
1072{
1073}
1074
1075const 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
1093void 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
1106void 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
1122void wxMenu::EndRadioGroup()
1123{
1124 // we're not inside a radio group any longer
1125 m_startRadioGroup = -1;
1126}
1127
1128wxMenuItem* 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
1172wxMenuItem* 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
1182wxMenuItem *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
1202void 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
1219void wxMenu::Detach()
1220{
1221 wxMenuBase::Detach();
1222}
1223
1224// ----------------------------------------------------------------------------
1225// wxMenu misc functions
1226// ----------------------------------------------------------------------------
1227
1228wxWindow *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
1271wxRenderer *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
1279void 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
1300bool wxMenu::IsShown() const
1301{
1302 return m_popupMenu && m_popupMenu->IsShown();
1303}
1304
1305void 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
1347void 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
1378void 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
1389bool 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
1397bool 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
1422bool 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
1450void 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
1463void 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
1480wxMenuItem::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
1499wxMenuItem::~wxMenuItem()
1500{
1501}
1502
1503// ----------------------------------------------------------------------------
1504// wxMenuItemBase methods implemented here
1505// ----------------------------------------------------------------------------
1506
1507/* static */
1508wxMenuItem *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 */
1519wxString wxMenuItemBase::GetLabelFromText(const wxString& text)
1520{
1521 return wxStripMenuCodes(text);
1522}
1523
1524// ----------------------------------------------------------------------------
1525// wxMenuItem operations
1526// ----------------------------------------------------------------------------
1527
1528void wxMenuItem::NotifyMenu()
1529{
1530 m_parentMenu->RefreshItem(this);
1531}
1532
1533void 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
1541void 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
1561void wxMenuItem::SetCheckable(bool checkable)
1562{
1563 if ( checkable != IsCheckable() )
1564 {
1565 wxMenuItemBase::SetCheckable(checkable);
1566
1567 NotifyMenu();
1568 }
1569}
1570
1571void wxMenuItem::SetBitmaps(const wxBitmap& bmpChecked,
1572 const wxBitmap& bmpUnchecked)
1573{
1574 m_bmpChecked = bmpChecked;
1575 m_bmpUnchecked = bmpUnchecked;
1576
1577 NotifyMenu();
1578}
1579
1580void wxMenuItem::Enable(bool enable)
1581{
1582 if ( enable != m_isEnabled )
1583 {
1584 wxMenuItemBase::Enable(enable);
1585
1586 NotifyMenu();
1587 }
1588}
1589
1590void 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
1646void wxMenuItem::SetAsRadioGroupStart()
1647{
1648 m_isRadioGroupStart = true;
1649}
1650
1651void 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
1659void 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
1671void wxMenuBar::Init()
1672{
1673 m_frameLast = NULL;
1674
1675 m_current = -1;
1676
1677 m_menuShown = NULL;
1678
1679 m_shouldShowMenu = false;
1680}
1681
1682wxMenuBar::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
1690void 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
1726void 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
1737wxMenuBar::~wxMenuBar()
1738{
1739}
1740
1741// ----------------------------------------------------------------------------
1742// wxMenuBar adding/removing items
1743// ----------------------------------------------------------------------------
1744
1745bool wxMenuBar::Append(wxMenu *menu, const wxString& title)
1746{
1747 return Insert(GetCount(), menu, title);
1748}
1749
1750bool 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
1763wxMenu *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
1784wxMenu *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
1804wxCoord wxMenuBar::GetItemWidth(size_t pos) const
1805{
1806 return m_menuInfos[pos].GetWidth(wxConstCast(this, wxMenuBar));
1807}
1808
1809void 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
1822bool 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
1829void 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
1842wxString 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
1853void 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
1866void 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
1880void 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
1942wxRect 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
1962wxSize 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
1986int 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
2012void 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
2021void 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
2049void 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
2073void 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
2085void 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
2116void wxMenuBar::OnMouseMove(wxMouseEvent& event)
2117{
2118 if ( HasCapture() )
2119 {
2120 (void)ProcessMouseEvent(event.GetPosition());
2121 }
2122 else
2123 {
2124 event.Skip();
2125 }
2126}
2127
2128bool 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
2164void 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
2303int 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
2381bool 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
2409void 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
2447void 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
2455void wxMenuBar::OnDismissMenu(bool dismissMenuBar)
2456{
2457 m_shouldShowMenu = false;
2458 m_menuShown = NULL;
2459 if ( dismissMenuBar )
2460 {
2461 OnDismiss();
2462 }
2463}
2464
2465void 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
2481bool 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
2517void wxMenuBar::GiveAwayFocus()
2518{
2519 GetFrame()->SetFocus();
2520}
2521
2522// ----------------------------------------------------------------------------
2523// popup menu support
2524// ----------------------------------------------------------------------------
2525
2526wxEventLoop *wxWindow::ms_evtLoopPopup = NULL;
2527
2528bool 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
2591void wxWindow::DismissPopupMenu()
2592{
2593 wxCHECK_RET( ms_evtLoopPopup, _T("no popup menu shown") );
2594
2595 ms_evtLoopPopup->Exit();
2596}
2597
2598#endif // wxUSE_MENUS