]> git.saurik.com Git - wxWidgets.git/blob - src/univ/menu.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
use wxUniv's setup
[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::GetFont(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 ~wxPopupMenuWindow();
128
129 // override the base class version to select the first item initially
130 virtual void Popup(wxWindow *focus = NULL);
131
132 // override the base class version to dismiss any open submenus
133 virtual void Dismiss();
134
135 // notify the menu when the window disappears from screen
136 virtual void OnDismiss();
137
138 // called when a submenu is dismissed
139 void OnSubmenuDismiss() { m_hasOpenSubMenu = FALSE; }
140
141 // get the currently selected item (may be NULL)
142 wxMenuItem *GetCurrentItem() const
143 {
144 return m_nodeCurrent ? m_nodeCurrent->GetData() : NULL;
145 }
146
147 // find the menu item at given position
148 wxMenuItemList::Node *GetMenuItemFromPoint(const wxPoint& pt) const;
149
150 // refresh the given item
151 void RefreshItem(wxMenuItem *item);
152
153 // preselect the first item
154 void SelectFirst() { SetCurrent(m_menu->GetMenuItems().GetFirst()); }
155
156 // process the key event, return TRUE if done
157 bool ProcessKeyDown(int key);
158
159 // process mouse move event
160 void ProcessMouseMove(const wxPoint& pt);
161
162 // don't dismiss the popup window if the parent menu was clicked
163 virtual bool ProcessLeftDown(wxMouseEvent& event);
164
165 protected:
166 // how did we perform this operation?
167 enum InputMethod
168 {
169 WithKeyboard,
170 WithMouse
171 };
172
173 // draw the menu inside this window
174 virtual void DoDraw(wxControlRenderer *renderer);
175
176 // event handlers
177 void OnLeftUp(wxMouseEvent& event);
178 void OnMouseMove(wxMouseEvent& event);
179 void OnMouseLeave(wxMouseEvent& event);
180 void OnKeyDown(wxKeyEvent& event);
181
182 // reset the current item and node
183 void ResetCurrent();
184
185 // set the current node and item withotu refreshing anything
186 void SetCurrent(wxMenuItemList::Node *node);
187
188 // change the current item refreshing the old and new items
189 void ChangeCurrent(wxMenuItemList::Node *node);
190
191 // activate item, i.e. call either ClickItem() or OpenSubmenu() depending
192 // on what it is, return TRUE if something was done (i.e. it's not a
193 // separator...)
194 bool ActivateItem(wxMenuItem *item, InputMethod how = WithKeyboard);
195
196 // send the event about the item click
197 void ClickItem(wxMenuItem *item);
198
199 // show the submenu for this item
200 void OpenSubmenu(wxMenuItem *item, InputMethod how = WithKeyboard);
201
202 // can this tiem be opened?
203 bool CanOpen(wxMenuItem *item)
204 {
205 return item && item->IsEnabled() && item->IsSubMenu();
206 }
207
208 // dismiss the menu and all parent menus too
209 void DismissAndNotify();
210
211 // react to dimissing this menu and also dismiss the parent if
212 // dismissParent
213 void HandleDismiss(bool dismissParent);
214
215 // do we have an open submenu?
216 bool HasOpenSubmenu() const { return m_hasOpenSubMenu; }
217
218 // get previous node after the current one
219 wxMenuItemList::Node *GetPrevNode() const;
220
221 // get previous node before the given one, wrapping if it's the first one
222 wxMenuItemList::Node *GetPrevNode(wxMenuItemList::Node *node) const;
223
224 // get next node after the current one
225 wxMenuItemList::Node *GetNextNode() const;
226
227 // get next node after the given one, wrapping if it's the last one
228 wxMenuItemList::Node *GetNextNode(wxMenuItemList::Node *node) const;
229
230 private:
231 // the menu we show
232 wxMenu *m_menu;
233
234 // the menu node corresponding to the current item
235 wxMenuItemList::Node *m_nodeCurrent;
236
237 // do we currently have an opened submenu?
238 bool m_hasOpenSubMenu;
239
240 DECLARE_EVENT_TABLE()
241 };
242
243 // ----------------------------------------------------------------------------
244 // wxMenuKbdRedirector: an event handler which redirects kbd input to wxMenu
245 // ----------------------------------------------------------------------------
246
247 class wxMenuKbdRedirector : public wxEvtHandler
248 {
249 public:
250 wxMenuKbdRedirector(wxMenu *menu) { m_menu = menu; }
251
252 virtual bool ProcessEvent(wxEvent& event)
253 {
254 if ( event.GetEventType() == wxEVT_KEY_DOWN )
255 {
256 return m_menu->ProcessKeyDown(((wxKeyEvent &)event).GetKeyCode());
257 }
258 else
259 {
260 // return FALSE;
261
262 return wxEvtHandler::ProcessEvent(event);
263 }
264 }
265
266 private:
267 wxMenu *m_menu;
268 };
269
270 // ----------------------------------------------------------------------------
271 // wxWin macros
272 // ----------------------------------------------------------------------------
273
274 IMPLEMENT_DYNAMIC_CLASS(wxMenu, wxEvtHandler)
275 IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxWindow)
276 IMPLEMENT_DYNAMIC_CLASS(wxMenuItem, wxObject)
277
278 BEGIN_EVENT_TABLE(wxPopupMenuWindow, wxPopupTransientWindow)
279 EVT_KEY_DOWN(wxPopupMenuWindow::OnKeyDown)
280
281 EVT_LEFT_UP(wxPopupMenuWindow::OnLeftUp)
282 EVT_MOTION(wxPopupMenuWindow::OnMouseMove)
283 EVT_LEAVE_WINDOW(wxPopupMenuWindow::OnMouseLeave)
284 END_EVENT_TABLE()
285
286 BEGIN_EVENT_TABLE(wxMenuBar, wxMenuBarBase)
287 EVT_KILL_FOCUS(wxMenuBar::OnKillFocus)
288
289 EVT_KEY_DOWN(wxMenuBar::OnKeyDown)
290
291 EVT_LEFT_DOWN(wxMenuBar::OnLeftDown)
292 EVT_MOTION(wxMenuBar::OnMouseMove)
293 END_EVENT_TABLE()
294
295 // ============================================================================
296 // implementation
297 // ============================================================================
298
299 // ----------------------------------------------------------------------------
300 // wxPopupMenuWindow
301 // ----------------------------------------------------------------------------
302
303 wxPopupMenuWindow::wxPopupMenuWindow(wxWindow *parent, wxMenu *menu)
304 {
305 m_menu = menu;
306 m_hasOpenSubMenu = FALSE;
307
308 ResetCurrent();
309
310 (void)Create(parent, wxBORDER_RAISED);
311
312 SetCursor(wxCURSOR_ARROW);
313 }
314
315 wxPopupMenuWindow::~wxPopupMenuWindow()
316 {
317 }
318
319 // ----------------------------------------------------------------------------
320 // wxPopupMenuWindow current item/node handling
321 // ----------------------------------------------------------------------------
322
323 void wxPopupMenuWindow::ResetCurrent()
324 {
325 SetCurrent(NULL);
326 }
327
328 void wxPopupMenuWindow::SetCurrent(wxMenuItemList::Node *node)
329 {
330 m_nodeCurrent = node;
331 }
332
333 void wxPopupMenuWindow::ChangeCurrent(wxMenuItemList::Node *node)
334 {
335 if ( node != m_nodeCurrent )
336 {
337 wxMenuItemList::Node *nodeOldCurrent = m_nodeCurrent;
338
339 m_nodeCurrent = node;
340
341 if ( nodeOldCurrent )
342 {
343 wxMenuItem *item = nodeOldCurrent->GetData();
344 wxCHECK_RET( item, _T("no current item?") );
345
346 // if it was the currently opened menu, close it
347 if ( item->IsSubMenu() && item->GetSubMenu()->IsShown() )
348 {
349 item->GetSubMenu()->Dismiss();
350 OnSubmenuDismiss();
351 }
352
353 RefreshItem(item);
354 }
355
356 if ( m_nodeCurrent )
357 RefreshItem(m_nodeCurrent->GetData());
358 }
359 }
360
361 wxMenuItemList::Node *wxPopupMenuWindow::GetPrevNode() const
362 {
363 // return the last node if there had been no previously selected one
364 return m_nodeCurrent ? GetPrevNode(m_nodeCurrent)
365 : m_menu->GetMenuItems().GetLast();
366 }
367
368 wxMenuItemList::Node *
369 wxPopupMenuWindow::GetPrevNode(wxMenuItemList::Node *node) const
370 {
371 if ( node )
372 {
373 node = node->GetPrevious();
374 if ( !node )
375 {
376 node = m_menu->GetMenuItems().GetLast();
377 }
378 }
379 //else: the menu is empty
380
381 return node;
382 }
383
384 wxMenuItemList::Node *wxPopupMenuWindow::GetNextNode() const
385 {
386 // return the first node if there had been no previously selected one
387 return m_nodeCurrent ? GetNextNode(m_nodeCurrent)
388 : m_menu->GetMenuItems().GetFirst();
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::GetFont(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 // We are a submenu of a menu of a menubar
1166 if (menu->GetMenuBar())
1167 return menu->GetMenuBar();
1168
1169 win = menu->GetInvokingWindow();
1170 if ( win )
1171 break;
1172
1173 menu = menu->GetParent();
1174 }
1175
1176 // we're probably going to crash in the caller anyhow, but try to detect
1177 // this error as soon as possible
1178 wxASSERT_MSG( win, _T("menu without any associated window?") );
1179
1180 // also remember it in this menu so that we don't have to search for it the
1181 // next time
1182 wxConstCast(this, wxMenu)->m_invokingWindow = win;
1183
1184 return win;
1185 }
1186
1187 wxRenderer *wxMenu::GetRenderer() const
1188 {
1189 // we're going to crash without renderer!
1190 wxCHECK_MSG( m_popupMenu, NULL, _T("neither popup nor menubar menu?") );
1191
1192 return m_popupMenu->GetRenderer();
1193 }
1194
1195 void wxMenu::RefreshItem(wxMenuItem *item)
1196 {
1197 // the item geometry changed, so our might have changed as well
1198 InvalidateGeometryInfo();
1199
1200 if ( IsShown() )
1201 {
1202 // this would be a bug in IsShown()
1203 wxCHECK_RET( m_popupMenu, _T("must have popup window if shown!") );
1204
1205 // recalc geometry to update the item height and such
1206 (void)GetGeometryInfo();
1207
1208 m_popupMenu->RefreshItem(item);
1209 }
1210 }
1211
1212 // ----------------------------------------------------------------------------
1213 // wxMenu showing and hiding
1214 // ----------------------------------------------------------------------------
1215
1216 bool wxMenu::IsShown() const
1217 {
1218 return m_popupMenu && m_popupMenu->IsShown();
1219 }
1220
1221 void wxMenu::OnDismiss(bool dismissParent)
1222 {
1223 if ( m_menuParent )
1224 {
1225 // always notify the parent about submenu disappearance
1226 wxPopupMenuWindow *win = m_menuParent->m_popupMenu;
1227 if ( win )
1228 {
1229 win->OnSubmenuDismiss();
1230 }
1231 else
1232 {
1233 wxFAIL_MSG( _T("parent menu not shown?") );
1234 }
1235
1236 // and if we dismiss everything, propagate to parent
1237 if ( dismissParent )
1238 {
1239 // dismissParent is recursive
1240 m_menuParent->Dismiss();
1241 m_menuParent->OnDismiss(TRUE);
1242 }
1243 }
1244 else // no parent menu
1245 {
1246 // notify the menu bar if we're a top level menu
1247 if ( m_menuBar )
1248 {
1249 m_menuBar->OnDismissMenu(dismissParent);
1250 }
1251 else // popup menu
1252 {
1253 wxCHECK_RET( m_invokingWindow, _T("what kind of menu is this?") );
1254
1255 m_invokingWindow->DismissPopupMenu();
1256
1257 // Why reset it here? We need it for sending the event to...
1258 // SetInvokingWindow(NULL);
1259 }
1260 }
1261 }
1262
1263 void wxMenu::Popup(const wxPoint& pos, const wxSize& size, bool selectFirst)
1264 {
1265 // create the popup window if not done yet
1266 if ( !m_popupMenu )
1267 {
1268 m_popupMenu = new wxPopupMenuWindow(GetRootWindow(), this);
1269 }
1270
1271 // select the first item unless disabled
1272 if ( selectFirst )
1273 {
1274 m_popupMenu->SelectFirst();
1275 }
1276
1277 // the geometry might have changed since the last time we were shown, so
1278 // always resize
1279 m_popupMenu->SetClientSize(GetGeometryInfo().GetSize());
1280
1281 // position it as specified
1282 m_popupMenu->Position(pos, size);
1283
1284 // the menu can't have the focus itself (it is a Windows limitation), so
1285 // always keep the focus at the originating window
1286 wxWindow *focus = GetRootWindow();
1287
1288 wxASSERT_MSG( focus, _T("no window to keep focus on?") );
1289
1290 // and show it
1291 m_popupMenu->Popup(focus);
1292 }
1293
1294 void wxMenu::Dismiss()
1295 {
1296 wxCHECK_RET( IsShown(), _T("can't dismiss hidden menu") );
1297
1298 m_popupMenu->Dismiss();
1299 }
1300
1301 // ----------------------------------------------------------------------------
1302 // wxMenu event processing
1303 // ----------------------------------------------------------------------------
1304
1305 bool wxMenu::ProcessKeyDown(int key)
1306 {
1307 wxCHECK_MSG( m_popupMenu, FALSE,
1308 _T("can't process key events if not shown") );
1309
1310 return m_popupMenu->ProcessKeyDown(key);
1311 }
1312
1313 bool wxMenu::ClickItem(wxMenuItem *item)
1314 {
1315 int isChecked;
1316 if ( item->IsCheckable() )
1317 {
1318 // update the item state
1319 isChecked = !item->IsChecked();
1320
1321 item->Check(isChecked != 0);
1322 }
1323 else
1324 {
1325 // not applicabled
1326 isChecked = -1;
1327 }
1328
1329 return SendEvent(item->GetId(), isChecked);
1330 }
1331
1332 // ----------------------------------------------------------------------------
1333 // wxMenu accel support
1334 // ----------------------------------------------------------------------------
1335
1336 #if wxUSE_ACCEL
1337
1338 bool wxMenu::ProcessAccelEvent(const wxKeyEvent& event)
1339 {
1340 // do we have an item for this accel?
1341 wxMenuItem *item = m_accelTable.GetMenuItem(event);
1342 if ( item && item->IsEnabled() )
1343 {
1344 return ClickItem(item);
1345 }
1346
1347 // try our submenus
1348 for ( wxMenuItemList::Node *node = GetMenuItems().GetFirst();
1349 node;
1350 node = node->GetNext() )
1351 {
1352 const wxMenuItem *item = node->GetData();
1353 if ( item->IsSubMenu() && item->IsEnabled() )
1354 {
1355 // try its elements
1356 if ( item->GetSubMenu()->ProcessAccelEvent(event) )
1357 {
1358 return TRUE;
1359 }
1360 }
1361 }
1362
1363 return FALSE;
1364 }
1365
1366 void wxMenu::AddAccelFor(wxMenuItem *item)
1367 {
1368 wxAcceleratorEntry *accel = item->GetAccel();
1369 if ( accel )
1370 {
1371 accel->SetMenuItem(item);
1372
1373 m_accelTable.Add(*accel);
1374
1375 delete accel;
1376 }
1377 }
1378
1379 void wxMenu::RemoveAccelFor(wxMenuItem *item)
1380 {
1381 wxAcceleratorEntry *accel = item->GetAccel();
1382 if ( accel )
1383 {
1384 m_accelTable.Remove(*accel);
1385
1386 delete accel;
1387 }
1388 }
1389
1390 #endif // wxUSE_ACCEL
1391
1392 // ----------------------------------------------------------------------------
1393 // wxMenuItem construction
1394 // ----------------------------------------------------------------------------
1395
1396 wxMenuItem::wxMenuItem(wxMenu *parentMenu,
1397 int id,
1398 const wxString& text,
1399 const wxString& help,
1400 bool isCheckable,
1401 wxMenu *subMenu)
1402 {
1403 m_id = id;
1404 m_parentMenu = parentMenu;
1405 m_subMenu = subMenu;
1406
1407 m_text = text;
1408 m_help = help;
1409
1410 m_isCheckable = isCheckable;
1411 m_isEnabled = TRUE;
1412 m_isChecked = FALSE;
1413
1414 m_posY =
1415 m_height = -1;
1416
1417 UpdateAccelInfo();
1418 }
1419
1420 wxMenuItem::~wxMenuItem()
1421 {
1422 }
1423
1424 // ----------------------------------------------------------------------------
1425 // wxMenuItemBase methods implemented here
1426 // ----------------------------------------------------------------------------
1427
1428 /* static */
1429 wxMenuItem *wxMenuItemBase::New(wxMenu *parentMenu,
1430 int id,
1431 const wxString& name,
1432 const wxString& help,
1433 bool isCheckable,
1434 wxMenu *subMenu)
1435 {
1436 return new wxMenuItem(parentMenu, id, name, help, isCheckable, subMenu);
1437 }
1438
1439 /* static */
1440 wxString wxMenuItemBase::GetLabelFromText(const wxString& text)
1441 {
1442 return wxStripMenuCodes(text);
1443 }
1444
1445 // ----------------------------------------------------------------------------
1446 // wxMenuItem operations
1447 // ----------------------------------------------------------------------------
1448
1449 void wxMenuItem::NotifyMenu()
1450 {
1451 m_parentMenu->RefreshItem(this);
1452 }
1453
1454 void wxMenuItem::UpdateAccelInfo()
1455 {
1456 m_indexAccel = wxControl::FindAccelIndex(m_text);
1457
1458 // will be empty if the text contains no TABs - ok
1459 m_strAccel = m_text.AfterFirst(_T('\t'));
1460 }
1461
1462 void wxMenuItem::SetText(const wxString& text)
1463 {
1464 if ( text != m_text )
1465 {
1466 // first call the base class version to change m_text
1467 wxMenuItemBase::SetText(text);
1468
1469 UpdateAccelInfo();
1470
1471 NotifyMenu();
1472 }
1473 }
1474
1475 void wxMenuItem::SetCheckable(bool checkable)
1476 {
1477 if ( checkable != m_isCheckable )
1478 {
1479 wxMenuItemBase::SetCheckable(checkable);
1480
1481 NotifyMenu();
1482 }
1483 }
1484
1485 void wxMenuItem::SetBitmaps(const wxBitmap& bmpChecked,
1486 const wxBitmap& bmpUnchecked)
1487 {
1488 m_bmpChecked = bmpChecked;
1489 m_bmpUnchecked = bmpUnchecked;
1490
1491 NotifyMenu();
1492 }
1493
1494 void wxMenuItem::Enable(bool enable)
1495 {
1496 if ( enable != m_isEnabled )
1497 {
1498 wxMenuItemBase::Enable(enable);
1499
1500 NotifyMenu();
1501 }
1502 }
1503
1504 void wxMenuItem::Check(bool check)
1505 {
1506 if ( check != m_isChecked )
1507 {
1508 wxMenuItemBase::Check(check);
1509
1510 NotifyMenu();
1511 }
1512 }
1513
1514 // ----------------------------------------------------------------------------
1515 // wxMenuBar creation
1516 // ----------------------------------------------------------------------------
1517
1518 void wxMenuBar::Init()
1519 {
1520 m_frameLast = NULL;
1521
1522 m_current = -1;
1523
1524 m_menuShown = NULL;
1525
1526 m_shouldShowMenu = FALSE;
1527 }
1528
1529 void wxMenuBar::Attach(wxFrame *frame)
1530 {
1531 // maybe you really wanted to call Detach()?
1532 wxCHECK_RET( frame, _T("wxMenuBar::Attach(NULL) called") );
1533
1534 wxMenuBarBase::Attach(frame);
1535
1536 if ( IsCreated() )
1537 {
1538 // reparent if necessary
1539 if ( m_frameLast != frame )
1540 {
1541 Reparent(frame);
1542 }
1543
1544 // show it back - was hidden by Detach()
1545 Show();
1546 }
1547 else // not created yet, do it now
1548 {
1549 // we have no way to return the error from here anyhow :-(
1550 (void)Create(frame, -1);
1551
1552 SetCursor(wxCURSOR_ARROW);
1553
1554 SetFont(wxSystemSettings::GetFont(wxSYS_SYSTEM_FONT));
1555
1556 // calculate and set our height (it won't be changed any more)
1557 SetSize(-1, GetBestSize().y);
1558 }
1559
1560 // remember the last frame which had us to avoid unnecessarily reparenting
1561 // above
1562 m_frameLast = frame;
1563 }
1564
1565 void wxMenuBar::Detach()
1566 {
1567 // don't delete the window because we may be reattached later, just hide it
1568 if ( m_frameLast )
1569 {
1570 Hide();
1571 }
1572
1573 wxMenuBarBase::Detach();
1574 }
1575
1576 wxMenuBar::~wxMenuBar()
1577 {
1578 }
1579
1580 // ----------------------------------------------------------------------------
1581 // wxMenuBar adding/removing items
1582 // ----------------------------------------------------------------------------
1583
1584 bool wxMenuBar::Append(wxMenu *menu, const wxString& title)
1585 {
1586 return Insert(GetCount(), menu, title);
1587 }
1588
1589 bool wxMenuBar::Insert(size_t pos, wxMenu *menu, const wxString& title)
1590 {
1591 if ( !wxMenuBarBase::Insert(pos, menu, title) )
1592 return FALSE;
1593
1594 wxMenuInfo *info = new wxMenuInfo(title);
1595 m_menuInfos.Insert(info, pos);
1596
1597 RefreshAllItemsAfter(pos);
1598
1599 return TRUE;
1600 }
1601
1602 wxMenu *wxMenuBar::Replace(size_t pos, wxMenu *menu, const wxString& title)
1603 {
1604 wxMenu *menuOld = wxMenuBarBase::Replace(pos, menu, title);
1605
1606 if ( menuOld )
1607 {
1608 wxMenuInfo& info = m_menuInfos[pos];
1609
1610 info.SetLabel(title);
1611
1612 // even if the old menu was disabled, the new one is not any more
1613 info.SetEnabled();
1614
1615 // even if we change only this one, the new label has different width,
1616 // so we need to refresh everything beyond this item as well
1617 RefreshAllItemsAfter(pos);
1618 }
1619
1620 return menuOld;
1621 }
1622
1623 wxMenu *wxMenuBar::Remove(size_t pos)
1624 {
1625 wxMenu *menuOld = wxMenuBarBase::Remove(pos);
1626
1627 if ( menuOld )
1628 {
1629 m_menuInfos.RemoveAt(pos);
1630
1631 // this doesn't happen too often, so don't try to be too smart - just
1632 // refresh everything
1633 Refresh();
1634 }
1635
1636 return menuOld;
1637 }
1638
1639 // ----------------------------------------------------------------------------
1640 // wxMenuBar top level menus access
1641 // ----------------------------------------------------------------------------
1642
1643 wxCoord wxMenuBar::GetItemWidth(size_t pos) const
1644 {
1645 return m_menuInfos[pos].GetWidth(wxConstCast(this, wxMenuBar));
1646 }
1647
1648 void wxMenuBar::EnableTop(size_t pos, bool enable)
1649 {
1650 wxCHECK_RET( pos < GetCount(), _T("invalid index in EnableTop") );
1651
1652 if ( enable != m_menuInfos[pos].IsEnabled() )
1653 {
1654 m_menuInfos[pos].SetEnabled(enable);
1655
1656 RefreshItem(pos);
1657 }
1658 //else: nothing to do
1659 }
1660
1661 bool wxMenuBar::IsEnabledTop(size_t pos) const
1662 {
1663 wxCHECK_MSG( pos < GetCount(), FALSE, _T("invalid index in IsEnabledTop") );
1664
1665 return m_menuInfos[pos].IsEnabled();
1666 }
1667
1668 void wxMenuBar::SetLabelTop(size_t pos, const wxString& label)
1669 {
1670 wxCHECK_RET( pos < GetCount(), _T("invalid index in EnableTop") );
1671
1672 if ( label != m_menuInfos[pos].GetLabel() )
1673 {
1674 m_menuInfos[pos].SetLabel(label);
1675
1676 RefreshItem(pos);
1677 }
1678 //else: nothing to do
1679 }
1680
1681 wxString wxMenuBar::GetLabelTop(size_t pos) const
1682 {
1683 wxCHECK_MSG( pos < GetCount(), _T(""), _T("invalid index in GetLabelTop") );
1684
1685 return m_menuInfos[pos].GetLabel();
1686 }
1687
1688 // ----------------------------------------------------------------------------
1689 // wxMenuBar drawing
1690 // ----------------------------------------------------------------------------
1691
1692 void wxMenuBar::RefreshAllItemsAfter(size_t pos)
1693 {
1694 if ( !IsCreated() )
1695 {
1696 // no need to refresh if nothing is shown yet
1697 return;
1698 }
1699
1700 wxRect rect = GetItemRect(pos);
1701 rect.width = GetClientSize().x - rect.x;
1702 RefreshRect(rect);
1703 }
1704
1705 void wxMenuBar::RefreshItem(size_t pos)
1706 {
1707 wxCHECK_RET( pos != (size_t)-1,
1708 _T("invalid item in wxMenuBar::RefreshItem") );
1709
1710 if ( !IsCreated() )
1711 {
1712 // no need to refresh if nothing is shown yet
1713 return;
1714 }
1715
1716 RefreshRect(GetItemRect(pos));
1717 }
1718
1719 void wxMenuBar::DoDraw(wxControlRenderer *renderer)
1720 {
1721 wxDC& dc = renderer->GetDC();
1722 dc.SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
1723
1724 // redraw only the items which must be redrawn
1725
1726 // we don't have to use GetUpdateClientRect() here because our client rect
1727 // is the same as total one
1728 wxRect rectUpdate = GetUpdateRegion().GetBox();
1729
1730 int flagsMenubar = GetStateFlags();
1731
1732 wxRect rect;
1733 rect.y = 0;
1734 rect.height = GetClientSize().y;
1735
1736 wxCoord x = 0;
1737 size_t count = GetCount();
1738 for ( size_t n = 0; n < count; n++ )
1739 {
1740 if ( x > rectUpdate.GetRight() )
1741 {
1742 // all remaining items are to the right of rectUpdate
1743 break;
1744 }
1745
1746 rect.x = x;
1747 rect.width = GetItemWidth(n);
1748 x += rect.width;
1749 if ( x < rectUpdate.x )
1750 {
1751 // this item is still to the left of rectUpdate
1752 continue;
1753 }
1754
1755 int flags = flagsMenubar;
1756 if ( m_current != -1 && n == (size_t)m_current )
1757 {
1758 flags |= wxCONTROL_SELECTED;
1759 }
1760
1761 if ( !IsEnabledTop(n) )
1762 {
1763 flags |= wxCONTROL_DISABLED;
1764 }
1765
1766 GetRenderer()->DrawMenuBarItem
1767 (
1768 dc,
1769 rect,
1770 m_menuInfos[n].GetLabel(),
1771 flags,
1772 m_menuInfos[n].GetAccelIndex()
1773 );
1774 }
1775 }
1776
1777 // ----------------------------------------------------------------------------
1778 // wxMenuBar geometry
1779 // ----------------------------------------------------------------------------
1780
1781 wxRect wxMenuBar::GetItemRect(size_t pos) const
1782 {
1783 wxASSERT_MSG( pos < GetCount(), _T("invalid menu bar item index") );
1784 wxASSERT_MSG( IsCreated(), _T("can't call this method yet") );
1785
1786 wxRect rect;
1787 rect.x =
1788 rect.y = 0;
1789 rect.height = GetClientSize().y;
1790
1791 for ( size_t n = 0; n < pos; n++ )
1792 {
1793 rect.x += GetItemWidth(n);
1794 }
1795
1796 rect.width = GetItemWidth(pos);
1797
1798 return rect;
1799 }
1800
1801 wxSize wxMenuBar::DoGetBestClientSize() const
1802 {
1803 wxSize size;
1804 if ( GetMenuCount() > 0 )
1805 {
1806 wxClientDC dc(wxConstCast(this, wxMenuBar));
1807 dc.SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
1808 dc.GetTextExtent(GetLabelTop(0), &size.x, &size.y);
1809
1810 // adjust for the renderer we use
1811 size = GetRenderer()->GetMenuBarItemSize(size);
1812 }
1813 else // empty menubar
1814 {
1815 size.x =
1816 size.y = 0;
1817 }
1818
1819 // the width is arbitrary, of course, for horizontal menubar
1820 size.x = 100;
1821
1822 return size;
1823 }
1824
1825 int wxMenuBar::GetMenuFromPoint(const wxPoint& pos) const
1826 {
1827 if ( pos.x < 0 || pos.y < 0 || pos.y > GetClientSize().y )
1828 return -1;
1829
1830 // do find it
1831 wxCoord x = 0;
1832 size_t count = GetCount();
1833 for ( size_t item = 0; item < count; item++ )
1834 {
1835 x += GetItemWidth(item);
1836
1837 if ( x > pos.x )
1838 {
1839 return item;
1840 }
1841 }
1842
1843 // to the right of the last menu item
1844 return -1;
1845 }
1846
1847 // ----------------------------------------------------------------------------
1848 // wxMenuBar menu operations
1849 // ----------------------------------------------------------------------------
1850
1851 void wxMenuBar::SelectMenu(size_t pos)
1852 {
1853 SetFocus();
1854 wxLogTrace(_T("mousecapture"), _T("Capturing mouse from wxMenuBar::SelectMenu"));
1855 CaptureMouse();
1856
1857 DoSelectMenu(pos);
1858 }
1859
1860 void wxMenuBar::DoSelectMenu(size_t pos)
1861 {
1862 wxCHECK_RET( pos < GetCount(), _T("invalid menu index in DoSelectMenu") );
1863
1864 int posOld = m_current;
1865
1866 m_current = pos;
1867
1868 if ( posOld != -1 )
1869 {
1870 // close the previous menu
1871 if ( IsShowingMenu() )
1872 {
1873 // restore m_shouldShowMenu flag after DismissMenu() which resets
1874 // it to FALSE
1875 bool old = m_shouldShowMenu;
1876
1877 DismissMenu();
1878
1879 m_shouldShowMenu = old;
1880 }
1881
1882 RefreshItem((size_t)posOld);
1883 }
1884
1885 RefreshItem(pos);
1886 }
1887
1888 void wxMenuBar::PopupMenu(size_t pos)
1889 {
1890 wxCHECK_RET( pos < GetCount(), _T("invalid menu index in PopupCurrentMenu") );
1891
1892 SetFocus();
1893 DoSelectMenu(pos);
1894 PopupCurrentMenu();
1895 }
1896
1897 // ----------------------------------------------------------------------------
1898 // wxMenuBar input handing
1899 // ----------------------------------------------------------------------------
1900
1901 /*
1902 Note that wxMenuBar doesn't use wxInputHandler but handles keyboard and
1903 mouse in the same way under all platforms. This is because it doesn't derive
1904 from wxControl (which works with input handlers) but directly from wxWindow.
1905
1906 Also, menu bar input handling is rather simple, so maybe it's not really
1907 worth making it themeable - at least I've decided against doing it now as it
1908 would merging the changes back into trunk more difficult. But it still could
1909 be done later if really needed.
1910 */
1911
1912 void wxMenuBar::OnKillFocus(wxFocusEvent& event)
1913 {
1914 if ( m_current != -1 )
1915 {
1916 RefreshItem((size_t)m_current);
1917
1918 m_current = -1;
1919 }
1920
1921 event.Skip();
1922 }
1923
1924 void wxMenuBar::OnLeftDown(wxMouseEvent& event)
1925 {
1926 if ( HasCapture() )
1927 {
1928 OnDismiss();
1929
1930 event.Skip();
1931 }
1932 else // we didn't have mouse capture, capture it now
1933 {
1934 m_current = GetMenuFromPoint(event.GetPosition());
1935 if ( m_current == -1 )
1936 {
1937 // unfortunately, we can't prevent wxMSW from giving us the focus,
1938 // so we can only give it back
1939 GiveAwayFocus();
1940 }
1941 else // on item
1942 {
1943 wxLogTrace(_T("mousecapture"), _T("Capturing mouse from wxMenuBar::OnLeftDown"));
1944 CaptureMouse();
1945
1946 // show it as selected
1947 RefreshItem((size_t)m_current);
1948
1949 // show the menu
1950 PopupCurrentMenu(FALSE /* don't select first item - as Windows does */);
1951 }
1952 }
1953 }
1954
1955 void wxMenuBar::OnMouseMove(wxMouseEvent& event)
1956 {
1957 if ( HasCapture() )
1958 {
1959 (void)ProcessMouseEvent(event.GetPosition());
1960 }
1961 else
1962 {
1963 event.Skip();
1964 }
1965 }
1966
1967 bool wxMenuBar::ProcessMouseEvent(const wxPoint& pt)
1968 {
1969 // a hack to ignore the extra mouse events MSW sends us: this is similar to
1970 // wxUSE_MOUSEEVENT_HACK in wxWin itself but it isn't enough for us here as
1971 // we get the messages from different windows (old and new popup menus for
1972 // example)
1973 #ifdef __WXMSW__
1974 static wxPoint s_ptLast;
1975 if ( pt == s_ptLast )
1976 {
1977 return FALSE;
1978 }
1979
1980 s_ptLast = pt;
1981 #endif // __WXMSW__
1982
1983 int currentNew = GetMenuFromPoint(pt);
1984 if ( (currentNew == -1) || (currentNew == m_current) )
1985 {
1986 return FALSE;
1987 }
1988
1989 // select the new active item
1990 DoSelectMenu(currentNew);
1991
1992 // show the menu if we know that we should, even if we hadn't been showing
1993 // it before (this may happen if the previous menu was disabled)
1994 if ( m_shouldShowMenu && !m_menuShown)
1995 {
1996 // open the new menu if the old one we closed had been opened
1997 PopupCurrentMenu(FALSE /* don't select first item - as Windows does */);
1998 }
1999
2000 return TRUE;
2001 }
2002
2003 void wxMenuBar::OnKeyDown(wxKeyEvent& event)
2004 {
2005 // ensure that we have a current item - we might not have it if we're
2006 // given the focus with Alt or F10 press (and under GTK+ the menubar
2007 // somehow gets the keyboard events even when it doesn't have focus...)
2008 if ( m_current == -1 )
2009 {
2010 if ( !HasCapture() )
2011 {
2012 SelectMenu(0);
2013 }
2014 else // we do have capture
2015 {
2016 // we always maintain a valid current item while we're in modal
2017 // state (i.e. have the capture)
2018 wxFAIL_MSG( _T("how did we manage to lose current item?") );
2019
2020 return;
2021 }
2022 }
2023
2024 int key = event.GetKeyCode();
2025
2026 // first let the menu have it
2027 if ( IsShowingMenu() && m_menuShown->ProcessKeyDown(key) )
2028 {
2029 return;
2030 }
2031
2032 // cycle through the menu items when left/right arrows are pressed and open
2033 // the menu when up/down one is
2034 switch ( key )
2035 {
2036 case WXK_MENU:
2037 // Alt must be processed at wxWindow level too
2038 event.Skip();
2039 // fall through
2040
2041 case WXK_ESCAPE:
2042 // remove the selection and give the focus away
2043 if ( m_current != -1 )
2044 {
2045 if ( IsShowingMenu() )
2046 {
2047 DismissMenu();
2048 }
2049
2050 OnDismiss();
2051 }
2052 break;
2053
2054 case WXK_LEFT:
2055 case WXK_RIGHT:
2056 {
2057 size_t count = GetCount();
2058 if ( count == 1 )
2059 {
2060 // the item won't change anyhow
2061 break;
2062 }
2063 //else: otherwise, it will
2064
2065 // remember if we were showing a menu - if we did, we should
2066 // show the new menu after changing the item
2067 bool wasMenuOpened = IsShowingMenu();
2068 if ( wasMenuOpened )
2069 {
2070 DismissMenu();
2071 }
2072
2073 // cast is safe as we tested for -1 above
2074 size_t currentNew = (size_t)m_current;
2075
2076 if ( key == WXK_LEFT )
2077 {
2078 if ( currentNew-- == 0 )
2079 currentNew = count - 1;
2080 }
2081 else // right
2082 {
2083 if ( ++currentNew == count )
2084 currentNew = 0;
2085 }
2086
2087 DoSelectMenu(currentNew);
2088
2089 if ( wasMenuOpened )
2090 {
2091 PopupCurrentMenu();
2092 }
2093 }
2094 break;
2095
2096 case WXK_DOWN:
2097 case WXK_UP:
2098 case WXK_RETURN:
2099 // open the menu
2100 PopupCurrentMenu();
2101 break;
2102
2103 default:
2104 // letters open the corresponding menu
2105 {
2106 bool unique;
2107 int idxFound = FindNextItemForAccel(m_current, key, &unique);
2108
2109 if ( idxFound != -1 )
2110 {
2111 if ( IsShowingMenu() )
2112 {
2113 DismissMenu();
2114 }
2115
2116 DoSelectMenu((size_t)idxFound);
2117
2118 // if the item is not unique, just select it but don't
2119 // activate as the user might have wanted to activate
2120 // another item
2121 //
2122 // also, don't try to open a disabled menu
2123 if ( unique && IsEnabledTop((size_t)idxFound) )
2124 {
2125 // open the menu
2126 PopupCurrentMenu();
2127 }
2128
2129 // skip the "event.Skip()" below
2130 break;
2131 }
2132 }
2133
2134 event.Skip();
2135 }
2136 }
2137
2138 // ----------------------------------------------------------------------------
2139 // wxMenuBar accel handling
2140 // ----------------------------------------------------------------------------
2141
2142 int wxMenuBar::FindNextItemForAccel(int idxStart, int key, bool *unique) const
2143 {
2144 if ( !wxIsalnum(key) )
2145 {
2146 // we only support letters/digits as accels
2147 return -1;
2148 }
2149
2150 // do we have more than one item with this accel?
2151 if ( unique )
2152 *unique = TRUE;
2153
2154 // translate everything to lower case before comparing
2155 wxChar chAccel = wxTolower(key);
2156
2157 // the index of the item with this accel
2158 int idxFound = -1;
2159
2160 // loop through all items searching for the item with this
2161 // accel starting at the item after the current one
2162 int count = GetCount();
2163 int n = idxStart == -1 ? 0 : idxStart + 1;
2164
2165 if ( n == count )
2166 {
2167 // wrap
2168 n = 0;
2169 }
2170
2171 idxStart = n;
2172 for ( ;; )
2173 {
2174 const wxMenuInfo& info = m_menuInfos[n];
2175
2176 int idxAccel = info.GetAccelIndex();
2177 if ( idxAccel != -1 &&
2178 wxTolower(info.GetLabel()[(size_t)idxAccel])
2179 == chAccel )
2180 {
2181 // ok, found an item with this accel
2182 if ( idxFound == -1 )
2183 {
2184 // store it but continue searching as we need to
2185 // know if it's the only item with this accel or if
2186 // there are more
2187 idxFound = n;
2188 }
2189 else // we already had found such item
2190 {
2191 if ( unique )
2192 *unique = FALSE;
2193
2194 // no need to continue further, we won't find
2195 // anything we don't already know
2196 break;
2197 }
2198 }
2199
2200 // we want to iterate over all items wrapping around if
2201 // necessary
2202 if ( ++n == count )
2203 {
2204 // wrap
2205 n = 0;
2206 }
2207
2208 if ( n == idxStart )
2209 {
2210 // we've seen all items
2211 break;
2212 }
2213 }
2214
2215 return idxFound;
2216 }
2217
2218 #if wxUSE_ACCEL
2219
2220 bool wxMenuBar::ProcessAccelEvent(const wxKeyEvent& event)
2221 {
2222 size_t n = 0;
2223 for ( wxMenuList::Node *node = m_menus.GetFirst();
2224 node;
2225 node = node->GetNext(), n++ )
2226 {
2227 // accels of the items in the disabled menus shouldn't work
2228 if ( m_menuInfos[n].IsEnabled() )
2229 {
2230 if ( node->GetData()->ProcessAccelEvent(event) )
2231 {
2232 // menu processed it
2233 return TRUE;
2234 }
2235 }
2236 }
2237
2238 // not found
2239 return FALSE;
2240 }
2241
2242 #endif // wxUSE_ACCEL
2243
2244 // ----------------------------------------------------------------------------
2245 // wxMenuBar menus showing
2246 // ----------------------------------------------------------------------------
2247
2248 void wxMenuBar::PopupCurrentMenu(bool selectFirst)
2249 {
2250 wxCHECK_RET( m_current != -1, _T("no menu to popup") );
2251
2252 // forgot to call DismissMenu()?
2253 wxASSERT_MSG( !m_menuShown, _T("shouldn't show two menu at once!") );
2254
2255 // in any case, we should show it - even if we won't
2256 m_shouldShowMenu = TRUE;
2257
2258 if ( IsEnabledTop(m_current) )
2259 {
2260 // remember the menu we show
2261 m_menuShown = GetMenu(m_current);
2262
2263 // we don't show the menu at all if it has no items
2264 if ( !m_menuShown->IsEmpty() )
2265 {
2266 // position it correctly: note that we must use screen coords and
2267 // that we pass 0 as width to position the menu exactly below the
2268 // item, not to the right of it
2269 wxRect rectItem = GetItemRect(m_current);
2270
2271 m_menuShown->Popup(ClientToScreen(rectItem.GetPosition()),
2272 wxSize(0, rectItem.GetHeight()),
2273 selectFirst);
2274 }
2275 else
2276 {
2277 // reset it back as no menu is shown
2278 m_menuShown = NULL;
2279 }
2280 }
2281 //else: don't show disabled menu
2282 }
2283
2284 void wxMenuBar::DismissMenu()
2285 {
2286 wxCHECK_RET( m_menuShown, _T("can't dismiss menu if none is shown") );
2287
2288 m_menuShown->Dismiss();
2289 OnDismissMenu();
2290 }
2291
2292 void wxMenuBar::OnDismissMenu(bool dismissMenuBar)
2293 {
2294 m_shouldShowMenu = FALSE;
2295 m_menuShown = NULL;
2296 if ( dismissMenuBar )
2297 {
2298 OnDismiss();
2299 }
2300 }
2301
2302 void wxMenuBar::OnDismiss()
2303 {
2304 if ( GetCapture() )
2305 {
2306 wxLogTrace(_T("mousecapture"), _T("Releasing mouse from wxMenuBar::OnDismiss"));
2307 GetCapture()->ReleaseMouse();
2308 }
2309
2310 if ( m_current != -1 )
2311 {
2312 size_t current = m_current;
2313 m_current = -1;
2314
2315 RefreshItem(current);
2316 }
2317
2318 GiveAwayFocus();
2319 }
2320
2321 void wxMenuBar::GiveAwayFocus()
2322 {
2323 GetFrame()->SetFocus();
2324 }
2325
2326 // ----------------------------------------------------------------------------
2327 // popup menu support
2328 // ----------------------------------------------------------------------------
2329
2330 wxEventLoop *wxWindow::ms_evtLoopPopup = NULL;
2331
2332 bool wxWindow::DoPopupMenu(wxMenu *menu, int x, int y)
2333 {
2334 wxCHECK_MSG( !ms_evtLoopPopup, FALSE,
2335 _T("can't show more than one popup menu at a time") );
2336
2337 #ifdef __WXMSW__
2338 // we need to change the cursor before showing the menu as, apparently, no
2339 // cursor changes took place while the mouse is captured
2340 wxCursor cursorOld = GetCursor();
2341 SetCursor(wxCURSOR_ARROW);
2342 #endif // __WXMSW__
2343
2344 #if 0
2345 // flash any delayed log messages before showing the menu, otherwise it
2346 // could be dismissed (because it would lose focus) immediately after being
2347 // shown
2348 wxLog::FlushActive();
2349
2350 // some controls update themselves from OnIdle() call - let them do it
2351 wxIdleEvent event;
2352 wxTheApp->ProcessEvent(event);
2353
2354 // if the window hadn't been refreshed yet, the menu can adversely affect
2355 // its next OnPaint() handler execution - i.e. scrolled window refresh
2356 // logic breaks then as it scrolls part of the menu which hadn't been there
2357 // when the update event was generated into view
2358 Update();
2359 #endif // 0
2360
2361 menu->SetInvokingWindow(this);
2362
2363 // wxLogDebug( "Name of invoking window %s", menu->GetInvokingWindow()->GetName().c_str() );
2364
2365 menu->Popup(ClientToScreen(wxPoint(x, y)), wxSize(0, 0));
2366
2367 // this is not very useful if the menu was popped up because of the mouse
2368 // click but I think it is nice to do when it appears because of a key
2369 // press (i.e. Windows menu key)
2370 //
2371 // Windows itself doesn't do it, but IMHO this is nice
2372 WarpPointer(x, y);
2373
2374 // we have to redirect all keyboard input to the menu temporarily
2375 PushEventHandler(new wxMenuKbdRedirector(menu));
2376
2377 // enter the local modal loop
2378 ms_evtLoopPopup = new wxEventLoop;
2379 ms_evtLoopPopup->Run();
2380
2381 delete ms_evtLoopPopup;
2382 ms_evtLoopPopup = NULL;
2383
2384 // remove the handler
2385 PopEventHandler(TRUE /* delete it */);
2386
2387 menu->SetInvokingWindow(NULL);
2388
2389 #ifdef __WXMSW__
2390 SetCursor(cursorOld);
2391 #endif // __WXMSW__
2392
2393 return TRUE;
2394 }
2395
2396 void wxWindow::DismissPopupMenu()
2397 {
2398 wxCHECK_RET( ms_evtLoopPopup, _T("no popup menu shown") );
2399
2400 ms_evtLoopPopup->Exit();
2401 }
2402
2403 #endif // wxUSE_MENUS
2404
wxWidgets (Impactor)