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