]> git.saurik.com Git - wxWidgets.git/blob - src/univ/menu.cpp
Return after activating already opened document in wxDocManager.
[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 IMPLEMENT_DYNAMIC_CLASS(wxMenu, wxEvtHandler)
285 IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxWindow)
286 IMPLEMENT_DYNAMIC_CLASS(wxMenuItem, wxObject)
287
288 BEGIN_EVENT_TABLE(wxPopupMenuWindow, wxPopupTransientWindow)
289 EVT_KEY_DOWN(wxPopupMenuWindow::OnKeyDown)
290
291 EVT_LEFT_UP(wxPopupMenuWindow::OnLeftUp)
292 EVT_MOTION(wxPopupMenuWindow::OnMouseMove)
293 EVT_LEAVE_WINDOW(wxPopupMenuWindow::OnMouseLeave)
294 #ifdef __WXMSW__
295 EVT_IDLE(wxPopupMenuWindow::OnIdle)
296 #endif
297 END_EVENT_TABLE()
298
299 BEGIN_EVENT_TABLE(wxMenuBar, wxMenuBarBase)
300 EVT_KILL_FOCUS(wxMenuBar::OnKillFocus)
301
302 EVT_KEY_DOWN(wxMenuBar::OnKeyDown)
303
304 EVT_LEFT_DOWN(wxMenuBar::OnLeftDown)
305 EVT_MOTION(wxMenuBar::OnMouseMove)
306 END_EVENT_TABLE()
307
308 // ============================================================================
309 // implementation
310 // ============================================================================
311
312 // ----------------------------------------------------------------------------
313 // wxPopupMenuWindow
314 // ----------------------------------------------------------------------------
315
316 wxPopupMenuWindow::wxPopupMenuWindow(wxWindow *parent, wxMenu *menu)
317 {
318 m_menu = menu;
319 m_hasOpenSubMenu = false;
320
321 ResetCurrent();
322
323 (void)Create(parent, wxBORDER_RAISED);
324
325 SetCursor(wxCURSOR_ARROW);
326 }
327
328 wxPopupMenuWindow::~wxPopupMenuWindow()
329 {
330 // When m_popupMenu in wxMenu is deleted because it
331 // is a child of an old menu bar being deleted (note: it does
332 // not get destroyed by the wxMenu destructor, but
333 // by DestroyChildren()), m_popupMenu should be reset to NULL.
334
335 m_menu->m_popupMenu = NULL;
336 }
337
338 // ----------------------------------------------------------------------------
339 // wxPopupMenuWindow current item/node handling
340 // ----------------------------------------------------------------------------
341
342 void wxPopupMenuWindow::ResetCurrent()
343 {
344 SetCurrentItem(wxMenuItemIter());
345 }
346
347 void wxPopupMenuWindow::SetCurrentItem(wxMenuItemIter node)
348 {
349 m_nodeCurrent = node;
350 }
351
352 void wxPopupMenuWindow::ChangeCurrent(wxMenuItemIter node)
353 {
354 if ( !m_nodeCurrent || !node || (node != m_nodeCurrent) )
355 {
356 wxMenuItemIter nodeOldCurrent = m_nodeCurrent;
357
358 m_nodeCurrent = node;
359
360 if ( nodeOldCurrent )
361 {
362 wxMenuItem *item = nodeOldCurrent->GetData();
363 wxCHECK_RET( item, wxT("no current item?") );
364
365 // if it was the currently opened menu, close it
366 if ( item->IsSubMenu() && item->GetSubMenu()->IsShown() )
367 {
368 item->GetSubMenu()->Dismiss();
369 OnSubmenuDismiss( false );
370 }
371
372 RefreshItem(item);
373 }
374
375 if ( m_nodeCurrent )
376 RefreshItem(m_nodeCurrent->GetData());
377 }
378 }
379
380 wxMenuItemIter wxPopupMenuWindow::GetPrevNode() const
381 {
382 // return the last node if there had been no previously selected one
383 return m_nodeCurrent ? GetPrevNode(m_nodeCurrent)
384 : wxMenuItemIter(m_menu->GetMenuItems().GetLast());
385 }
386
387 wxMenuItemIter
388 wxPopupMenuWindow::GetPrevNode(wxMenuItemIter node) const
389 {
390 if ( node )
391 {
392 node = node->GetPrevious();
393 if ( !node )
394 {
395 node = m_menu->GetMenuItems().GetLast();
396 }
397 }
398 //else: the menu is empty
399
400 return node;
401 }
402
403 wxMenuItemIter wxPopupMenuWindow::GetNextNode() const
404 {
405 // return the first node if there had been no previously selected one
406 return m_nodeCurrent ? GetNextNode(m_nodeCurrent)
407 : wxMenuItemIter(m_menu->GetMenuItems().GetFirst());
408 }
409
410 wxMenuItemIter
411 wxPopupMenuWindow::GetNextNode(wxMenuItemIter node) const
412 {
413 if ( node )
414 {
415 node = node->GetNext();
416 if ( !node )
417 {
418 node = m_menu->GetMenuItems().GetFirst();
419 }
420 }
421 //else: the menu is empty
422
423 return node;
424 }
425
426 // ----------------------------------------------------------------------------
427 // wxPopupMenuWindow popup/dismiss
428 // ----------------------------------------------------------------------------
429
430 void wxPopupMenuWindow::Popup(wxWindow *focus)
431 {
432 // check that the current item had been properly reset before
433 wxASSERT_MSG( !m_nodeCurrent ||
434 m_nodeCurrent == m_menu->GetMenuItems().GetFirst(),
435 wxT("menu current item preselected incorrectly") );
436
437 wxPopupTransientWindow::Popup(focus);
438
439 // the base class no-longer captures the mouse automatically when Popup
440 // is called, so do it here to allow the menu tracking to work
441 if ( !HasCapture() )
442 CaptureMouse();
443
444 #ifdef __WXMSW__
445 // ensure that this window is really on top of everything: without using
446 // SetWindowPos() it can be covered by its parent menu which is not
447 // really what we want
448 wxMenu *menuParent = m_menu->GetParent();
449 if ( menuParent )
450 {
451 wxPopupMenuWindow *win = menuParent->m_popupMenu;
452
453 // if we're shown, the parent menu must be also shown
454 wxCHECK_RET( win, wxT("parent menu is not shown?") );
455
456 if ( !::SetWindowPos(GetHwndOf(win), GetHwnd(),
457 0, 0, 0, 0,
458 SWP_NOMOVE | SWP_NOSIZE | SWP_NOREDRAW) )
459 {
460 wxLogLastError(wxT("SetWindowPos(HWND_TOP)"));
461 }
462
463 Refresh();
464 }
465 #endif // __WXMSW__
466 }
467
468 void wxPopupMenuWindow::Dismiss()
469 {
470 if ( HasOpenSubmenu() )
471 {
472 wxMenuItem *item = GetCurrentItem();
473 wxCHECK_RET( item && item->IsSubMenu(), wxT("where is our open submenu?") );
474
475 wxPopupMenuWindow *win = item->GetSubMenu()->m_popupMenu;
476 wxCHECK_RET( win, wxT("opened submenu is not opened?") );
477
478 win->Dismiss();
479 OnSubmenuDismiss( false );
480 }
481
482 wxPopupTransientWindow::Dismiss();
483
484 ResetCurrent();
485 }
486
487 void wxPopupMenuWindow::OnDismiss()
488 {
489 // when we are dismissed because the user clicked elsewhere or we lost
490 // focus in any other way, hide the parent menu as well
491 HandleDismiss(true);
492 }
493
494 void wxPopupMenuWindow::OnSubmenuDismiss(bool WXUNUSED(dismissParent))
495 {
496 m_hasOpenSubMenu = false;
497 }
498
499 void wxPopupMenuWindow::HandleDismiss(bool dismissParent)
500 {
501 m_menu->OnDismiss(dismissParent);
502 }
503
504 void wxPopupMenuWindow::DismissAndNotify()
505 {
506 Dismiss();
507 HandleDismiss(true);
508 }
509
510 // ----------------------------------------------------------------------------
511 // wxPopupMenuWindow geometry
512 // ----------------------------------------------------------------------------
513
514 wxMenuItemIter
515 wxPopupMenuWindow::GetMenuItemFromPoint(const wxPoint& pt) const
516 {
517 // we only use the y coord normally, but still check x in case the point is
518 // outside the window completely
519 if ( wxWindow::HitTest(pt) == wxHT_WINDOW_INSIDE )
520 {
521 wxCoord y = 0;
522 for ( wxMenuItemIter node = m_menu->GetMenuItems().GetFirst();
523 node;
524 node = node->GetNext() )
525 {
526 wxMenuItem *item = node->GetData();
527 y += item->GetHeight();
528 if ( y > pt.y )
529 {
530 // found
531 return node;
532 }
533 }
534 }
535
536 return wxMenuItemIter();
537 }
538
539 // ----------------------------------------------------------------------------
540 // wxPopupMenuWindow drawing
541 // ----------------------------------------------------------------------------
542
543 void wxPopupMenuWindow::RefreshItem(wxMenuItem *item)
544 {
545 wxCHECK_RET( item, wxT("can't refresh NULL item") );
546
547 wxASSERT_MSG( IsShown(), wxT("can't refresh menu which is not shown") );
548
549 // FIXME: -1 here because of SetLogicalOrigin(1, 1) in DoDraw()
550 RefreshRect(wxRect(0, item->GetPosition() - 1,
551 m_menu->GetGeometryInfo().GetSize().x, item->GetHeight()));
552 }
553
554 void wxPopupMenuWindow::DoDraw(wxControlRenderer *renderer)
555 {
556 // no clipping so far - do we need it? I don't think so as the menu is
557 // never partially covered as it is always on top of everything
558
559 wxDC& dc = renderer->GetDC();
560 dc.SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
561
562 // FIXME: this should be done in the renderer, however when it is fixed
563 // wxPopupMenuWindow::RefreshItem() should be changed too!
564 dc.SetLogicalOrigin(1, 1);
565
566 wxRenderer *rend = renderer->GetRenderer();
567
568 wxCoord y = 0;
569 const wxMenuGeometryInfo& gi = m_menu->GetGeometryInfo();
570 for ( wxMenuItemIter node = m_menu->GetMenuItems().GetFirst();
571 node;
572 node = node->GetNext() )
573 {
574 wxMenuItem *item = node->GetData();
575
576 if ( item->IsSeparator() )
577 {
578 rend->DrawMenuSeparator(dc, y, gi);
579 }
580 else // not a separator
581 {
582 int flags = 0;
583 if ( item->IsCheckable() )
584 {
585 flags |= wxCONTROL_CHECKABLE;
586
587 if ( item->IsChecked() )
588 {
589 flags |= wxCONTROL_CHECKED;
590 }
591 }
592
593 if ( !item->IsEnabled() )
594 flags |= wxCONTROL_DISABLED;
595
596 if ( item->IsSubMenu() )
597 flags |= wxCONTROL_ISSUBMENU;
598
599 if ( item == GetCurrentItem() )
600 flags |= wxCONTROL_SELECTED;
601
602 wxBitmap bmp;
603
604 if ( !item->IsEnabled() )
605 {
606 bmp = item->GetDisabledBitmap();
607 }
608
609 if ( !bmp.Ok() )
610 {
611 // strangely enough, for unchecked item we use the
612 // "checked" bitmap because this is the default one - this
613 // explains this strange boolean expression
614 bmp = item->GetBitmap(!item->IsCheckable() || item->IsChecked());
615 }
616
617 rend->DrawMenuItem
618 (
619 dc,
620 y,
621 gi,
622 item->GetItemLabelText(),
623 item->GetAccelString(),
624 bmp,
625 flags,
626 item->GetAccelIndex()
627 );
628 }
629
630 y += item->GetHeight();
631 }
632 }
633
634 // ----------------------------------------------------------------------------
635 // wxPopupMenuWindow actions
636 // ----------------------------------------------------------------------------
637
638 void wxPopupMenuWindow::ClickItem(wxMenuItem *item)
639 {
640 wxCHECK_RET( item, wxT("can't click NULL item") );
641
642 wxASSERT_MSG( !item->IsSeparator() && !item->IsSubMenu(),
643 wxT("can't click this item") );
644
645 wxMenu* menu = m_menu;
646
647 // close all menus
648 DismissAndNotify();
649
650 menu->ClickItem(item);
651 }
652
653 void wxPopupMenuWindow::OpenSubmenu(wxMenuItem *item, InputMethod how)
654 {
655 wxCHECK_RET( item, wxT("can't open NULL submenu") );
656
657 wxMenu *submenu = item->GetSubMenu();
658 wxCHECK_RET( submenu, wxT("can only open submenus!") );
659
660 // FIXME: should take into account the border width
661 submenu->Popup(ClientToScreen(wxPoint(0, item->GetPosition())),
662 wxSize(m_menu->GetGeometryInfo().GetSize().x, 0),
663 how == WithKeyboard /* preselect first item then */);
664
665 m_hasOpenSubMenu = true;
666 }
667
668 bool wxPopupMenuWindow::ActivateItem(wxMenuItem *item, InputMethod how)
669 {
670 // don't activate disabled items
671 if ( !item || !item->IsEnabled() )
672 {
673 return false;
674 }
675
676 // normal menu items generate commands, submenus can be opened and
677 // the separators don't do anything
678 if ( item->IsSubMenu() )
679 {
680 OpenSubmenu(item, how);
681 }
682 else if ( !item->IsSeparator() )
683 {
684 ClickItem(item);
685 }
686 else // separator, can't activate
687 {
688 return false;
689 }
690
691 return true;
692 }
693
694 // ----------------------------------------------------------------------------
695 // wxPopupMenuWindow input handling
696 // ----------------------------------------------------------------------------
697
698 bool wxPopupMenuWindow::ProcessLeftDown(wxMouseEvent& event)
699 {
700 // wxPopupWindowHandler dismisses the window when the mouse is clicked
701 // outside it which is usually just fine, but there is one case when we
702 // don't want to do it: if the mouse was clicked on the parent submenu item
703 // which opens this menu, so check for it
704
705 wxPoint pos = event.GetPosition();
706 if ( HitTest(pos.x, pos.y) == wxHT_WINDOW_OUTSIDE )
707 {
708 wxMenu *menu = m_menu->GetParent();
709 if ( menu )
710 {
711 wxPopupMenuWindow *win = menu->m_popupMenu;
712
713 wxCHECK_MSG( win, false, wxT("parent menu not shown?") );
714
715 pos = ClientToScreen(pos);
716 if ( win->GetMenuItemFromPoint(win->ScreenToClient(pos)) )
717 {
718 // eat the event
719 return true;
720 }
721 //else: it is outside the parent menu as well, do dismiss this one
722 }
723 }
724
725 return false;
726 }
727
728 void wxPopupMenuWindow::OnLeftUp(wxMouseEvent& event)
729 {
730 wxMenuItemIter node = GetMenuItemFromPoint(event.GetPosition());
731 if ( node )
732 {
733 ActivateItem(node->GetData(), WithMouse);
734 }
735 }
736
737 void wxPopupMenuWindow::OnMouseMove(wxMouseEvent& event)
738 {
739 const wxPoint pt = event.GetPosition();
740
741 // we need to ignore extra mouse events: example when this happens is when
742 // the mouse is on the menu and we open a submenu from keyboard - Windows
743 // then sends us a dummy mouse move event, we (correctly) determine that it
744 // happens in the parent menu and so immediately close the just opened
745 // submenu!
746 #ifdef __WXMSW__
747 static wxPoint s_ptLast;
748 wxPoint ptCur = ClientToScreen(pt);
749 if ( ptCur == s_ptLast )
750 {
751 return;
752 }
753
754 s_ptLast = ptCur;
755 #endif // __WXMSW__
756
757 ProcessMouseMove(pt);
758
759 event.Skip();
760 }
761
762 void wxPopupMenuWindow::ProcessMouseMove(const wxPoint& pt)
763 {
764 wxMenuItemIter node = GetMenuItemFromPoint(pt);
765
766 // don't reset current to NULL here, we only do it when the mouse leaves
767 // the window (see below)
768 if ( node )
769 {
770 if ( !m_nodeCurrent || (node != m_nodeCurrent) )
771 {
772 ChangeCurrent(node);
773
774 wxMenuItem *item = GetCurrentItem();
775 if ( CanOpen(item) )
776 {
777 OpenSubmenu(item, WithMouse);
778 }
779 }
780 //else: same item, nothing to do
781 }
782 else // not on an item
783 {
784 // the last open submenu forwards the mouse move messages to its
785 // parent, so if the mouse moves to another item of the parent menu,
786 // this menu is closed and this other item is selected - in the similar
787 // manner, the top menu forwards the mouse moves to the menubar which
788 // allows to select another top level menu by just moving the mouse
789
790 // we need to translate our client coords to the client coords of the
791 // window we forward this event to
792 wxPoint ptScreen = ClientToScreen(pt);
793
794 // if the mouse is outside this menu, let the parent one to
795 // process it
796 wxMenu *menuParent = m_menu->GetParent();
797 if ( menuParent )
798 {
799 wxPopupMenuWindow *win = menuParent->m_popupMenu;
800
801 // if we're shown, the parent menu must be also shown
802 wxCHECK_RET( win, wxT("parent menu is not shown?") );
803
804 win->ProcessMouseMove(win->ScreenToClient(ptScreen));
805 }
806 else // no parent menu
807 {
808 wxMenuBar *menubar = m_menu->GetMenuBar();
809 if ( menubar )
810 {
811 if ( menubar->ProcessMouseEvent(
812 menubar->ScreenToClient(ptScreen)) )
813 {
814 // menubar has closed this menu and opened another one, probably
815 return;
816 }
817 }
818 }
819 //else: top level popup menu, no other processing to do
820 }
821 }
822
823 void wxPopupMenuWindow::OnMouseLeave(wxMouseEvent& event)
824 {
825 // due to the artefact of mouse events generation under MSW, we actually
826 // may get the mouse leave event after the menu had been already dismissed
827 // and calling ChangeCurrent() would then assert, so don't do it
828 if ( IsShown() )
829 {
830 // we shouldn't change the current them if our submenu is opened and
831 // mouse moved there, in this case the submenu is responsable for
832 // handling it
833 bool resetCurrent;
834 if ( HasOpenSubmenu() )
835 {
836 wxMenuItem *item = GetCurrentItem();
837 wxCHECK_RET( CanOpen(item), wxT("where is our open submenu?") );
838
839 wxPopupMenuWindow *win = item->GetSubMenu()->m_popupMenu;
840 wxCHECK_RET( win, wxT("submenu is opened but not shown?") );
841
842 // only handle this event if the mouse is not inside the submenu
843 wxPoint pt = ClientToScreen(event.GetPosition());
844 resetCurrent =
845 win->HitTest(win->ScreenToClient(pt)) == wxHT_WINDOW_OUTSIDE;
846 }
847 else
848 {
849 // this menu is the last opened
850 resetCurrent = true;
851 }
852
853 if ( resetCurrent )
854 {
855 ChangeCurrent(wxMenuItemIter());
856 }
857 }
858
859 event.Skip();
860 }
861
862 void wxPopupMenuWindow::OnKeyDown(wxKeyEvent& event)
863 {
864 wxMenuBar *menubar = m_menu->GetMenuBar();
865
866 if ( menubar )
867 {
868 menubar->ProcessEvent(event);
869 }
870 else if ( !ProcessKeyDown(event.GetKeyCode()) )
871 {
872 event.Skip();
873 }
874 }
875
876 bool wxPopupMenuWindow::ProcessKeyDown(int key)
877 {
878 wxMenuItem *item = GetCurrentItem();
879
880 // first let the opened submenu to have it (no test for IsEnabled() here,
881 // the keys navigate even in a disabled submenu if we had somehow managed
882 // to open it inspit of this)
883 if ( HasOpenSubmenu() )
884 {
885 wxCHECK_MSG( CanOpen(item), false,
886 wxT("has open submenu but another item selected?") );
887
888 if ( item->GetSubMenu()->ProcessKeyDown(key) )
889 return true;
890 }
891
892 bool processed = true;
893
894 // handle the up/down arrows, home, end, esc and return here, pass the
895 // left/right arrows to the menu bar except when the right arrow can be
896 // used to open a submenu
897 switch ( key )
898 {
899 case WXK_LEFT:
900 // if we're not a top level menu, close us, else leave this to the
901 // menubar
902 if ( !m_menu->GetParent() )
903 {
904 processed = false;
905 break;
906 }
907
908 // fall through
909
910 case WXK_ESCAPE:
911 // close just this menu
912 Dismiss();
913 HandleDismiss(false);
914 break;
915
916 case WXK_RETURN:
917 processed = ActivateItem(item);
918 break;
919
920 case WXK_HOME:
921 ChangeCurrent(m_menu->GetMenuItems().GetFirst());
922 break;
923
924 case WXK_END:
925 ChangeCurrent(m_menu->GetMenuItems().GetLast());
926 break;
927
928 case WXK_UP:
929 case WXK_DOWN:
930 {
931 bool up = key == WXK_UP;
932
933 wxMenuItemIter nodeStart = up ? GetPrevNode() : GetNextNode(),
934 node = nodeStart;
935 while ( node && node->GetData()->IsSeparator() )
936 {
937 node = up ? GetPrevNode(node) : GetNextNode(node);
938
939 if ( node == nodeStart )
940 {
941 // nothing but separators and disabled items in this
942 // menu, break out
943 node = wxMenuItemIter();
944 }
945 }
946
947 if ( node )
948 {
949 ChangeCurrent(node);
950 }
951 else
952 {
953 processed = false;
954 }
955 }
956 break;
957
958 case WXK_RIGHT:
959 // don't try to reopen an already opened menu
960 if ( !HasOpenSubmenu() && CanOpen(item) )
961 {
962 OpenSubmenu(item);
963 }
964 else
965 {
966 processed = false;
967 }
968 break;
969
970 default:
971 // look for the menu item starting with this letter
972 if ( wxIsalnum((wxChar)key) )
973 {
974 // we want to start from the item after this one because
975 // if we're already on the item with the given accel we want to
976 // go to the next one, not to stay in place
977 wxMenuItemIter nodeStart = GetNextNode();
978
979 // do we have more than one item with this accel?
980 bool notUnique = false;
981
982 // translate everything to lower case before comparing
983 wxChar chAccel = (wxChar)wxTolower(key);
984
985 // loop through all items searching for the item with this
986 // accel
987 wxMenuItemIter nodeFound,
988 node = nodeStart;
989 for ( ;; )
990 {
991 item = node->GetData();
992
993 int idxAccel = item->GetAccelIndex();
994 if ( idxAccel != -1 &&
995 (wxChar)wxTolower(item->GetItemLabelText()[(size_t)idxAccel])
996 == chAccel )
997 {
998 // ok, found an item with this accel
999 if ( !nodeFound )
1000 {
1001 // store it but continue searching as we need to
1002 // know if it's the only item with this accel or if
1003 // there are more
1004 nodeFound = node;
1005 }
1006 else // we already had found such item
1007 {
1008 notUnique = true;
1009
1010 // no need to continue further, we won't find
1011 // anything we don't already know
1012 break;
1013 }
1014 }
1015
1016 // we want to iterate over all items wrapping around if
1017 // necessary
1018 node = GetNextNode(node);
1019 if ( node == nodeStart )
1020 {
1021 // we've seen all nodes
1022 break;
1023 }
1024 }
1025
1026 if ( nodeFound )
1027 {
1028 item = nodeFound->GetData();
1029
1030 // go to this item anyhow
1031 ChangeCurrent(nodeFound);
1032
1033 if ( !notUnique && item->IsEnabled() )
1034 {
1035 // unique item with this accel - activate it
1036 processed = ActivateItem(item);
1037 }
1038 //else: just select it but don't activate as the user might
1039 // have wanted to activate another item
1040
1041 // skip "processed = false" below
1042 break;
1043 }
1044 }
1045
1046 processed = false;
1047 }
1048
1049 return processed;
1050 }
1051
1052 // ----------------------------------------------------------------------------
1053 // wxMenu
1054 // ----------------------------------------------------------------------------
1055
1056 void wxMenu::Init()
1057 {
1058 m_geometry = NULL;
1059
1060 m_popupMenu = NULL;
1061
1062 m_startRadioGroup = -1;
1063 }
1064
1065 wxMenu::~wxMenu()
1066 {
1067 delete m_geometry;
1068 delete m_popupMenu;
1069 }
1070
1071 // ----------------------------------------------------------------------------
1072 // wxMenu and wxMenuGeometryInfo
1073 // ----------------------------------------------------------------------------
1074
1075 wxMenuGeometryInfo::~wxMenuGeometryInfo()
1076 {
1077 }
1078
1079 const wxMenuGeometryInfo& wxMenu::GetGeometryInfo() const
1080 {
1081 if ( !m_geometry )
1082 {
1083 if ( m_popupMenu )
1084 {
1085 wxConstCast(this, wxMenu)->m_geometry =
1086 m_popupMenu->GetRenderer()->GetMenuGeometry(m_popupMenu, *this);
1087 }
1088 else
1089 {
1090 wxFAIL_MSG( wxT("can't get geometry without window") );
1091 }
1092 }
1093
1094 return *m_geometry;
1095 }
1096
1097 void wxMenu::InvalidateGeometryInfo()
1098 {
1099 wxDELETE(m_geometry);
1100 }
1101
1102 // ----------------------------------------------------------------------------
1103 // wxMenu adding/removing items
1104 // ----------------------------------------------------------------------------
1105
1106 void wxMenu::OnItemAdded(wxMenuItem *item)
1107 {
1108 InvalidateGeometryInfo();
1109
1110 #if wxUSE_ACCEL
1111 AddAccelFor(item);
1112 #endif // wxUSE_ACCEL
1113 }
1114
1115 void wxMenu::EndRadioGroup()
1116 {
1117 // we're not inside a radio group any longer
1118 m_startRadioGroup = -1;
1119 }
1120
1121 wxMenuItem* wxMenu::DoAppend(wxMenuItem *item)
1122 {
1123 if ( item->GetKind() == wxITEM_RADIO )
1124 {
1125 int count = GetMenuItemCount();
1126
1127 if ( m_startRadioGroup == -1 )
1128 {
1129 // start a new radio group
1130 m_startRadioGroup = count;
1131
1132 // for now it has just one element
1133 item->SetAsRadioGroupStart();
1134 item->SetRadioGroupEnd(m_startRadioGroup);
1135 }
1136 else // extend the current radio group
1137 {
1138 // we need to update its end item
1139 item->SetRadioGroupStart(m_startRadioGroup);
1140 wxMenuItemIter node = GetMenuItems().Item(m_startRadioGroup);
1141
1142 if ( node )
1143 {
1144 node->GetData()->SetRadioGroupEnd(count);
1145 }
1146 else
1147 {
1148 wxFAIL_MSG( wxT("where is the radio group start item?") );
1149 }
1150 }
1151 }
1152 else // not a radio item
1153 {
1154 EndRadioGroup();
1155 }
1156
1157 if ( !wxMenuBase::DoAppend(item) )
1158 return NULL;
1159
1160 OnItemAdded(item);
1161
1162 return item;
1163 }
1164
1165 wxMenuItem* wxMenu::DoInsert(size_t pos, wxMenuItem *item)
1166 {
1167 if ( !wxMenuBase::DoInsert(pos, item) )
1168 return NULL;
1169
1170 OnItemAdded(item);
1171
1172 return item;
1173 }
1174
1175 wxMenuItem *wxMenu::DoRemove(wxMenuItem *item)
1176 {
1177 wxMenuItem *itemOld = wxMenuBase::DoRemove(item);
1178
1179 if ( itemOld )
1180 {
1181 InvalidateGeometryInfo();
1182
1183 #if wxUSE_ACCEL
1184 RemoveAccelFor(item);
1185 #endif // wxUSE_ACCEL
1186 }
1187
1188 return itemOld;
1189 }
1190
1191 // ----------------------------------------------------------------------------
1192 // wxMenu attaching/detaching
1193 // ----------------------------------------------------------------------------
1194
1195 void wxMenu::Attach(wxMenuBarBase *menubar)
1196 {
1197 wxMenuBase::Attach(menubar);
1198
1199 wxCHECK_RET( m_menuBar, wxT("menubar can't be NULL after attaching") );
1200
1201 // unfortunately, we can't use m_menuBar->GetEventHandler() here because,
1202 // if the menubar is currently showing a menu, its event handler is a
1203 // temporary one installed by wxPopupWindow and so will disappear soon any
1204 // any attempts to use it from the newly attached menu would result in a
1205 // crash
1206 //
1207 // so we use the menubar itself, even if it's a pity as it means we can't
1208 // redirect all menu events by changing the menubar handler (FIXME)
1209 SetNextHandler(m_menuBar);
1210 }
1211
1212 void wxMenu::Detach()
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