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