]> git.saurik.com Git - wxWidgets.git/blob - src/univ/menu.cpp
Use wxMarkupParser in wxStaticText for dealing with markup.
[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.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->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 wxMenuBase::Detach();
1211 }
1212
1213 // ----------------------------------------------------------------------------
1214 // wxMenu misc functions
1215 // ----------------------------------------------------------------------------
1216
1217 wxWindow *wxMenu::GetRootWindow() const
1218 {
1219 return GetMenuBar() ? GetMenuBar() : GetInvokingWindow();
1220 }
1221
1222 wxRenderer *wxMenu::GetRenderer() const
1223 {
1224 // we're going to crash without renderer!
1225 wxCHECK_MSG( m_popupMenu, NULL, wxT("neither popup nor menubar menu?") );
1226
1227 return m_popupMenu->GetRenderer();
1228 }
1229
1230 void wxMenu::RefreshItem(wxMenuItem *item)
1231 {
1232 // the item geometry changed, so our might have changed as well
1233 InvalidateGeometryInfo();
1234
1235 if ( IsShown() )
1236 {
1237 // this would be a bug in IsShown()
1238 wxCHECK_RET( m_popupMenu, wxT("must have popup window if shown!") );
1239
1240 // recalc geometry to update the item height and such
1241 (void)GetGeometryInfo();
1242
1243 m_popupMenu->RefreshItem(item);
1244 }
1245 }
1246
1247 // ----------------------------------------------------------------------------
1248 // wxMenu showing and hiding
1249 // ----------------------------------------------------------------------------
1250
1251 bool wxMenu::IsShown() const
1252 {
1253 return m_popupMenu && m_popupMenu->IsShown();
1254 }
1255
1256 void wxMenu::OnDismiss(bool dismissParent)
1257 {
1258 if ( m_menuParent )
1259 {
1260 // always notify the parent about submenu disappearance
1261 wxPopupMenuWindow *win = m_menuParent->m_popupMenu;
1262 if ( win )
1263 {
1264 win->OnSubmenuDismiss( true );
1265 }
1266 else
1267 {
1268 wxFAIL_MSG( wxT("parent menu not shown?") );
1269 }
1270
1271 // and if we dismiss everything, propagate to parent
1272 if ( dismissParent )
1273 {
1274 // dismissParent is recursive
1275 m_menuParent->Dismiss();
1276 m_menuParent->OnDismiss(true);
1277 }
1278 }
1279 else // no parent menu
1280 {
1281 // notify the menu bar if we're a top level menu
1282 if ( m_menuBar )
1283 {
1284 m_menuBar->OnDismissMenu(dismissParent);
1285 }
1286 else // popup menu
1287 {
1288 wxWindow * const win = GetInvokingWindow();
1289 wxCHECK_RET( win, wxT("what kind of menu is this?") );
1290
1291 win->DismissPopupMenu();
1292 }
1293 }
1294 }
1295
1296 void wxMenu::Popup(const wxPoint& pos, const wxSize& size, bool selectFirst)
1297 {
1298 // create the popup window if not done yet
1299 if ( !m_popupMenu )
1300 {
1301 m_popupMenu = new wxPopupMenuWindow(GetRootWindow(), this);
1302 }
1303
1304 // select the first item unless disabled
1305 if ( selectFirst )
1306 {
1307 m_popupMenu->SelectFirst();
1308 }
1309
1310 // the geometry might have changed since the last time we were shown, so
1311 // always resize
1312 m_popupMenu->SetClientSize(GetGeometryInfo().GetSize());
1313
1314 // position it as specified
1315 m_popupMenu->Position(pos, size);
1316
1317 // the menu can't have the focus itself (it is a Windows limitation), so
1318 // always keep the focus at the originating window
1319 wxWindow *focus = GetRootWindow();
1320
1321 wxASSERT_MSG( focus, wxT("no window to keep focus on?") );
1322
1323 // and show it
1324 m_popupMenu->Popup(focus);
1325 }
1326
1327 void wxMenu::Dismiss()
1328 {
1329 wxCHECK_RET( IsShown(), wxT("can't dismiss hidden menu") );
1330
1331 m_popupMenu->Dismiss();
1332 }
1333
1334 // ----------------------------------------------------------------------------
1335 // wxMenu event processing
1336 // ----------------------------------------------------------------------------
1337
1338 bool wxMenu::ProcessKeyDown(int key)
1339 {
1340 wxCHECK_MSG( m_popupMenu, false,
1341 wxT("can't process key events if not shown") );
1342
1343 return m_popupMenu->ProcessKeyDown(key);
1344 }
1345
1346 bool wxMenu::ClickItem(wxMenuItem *item)
1347 {
1348 int isChecked;
1349 if ( item->IsCheckable() )
1350 {
1351 // update the item state
1352 isChecked = !item->IsChecked();
1353
1354 item->Check(isChecked != 0);
1355 }
1356 else
1357 {
1358 // not applicabled
1359 isChecked = -1;
1360 }
1361
1362 return SendEvent(item->GetId(), isChecked);
1363 }
1364
1365 // ----------------------------------------------------------------------------
1366 // wxMenu accel support
1367 // ----------------------------------------------------------------------------
1368
1369 #if wxUSE_ACCEL
1370
1371 bool wxMenu::ProcessAccelEvent(const wxKeyEvent& event)
1372 {
1373 // do we have an item for this accel?
1374 wxMenuItem *item = m_accelTable.GetMenuItem(event);
1375 if ( item && item->IsEnabled() )
1376 {
1377 return ClickItem(item);
1378 }
1379
1380 // try our submenus
1381 for ( wxMenuItemIter node = GetMenuItems().GetFirst();
1382 node;
1383 node = node->GetNext() )
1384 {
1385 const wxMenuItem *item = node->GetData();
1386 if ( item->IsSubMenu() && item->IsEnabled() )
1387 {
1388 // try its elements
1389 if ( item->GetSubMenu()->ProcessAccelEvent(event) )
1390 {
1391 return true;
1392 }
1393 }
1394 }
1395
1396 return false;
1397 }
1398
1399 void wxMenu::AddAccelFor(wxMenuItem *item)
1400 {
1401 wxAcceleratorEntry *accel = item->GetAccel();
1402 if ( accel )
1403 {
1404 accel->SetMenuItem(item);
1405
1406 m_accelTable.Add(*accel);
1407
1408 delete accel;
1409 }
1410 }
1411
1412 void wxMenu::RemoveAccelFor(wxMenuItem *item)
1413 {
1414 wxAcceleratorEntry *accel = item->GetAccel();
1415 if ( accel )
1416 {
1417 m_accelTable.Remove(*accel);
1418
1419 delete accel;
1420 }
1421 }
1422
1423 #endif // wxUSE_ACCEL
1424
1425 // ----------------------------------------------------------------------------
1426 // wxMenuItem construction
1427 // ----------------------------------------------------------------------------
1428
1429 wxMenuItem::wxMenuItem(wxMenu *parentMenu,
1430 int id,
1431 const wxString& text,
1432 const wxString& help,
1433 wxItemKind kind,
1434 wxMenu *subMenu)
1435 : wxMenuItemBase(parentMenu, id, text, help, kind, subMenu)
1436 {
1437 m_posY =
1438 m_height = wxDefaultCoord;
1439
1440 m_radioGroup.start = -1;
1441 m_isRadioGroupStart = false;
1442
1443 m_bmpDisabled = wxNullBitmap;
1444
1445 UpdateAccelInfo();
1446 }
1447
1448 wxMenuItem::~wxMenuItem()
1449 {
1450 }
1451
1452 // ----------------------------------------------------------------------------
1453 // wxMenuItemBase methods implemented here
1454 // ----------------------------------------------------------------------------
1455
1456 /* static */
1457 wxMenuItem *wxMenuItemBase::New(wxMenu *parentMenu,
1458 int id,
1459 const wxString& name,
1460 const wxString& help,
1461 wxItemKind kind,
1462 wxMenu *subMenu)
1463 {
1464 return new wxMenuItem(parentMenu, id, name, help, kind, subMenu);
1465 }
1466
1467 // ----------------------------------------------------------------------------
1468 // wxMenuItem operations
1469 // ----------------------------------------------------------------------------
1470
1471 void wxMenuItem::NotifyMenu()
1472 {
1473 m_parentMenu->RefreshItem(this);
1474 }
1475
1476 void wxMenuItem::UpdateAccelInfo()
1477 {
1478 m_indexAccel = wxControl::FindAccelIndex(m_text);
1479
1480 // will be empty if the text contains no TABs - ok
1481 m_strAccel = m_text.AfterFirst(wxT('\t'));
1482 }
1483
1484 void wxMenuItem::SetItemLabel(const wxString& text)
1485 {
1486 if ( text != m_text )
1487 {
1488 // first call the base class version to change m_text
1489 // (and also check if we don't have a stock menu item)
1490 wxMenuItemBase::SetItemLabel(text);
1491
1492 UpdateAccelInfo();
1493
1494 NotifyMenu();
1495 }
1496 }
1497
1498 void wxMenuItem::SetCheckable(bool checkable)
1499 {
1500 if ( checkable != IsCheckable() )
1501 {
1502 wxMenuItemBase::SetCheckable(checkable);
1503
1504 NotifyMenu();
1505 }
1506 }
1507
1508 void wxMenuItem::SetBitmaps(const wxBitmap& bmpChecked,
1509 const wxBitmap& bmpUnchecked)
1510 {
1511 m_bmpChecked = bmpChecked;
1512 m_bmpUnchecked = bmpUnchecked;
1513
1514 NotifyMenu();
1515 }
1516
1517 void wxMenuItem::Enable(bool enable)
1518 {
1519 if ( enable != m_isEnabled )
1520 {
1521 wxMenuItemBase::Enable(enable);
1522
1523 NotifyMenu();
1524 }
1525 }
1526
1527 void wxMenuItem::Check(bool check)
1528 {
1529 wxCHECK_RET( IsCheckable(), wxT("only checkable items may be checked") );
1530
1531 if ( m_isChecked == check )
1532 return;
1533
1534 if ( GetKind() == wxITEM_RADIO )
1535 {
1536 // it doesn't make sense to uncheck a radio item - what would this do?
1537 if ( !check )
1538 return;
1539
1540 // get the index of this item in the menu
1541 const wxMenuItemList& items = m_parentMenu->GetMenuItems();
1542 int pos = items.IndexOf(this);
1543 wxCHECK_RET( pos != wxNOT_FOUND,
1544 wxT("menuitem not found in the menu items list?") );
1545
1546 // get the radio group range
1547 int start,
1548 end;
1549
1550 if ( m_isRadioGroupStart )
1551 {
1552 // we already have all information we need
1553 start = pos;
1554 end = m_radioGroup.end;
1555 }
1556 else // next radio group item
1557 {
1558 // get the radio group end from the start item
1559 start = m_radioGroup.start;
1560 end = items.Item(start)->GetData()->m_radioGroup.end;
1561 }
1562
1563 // also uncheck all the other items in this radio group
1564 wxMenuItemIter node = items.Item(start);
1565 for ( int n = start; n <= end && node; n++ )
1566 {
1567 if ( n != pos )
1568 {
1569 node->GetData()->m_isChecked = false;
1570 }
1571 node = node->GetNext();
1572 }
1573 }
1574
1575 wxMenuItemBase::Check(check);
1576
1577 NotifyMenu();
1578 }
1579
1580 // radio group stuff
1581 // -----------------
1582
1583 void wxMenuItem::SetAsRadioGroupStart()
1584 {
1585 m_isRadioGroupStart = true;
1586 }
1587
1588 void wxMenuItem::SetRadioGroupStart(int start)
1589 {
1590 wxASSERT_MSG( !m_isRadioGroupStart,
1591 wxT("should only be called for the next radio items") );
1592
1593 m_radioGroup.start = start;
1594 }
1595
1596 void wxMenuItem::SetRadioGroupEnd(int end)
1597 {
1598 wxASSERT_MSG( m_isRadioGroupStart,
1599 wxT("should only be called for the first radio item") );
1600
1601 m_radioGroup.end = end;
1602 }
1603
1604 // ----------------------------------------------------------------------------
1605 // wxMenuBar creation
1606 // ----------------------------------------------------------------------------
1607
1608 void wxMenuBar::Init()
1609 {
1610 m_frameLast = NULL;
1611
1612 m_current = -1;
1613
1614 m_menuShown = NULL;
1615
1616 m_shouldShowMenu = false;
1617 }
1618
1619 wxMenuBar::wxMenuBar(size_t n, wxMenu *menus[], const wxString titles[], long WXUNUSED(style))
1620 {
1621 Init();
1622
1623 for (size_t i = 0; i < n; ++i )
1624 Append(menus[i], titles[i]);
1625 }
1626
1627 void wxMenuBar::Attach(wxFrame *frame)
1628 {
1629 // maybe you really wanted to call Detach()?
1630 wxCHECK_RET( frame, wxT("wxMenuBar::Attach(NULL) called") );
1631
1632 wxMenuBarBase::Attach(frame);
1633
1634 if ( IsCreated() )
1635 {
1636 // reparent if necessary
1637 if ( m_frameLast != frame )
1638 {
1639 Reparent(frame);
1640 }
1641
1642 // show it back - was hidden by Detach()
1643 Show();
1644 }
1645 else // not created yet, do it now
1646 {
1647 // we have no way to return the error from here anyhow :-(
1648 (void)Create(frame, wxID_ANY);
1649
1650 SetCursor(wxCURSOR_ARROW);
1651
1652 SetFont(wxSystemSettings::GetFont(wxSYS_SYSTEM_FONT));
1653
1654 // calculate and set our height (it won't be changed any more)
1655 SetSize(wxDefaultCoord, GetBestSize().y);
1656 }
1657
1658 // remember the last frame which had us to avoid unnecessarily reparenting
1659 // above
1660 m_frameLast = frame;
1661 }
1662
1663 void wxMenuBar::Detach()
1664 {
1665 // don't delete the window because we may be reattached later, just hide it
1666 if ( m_frameLast )
1667 {
1668 Hide();
1669 }
1670
1671 wxMenuBarBase::Detach();
1672 }
1673
1674 wxMenuBar::~wxMenuBar()
1675 {
1676 }
1677
1678 // ----------------------------------------------------------------------------
1679 // wxMenuBar adding/removing items
1680 // ----------------------------------------------------------------------------
1681
1682 bool wxMenuBar::Append(wxMenu *menu, const wxString& title)
1683 {
1684 return Insert(GetCount(), menu, title);
1685 }
1686
1687 bool wxMenuBar::Insert(size_t pos, wxMenu *menu, const wxString& title)
1688 {
1689 if ( !wxMenuBarBase::Insert(pos, menu, title) )
1690 return false;
1691
1692 wxMenuInfo *info = new wxMenuInfo(title);
1693 m_menuInfos.Insert(info, pos);
1694
1695 RefreshAllItemsAfter(pos);
1696
1697 return true;
1698 }
1699
1700 wxMenu *wxMenuBar::Replace(size_t pos, wxMenu *menu, const wxString& title)
1701 {
1702 wxMenu *menuOld = wxMenuBarBase::Replace(pos, menu, title);
1703
1704 if ( menuOld )
1705 {
1706 wxMenuInfo& info = m_menuInfos[pos];
1707
1708 info.SetLabel(title);
1709
1710 // even if the old menu was disabled, the new one is not any more
1711 info.SetEnabled();
1712
1713 // even if we change only this one, the new label has different width,
1714 // so we need to refresh everything beyond this item as well
1715 RefreshAllItemsAfter(pos);
1716 }
1717
1718 return menuOld;
1719 }
1720
1721 wxMenu *wxMenuBar::Remove(size_t pos)
1722 {
1723 wxMenu *menuOld = wxMenuBarBase::Remove(pos);
1724
1725 if ( menuOld )
1726 {
1727 m_menuInfos.RemoveAt(pos);
1728
1729 // this doesn't happen too often, so don't try to be too smart - just
1730 // refresh everything
1731 Refresh();
1732 }
1733
1734 return menuOld;
1735 }
1736
1737 // ----------------------------------------------------------------------------
1738 // wxMenuBar top level menus access
1739 // ----------------------------------------------------------------------------
1740
1741 wxCoord wxMenuBar::GetItemWidth(size_t pos) const
1742 {
1743 return m_menuInfos[pos].GetWidth(wxConstCast(this, wxMenuBar));
1744 }
1745
1746 void wxMenuBar::EnableTop(size_t pos, bool enable)
1747 {
1748 wxCHECK_RET( pos < GetCount(), wxT("invalid index in EnableTop") );
1749
1750 if ( enable != m_menuInfos[pos].IsEnabled() )
1751 {
1752 m_menuInfos[pos].SetEnabled(enable);
1753
1754 RefreshItem(pos);
1755 }
1756 //else: nothing to do
1757 }
1758
1759 bool wxMenuBar::IsEnabledTop(size_t pos) const
1760 {
1761 wxCHECK_MSG( pos < GetCount(), false, wxT("invalid index in IsEnabledTop") );
1762
1763 return m_menuInfos[pos].IsEnabled();
1764 }
1765
1766 void wxMenuBar::SetMenuLabel(size_t pos, const wxString& label)
1767 {
1768 wxCHECK_RET( pos < GetCount(), wxT("invalid index in SetMenuLabel") );
1769
1770 if ( label != m_menuInfos[pos].GetOriginalLabel() )
1771 {
1772 m_menuInfos[pos].SetLabel(label);
1773
1774 RefreshItem(pos);
1775 }
1776 //else: nothing to do
1777 }
1778
1779 wxString wxMenuBar::GetMenuLabel(size_t pos) const
1780 {
1781 wxCHECK_MSG( pos < GetCount(), wxEmptyString, wxT("invalid index in GetMenuLabel") );
1782
1783 return m_menuInfos[pos].GetOriginalLabel();
1784 }
1785
1786 // ----------------------------------------------------------------------------
1787 // wxMenuBar drawing
1788 // ----------------------------------------------------------------------------
1789
1790 void wxMenuBar::RefreshAllItemsAfter(size_t pos)
1791 {
1792 if ( !IsCreated() )
1793 {
1794 // no need to refresh if nothing is shown yet
1795 return;
1796 }
1797
1798 wxRect rect = GetItemRect(pos);
1799 rect.width = GetClientSize().x - rect.x;
1800 RefreshRect(rect);
1801 }
1802
1803 void wxMenuBar::RefreshItem(size_t pos)
1804 {
1805 wxCHECK_RET( pos != (size_t)-1,
1806 wxT("invalid item in wxMenuBar::RefreshItem") );
1807
1808 if ( !IsCreated() )
1809 {
1810 // no need to refresh if nothing is shown yet
1811 return;
1812 }
1813
1814 RefreshRect(GetItemRect(pos));
1815 }
1816
1817 void wxMenuBar::DoDraw(wxControlRenderer *renderer)
1818 {
1819 wxDC& dc = renderer->GetDC();
1820 dc.SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
1821
1822 // redraw only the items which must be redrawn
1823
1824 // we don't have to use GetUpdateClientRect() here because our client rect
1825 // is the same as total one
1826 wxRect rectUpdate = GetUpdateRegion().GetBox();
1827
1828 int flagsMenubar = GetStateFlags();
1829
1830 wxRect rect;
1831 rect.y = 0;
1832 rect.height = GetClientSize().y;
1833
1834 wxCoord x = 0;
1835 size_t count = GetCount();
1836 for ( size_t n = 0; n < count; n++ )
1837 {
1838 if ( x > rectUpdate.GetRight() )
1839 {
1840 // all remaining items are to the right of rectUpdate
1841 break;
1842 }
1843
1844 rect.x = x;
1845 rect.width = GetItemWidth(n);
1846 x += rect.width;
1847 if ( x < rectUpdate.x )
1848 {
1849 // this item is still to the left of rectUpdate
1850 continue;
1851 }
1852
1853 int flags = flagsMenubar;
1854 if ( m_current != -1 && n == (size_t)m_current )
1855 {
1856 flags |= wxCONTROL_SELECTED;
1857 }
1858
1859 if ( !IsEnabledTop(n) )
1860 {
1861 flags |= wxCONTROL_DISABLED;
1862 }
1863
1864 GetRenderer()->DrawMenuBarItem
1865 (
1866 dc,
1867 rect,
1868 m_menuInfos[n].GetLabel(),
1869 flags,
1870 m_menuInfos[n].GetAccelIndex()
1871 );
1872 }
1873 }
1874
1875 // ----------------------------------------------------------------------------
1876 // wxMenuBar geometry
1877 // ----------------------------------------------------------------------------
1878
1879 wxRect wxMenuBar::GetItemRect(size_t pos) const
1880 {
1881 wxASSERT_MSG( pos < GetCount(), wxT("invalid menu bar item index") );
1882 wxASSERT_MSG( IsCreated(), wxT("can't call this method yet") );
1883
1884 wxRect rect;
1885 rect.x =
1886 rect.y = 0;
1887 rect.height = GetClientSize().y;
1888
1889 for ( size_t n = 0; n < pos; n++ )
1890 {
1891 rect.x += GetItemWidth(n);
1892 }
1893
1894 rect.width = GetItemWidth(pos);
1895
1896 return rect;
1897 }
1898
1899 wxSize wxMenuBar::DoGetBestClientSize() const
1900 {
1901 wxSize size;
1902 if ( GetMenuCount() > 0 )
1903 {
1904 wxClientDC dc(wxConstCast(this, wxMenuBar));
1905 dc.SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
1906 dc.GetTextExtent(GetMenuLabel(0), &size.x, &size.y);
1907
1908 // adjust for the renderer we use
1909 size = GetRenderer()->GetMenuBarItemSize(size);
1910 }
1911 else // empty menubar
1912 {
1913 size.x =
1914 size.y = 0;
1915 }
1916
1917 // the width is arbitrary, of course, for horizontal menubar
1918 size.x = 100;
1919
1920 return size;
1921 }
1922
1923 int wxMenuBar::GetMenuFromPoint(const wxPoint& pos) const
1924 {
1925 if ( pos.x < 0 || pos.y < 0 || pos.y > GetClientSize().y )
1926 return -1;
1927
1928 // do find it
1929 wxCoord x = 0;
1930 size_t count = GetCount();
1931 for ( size_t item = 0; item < count; item++ )
1932 {
1933 x += GetItemWidth(item);
1934
1935 if ( x > pos.x )
1936 {
1937 return item;
1938 }
1939 }
1940
1941 // to the right of the last menu item
1942 return -1;
1943 }
1944
1945 // ----------------------------------------------------------------------------
1946 // wxMenuBar menu operations
1947 // ----------------------------------------------------------------------------
1948
1949 void wxMenuBar::SelectMenu(size_t pos)
1950 {
1951 SetFocus();
1952 wxLogTrace(wxT("mousecapture"), wxT("Capturing mouse from wxMenuBar::SelectMenu"));
1953 CaptureMouse();
1954
1955 DoSelectMenu(pos);
1956 }
1957
1958 void wxMenuBar::DoSelectMenu(size_t pos)
1959 {
1960 wxCHECK_RET( pos < GetCount(), wxT("invalid menu index in DoSelectMenu") );
1961
1962 int posOld = m_current;
1963
1964 m_current = pos;
1965
1966 if ( posOld != -1 )
1967 {
1968 // close the previous menu
1969 if ( IsShowingMenu() )
1970 {
1971 // restore m_shouldShowMenu flag after DismissMenu() which resets
1972 // it to false
1973 bool old = m_shouldShowMenu;
1974
1975 DismissMenu();
1976
1977 m_shouldShowMenu = old;
1978 }
1979
1980 RefreshItem((size_t)posOld);
1981 }
1982
1983 RefreshItem(pos);
1984 }
1985
1986 void wxMenuBar::PopupMenu(size_t pos)
1987 {
1988 wxCHECK_RET( pos < GetCount(), wxT("invalid menu index in PopupCurrentMenu") );
1989
1990 SetFocus();
1991 DoSelectMenu(pos);
1992 PopupCurrentMenu();
1993 }
1994
1995 // ----------------------------------------------------------------------------
1996 // wxMenuBar input handing
1997 // ----------------------------------------------------------------------------
1998
1999 /*
2000 Note that wxMenuBar doesn't use wxInputHandler but handles keyboard and
2001 mouse in the same way under all platforms. This is because it doesn't derive
2002 from wxControl (which works with input handlers) but directly from wxWindow.
2003
2004 Also, menu bar input handling is rather simple, so maybe it's not really
2005 worth making it themeable - at least I've decided against doing it now as it
2006 would merging the changes back into trunk more difficult. But it still could
2007 be done later if really needed.
2008 */
2009
2010 void wxMenuBar::OnKillFocus(wxFocusEvent& event)
2011 {
2012 if ( m_current != -1 )
2013 {
2014 RefreshItem((size_t)m_current);
2015
2016 m_current = -1;
2017 }
2018
2019 event.Skip();
2020 }
2021
2022 void wxMenuBar::OnLeftDown(wxMouseEvent& event)
2023 {
2024 if ( HasCapture() )
2025 {
2026 OnDismiss();
2027
2028 event.Skip();
2029 }
2030 else // we didn't have mouse capture, capture it now
2031 {
2032 m_current = GetMenuFromPoint(event.GetPosition());
2033 if ( m_current == -1 )
2034 {
2035 // unfortunately, we can't prevent wxMSW from giving us the focus,
2036 // so we can only give it back
2037 GiveAwayFocus();
2038 }
2039 else // on item
2040 {
2041 wxLogTrace(wxT("mousecapture"), wxT("Capturing mouse from wxMenuBar::OnLeftDown"));
2042 CaptureMouse();
2043
2044 // show it as selected
2045 RefreshItem((size_t)m_current);
2046
2047 // show the menu
2048 PopupCurrentMenu(false /* don't select first item - as Windows does */);
2049 }
2050 }
2051 }
2052
2053 void wxMenuBar::OnMouseMove(wxMouseEvent& event)
2054 {
2055 if ( HasCapture() )
2056 {
2057 (void)ProcessMouseEvent(event.GetPosition());
2058 }
2059 else
2060 {
2061 event.Skip();
2062 }
2063 }
2064
2065 bool wxMenuBar::ProcessMouseEvent(const wxPoint& pt)
2066 {
2067 // a hack to ignore the extra mouse events MSW sends us: this is similar to
2068 // wxUSE_MOUSEEVENT_HACK in wxWin itself but it isn't enough for us here as
2069 // we get the messages from different windows (old and new popup menus for
2070 // example)
2071 #ifdef __WXMSW__
2072 static wxPoint s_ptLast;
2073 if ( pt == s_ptLast )
2074 {
2075 return false;
2076 }
2077
2078 s_ptLast = pt;
2079 #endif // __WXMSW__
2080
2081 int currentNew = GetMenuFromPoint(pt);
2082 if ( (currentNew == -1) || (currentNew == m_current) )
2083 {
2084 return false;
2085 }
2086
2087 // select the new active item
2088 DoSelectMenu(currentNew);
2089
2090 // show the menu if we know that we should, even if we hadn't been showing
2091 // it before (this may happen if the previous menu was disabled)
2092 if ( m_shouldShowMenu && !m_menuShown)
2093 {
2094 // open the new menu if the old one we closed had been opened
2095 PopupCurrentMenu(false /* don't select first item - as Windows does */);
2096 }
2097
2098 return true;
2099 }
2100
2101 void wxMenuBar::OnKeyDown(wxKeyEvent& event)
2102 {
2103 // ensure that we have a current item - we might not have it if we're
2104 // given the focus with Alt or F10 press (and under GTK+ the menubar
2105 // somehow gets the keyboard events even when it doesn't have focus...)
2106 if ( m_current == -1 )
2107 {
2108 if ( !HasCapture() )
2109 {
2110 SelectMenu(0);
2111 }
2112 else // we do have capture
2113 {
2114 // we always maintain a valid current item while we're in modal
2115 // state (i.e. have the capture)
2116 wxFAIL_MSG( wxT("how did we manage to lose current item?") );
2117
2118 return;
2119 }
2120 }
2121
2122 int key = event.GetKeyCode();
2123
2124 // first let the menu have it
2125 if ( IsShowingMenu() && m_menuShown->ProcessKeyDown(key) )
2126 {
2127 return;
2128 }
2129
2130 // cycle through the menu items when left/right arrows are pressed and open
2131 // the menu when up/down one is
2132 switch ( key )
2133 {
2134 case WXK_ALT:
2135 // Alt must be processed at wxWindow level too
2136 event.Skip();
2137 // fall through
2138
2139 case WXK_ESCAPE:
2140 // remove the selection and give the focus away
2141 if ( m_current != -1 )
2142 {
2143 if ( IsShowingMenu() )
2144 {
2145 DismissMenu();
2146 }
2147
2148 OnDismiss();
2149 }
2150 break;
2151
2152 case WXK_LEFT:
2153 case WXK_RIGHT:
2154 {
2155 size_t count = GetCount();
2156 if ( count == 1 )
2157 {
2158 // the item won't change anyhow
2159 break;
2160 }
2161 //else: otherwise, it will
2162
2163 // remember if we were showing a menu - if we did, we should
2164 // show the new menu after changing the item
2165 bool wasMenuOpened = IsShowingMenu();
2166 if ( wasMenuOpened )
2167 {
2168 DismissMenu();
2169 }
2170
2171 // cast is safe as we tested for -1 above
2172 size_t currentNew = (size_t)m_current;
2173
2174 if ( key == WXK_LEFT )
2175 {
2176 if ( currentNew-- == 0 )
2177 currentNew = count - 1;
2178 }
2179 else // right
2180 {
2181 if ( ++currentNew == count )
2182 currentNew = 0;
2183 }
2184
2185 DoSelectMenu(currentNew);
2186
2187 if ( wasMenuOpened )
2188 {
2189 PopupCurrentMenu();
2190 }
2191 }
2192 break;
2193
2194 case WXK_DOWN:
2195 case WXK_UP:
2196 case WXK_RETURN:
2197 // open the menu
2198 PopupCurrentMenu();
2199 break;
2200
2201 default:
2202 // letters open the corresponding menu
2203 {
2204 bool unique;
2205 int idxFound = FindNextItemForAccel(m_current, key, &unique);
2206
2207 if ( idxFound != -1 )
2208 {
2209 if ( IsShowingMenu() )
2210 {
2211 DismissMenu();
2212 }
2213
2214 DoSelectMenu((size_t)idxFound);
2215
2216 // if the item is not unique, just select it but don't
2217 // activate as the user might have wanted to activate
2218 // another item
2219 //
2220 // also, don't try to open a disabled menu
2221 if ( unique && IsEnabledTop((size_t)idxFound) )
2222 {
2223 // open the menu
2224 PopupCurrentMenu();
2225 }
2226
2227 // skip the "event.Skip()" below
2228 break;
2229 }
2230 }
2231
2232 event.Skip();
2233 }
2234 }
2235
2236 // ----------------------------------------------------------------------------
2237 // wxMenuBar accel handling
2238 // ----------------------------------------------------------------------------
2239
2240 int wxMenuBar::FindNextItemForAccel(int idxStart, int key, bool *unique) const
2241 {
2242 if ( !wxIsalnum((wxChar)key) )
2243 {
2244 // we only support letters/digits as accels
2245 return -1;
2246 }
2247
2248 // do we have more than one item with this accel?
2249 if ( unique )
2250 *unique = true;
2251
2252 // translate everything to lower case before comparing
2253 wxChar chAccel = (wxChar)wxTolower(key);
2254
2255 // the index of the item with this accel
2256 int idxFound = -1;
2257
2258 // loop through all items searching for the item with this
2259 // accel starting at the item after the current one
2260 int count = GetCount();
2261 int n = idxStart == -1 ? 0 : idxStart + 1;
2262
2263 if ( n == count )
2264 {
2265 // wrap
2266 n = 0;
2267 }
2268
2269 idxStart = n;
2270 for ( ;; )
2271 {
2272 const wxMenuInfo& info = m_menuInfos[n];
2273
2274 int idxAccel = info.GetAccelIndex();
2275 if ( idxAccel != -1 &&
2276 (wxChar)wxTolower(info.GetLabel()[(size_t)idxAccel]) == chAccel )
2277 {
2278 // ok, found an item with this accel
2279 if ( idxFound == -1 )
2280 {
2281 // store it but continue searching as we need to
2282 // know if it's the only item with this accel or if
2283 // there are more
2284 idxFound = n;
2285 }
2286 else // we already had found such item
2287 {
2288 if ( unique )
2289 *unique = false;
2290
2291 // no need to continue further, we won't find
2292 // anything we don't already know
2293 break;
2294 }
2295 }
2296
2297 // we want to iterate over all items wrapping around if
2298 // necessary
2299 if ( ++n == count )
2300 {
2301 // wrap
2302 n = 0;
2303 }
2304
2305 if ( n == idxStart )
2306 {
2307 // we've seen all items
2308 break;
2309 }
2310 }
2311
2312 return idxFound;
2313 }
2314
2315 #if wxUSE_ACCEL
2316
2317 bool wxMenuBar::ProcessAccelEvent(const wxKeyEvent& event)
2318 {
2319 size_t n = 0;
2320 for ( wxMenuList::compatibility_iterator node = m_menus.GetFirst();
2321 node;
2322 node = node->GetNext(), n++ )
2323 {
2324 // accels of the items in the disabled menus shouldn't work
2325 if ( m_menuInfos[n].IsEnabled() )
2326 {
2327 if ( node->GetData()->ProcessAccelEvent(event) )
2328 {
2329 // menu processed it
2330 return true;
2331 }
2332 }
2333 }
2334
2335 // not found
2336 return false;
2337 }
2338
2339 #endif // wxUSE_ACCEL
2340
2341 // ----------------------------------------------------------------------------
2342 // wxMenuBar menus showing
2343 // ----------------------------------------------------------------------------
2344
2345 void wxMenuBar::PopupCurrentMenu(bool selectFirst)
2346 {
2347 wxCHECK_RET( m_current != -1, wxT("no menu to popup") );
2348
2349 // forgot to call DismissMenu()?
2350 wxASSERT_MSG( !m_menuShown, wxT("shouldn't show two menus at once!") );
2351
2352 // in any case, we should show it - even if we won't
2353 m_shouldShowMenu = true;
2354
2355 if ( IsEnabledTop(m_current) )
2356 {
2357 // remember the menu we show
2358 m_menuShown = GetMenu(m_current);
2359
2360 // we don't show the menu at all if it has no items
2361 if ( !m_menuShown->IsEmpty() )
2362 {
2363 // position it correctly: note that we must use screen coords and
2364 // that we pass 0 as width to position the menu exactly below the
2365 // item, not to the right of it
2366 wxRect rectItem = GetItemRect(m_current);
2367
2368 m_menuShown->Popup(ClientToScreen(rectItem.GetPosition()),
2369 wxSize(0, rectItem.GetHeight()),
2370 selectFirst);
2371 }
2372 else
2373 {
2374 // reset it back as no menu is shown
2375 m_menuShown = NULL;
2376 }
2377 }
2378 //else: don't show disabled menu
2379 }
2380
2381 void wxMenuBar::DismissMenu()
2382 {
2383 wxCHECK_RET( m_menuShown, wxT("can't dismiss menu if none is shown") );
2384
2385 m_menuShown->Dismiss();
2386 OnDismissMenu();
2387 }
2388
2389 void wxMenuBar::OnDismissMenu(bool dismissMenuBar)
2390 {
2391 m_shouldShowMenu = false;
2392 m_menuShown = NULL;
2393 if ( dismissMenuBar )
2394 {
2395 OnDismiss();
2396 }
2397 }
2398
2399 void wxMenuBar::OnDismiss()
2400 {
2401 if ( ReleaseMouseCapture() )
2402 {
2403 wxLogTrace(wxT("mousecapture"), wxT("Releasing mouse from wxMenuBar::OnDismiss"));
2404 }
2405
2406 if ( m_current != -1 )
2407 {
2408 size_t current = m_current;
2409 m_current = -1;
2410
2411 RefreshItem(current);
2412 }
2413
2414 GiveAwayFocus();
2415 }
2416
2417 bool wxMenuBar::ReleaseMouseCapture()
2418 {
2419 #ifdef __WXX11__
2420 // With wxX11, when a menu is closed by clicking away from it, a control
2421 // under the click will still get an event, even though the menu has the
2422 // capture (bug?). So that control may already have taken the capture by
2423 // this point, preventing us from releasing the menu's capture. So to work
2424 // around this, we release both captures, then put back the control's
2425 // capture.
2426 wxWindow *capture = GetCapture();
2427 if ( capture )
2428 {
2429 capture->ReleaseMouse();
2430
2431 if ( capture == this )
2432 return true;
2433
2434 bool had = HasCapture();
2435
2436 if ( had )
2437 ReleaseMouse();
2438
2439 capture->CaptureMouse();
2440
2441 return had;
2442 }
2443 #else
2444 if ( HasCapture() )
2445 {
2446 ReleaseMouse();
2447 return true;
2448 }
2449 #endif
2450 return false;
2451 }
2452
2453 void wxMenuBar::GiveAwayFocus()
2454 {
2455 GetFrame()->SetFocus();
2456 }
2457
2458 // ----------------------------------------------------------------------------
2459 // popup menu support
2460 // ----------------------------------------------------------------------------
2461
2462 wxEventLoop *wxWindow::ms_evtLoopPopup = NULL;
2463
2464 bool wxWindow::DoPopupMenu(wxMenu *menu, int x, int y)
2465 {
2466 wxCHECK_MSG( !ms_evtLoopPopup, false,
2467 wxT("can't show more than one popup menu at a time") );
2468
2469 #ifdef __WXMSW__
2470 // we need to change the cursor before showing the menu as, apparently, no
2471 // cursor changes took place while the mouse is captured
2472 wxCursor cursorOld = GetCursor();
2473 SetCursor(wxCURSOR_ARROW);
2474 #endif // __WXMSW__
2475
2476 #if 0
2477 // flash any delayed log messages before showing the menu, otherwise it
2478 // could be dismissed (because it would lose focus) immediately after being
2479 // shown
2480 wxLog::FlushActive();
2481
2482 // some controls update themselves from OnIdle() call - let them do it
2483 wxTheApp->ProcessIdle();
2484
2485 // if the window hadn't been refreshed yet, the menu can adversely affect
2486 // its next OnPaint() handler execution - i.e. scrolled window refresh
2487 // logic breaks then as it scrolls part of the menu which hadn't been there
2488 // when the update event was generated into view
2489 Update();
2490 #endif // 0
2491
2492 menu->Popup(ClientToScreen(wxPoint(x, y)), wxSize(0,0));
2493
2494 // this is not very useful if the menu was popped up because of the mouse
2495 // click but I think it is nice to do when it appears because of a key
2496 // press (i.e. Windows menu key)
2497 //
2498 // Windows itself doesn't do it, but IMHO this is nice
2499 WarpPointer(x, y);
2500
2501 // we have to redirect all keyboard input to the menu temporarily
2502 PushEventHandler(new wxMenuKbdRedirector(menu));
2503
2504 // enter the local modal loop
2505 ms_evtLoopPopup = new wxEventLoop;
2506 ms_evtLoopPopup->Run();
2507
2508 wxDELETE(ms_evtLoopPopup);
2509
2510 // remove the handler
2511 PopEventHandler(true /* delete it */);
2512
2513 #ifdef __WXMSW__
2514 SetCursor(cursorOld);
2515 #endif // __WXMSW__
2516
2517 return true;
2518 }
2519
2520 void wxWindow::DismissPopupMenu()
2521 {
2522 wxCHECK_RET( ms_evtLoopPopup, wxT("no popup menu shown") );
2523
2524 ms_evtLoopPopup->Exit();
2525 }
2526
2527 #endif // wxUSE_MENUS