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