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