]> git.saurik.com Git - wxWidgets.git/blob - src/common/menucmn.cpp
minor tab height bug fix
[wxWidgets.git] / src / common / menucmn.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/menucmn.cpp
3 // Purpose: wxMenu and wxMenuBar methods common to all ports
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 26.10.99
7 // RCS-ID: $Id$
8 // Copyright: (c) wxWidgets team
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 #if wxUSE_MENUS
28
29 #include <ctype.h>
30
31 #ifndef WX_PRECOMP
32 #include "wx/intl.h"
33 #include "wx/log.h"
34 #include "wx/menu.h"
35 #endif
36
37 #include "wx/stockitem.h"
38
39 // ----------------------------------------------------------------------------
40 // template lists
41 // ----------------------------------------------------------------------------
42
43 #include "wx/listimpl.cpp"
44
45 WX_DEFINE_LIST(wxMenuList)
46 WX_DEFINE_LIST(wxMenuItemList)
47
48 // ============================================================================
49 // implementation
50 // ============================================================================
51
52 // ----------------------------------------------------------------------------
53 // wxAcceleratorEntry
54 // ----------------------------------------------------------------------------
55
56
57 #if wxUSE_ACCEL
58
59 static const struct wxKeyName
60 {
61 wxKeyCode code;
62 const wxChar *name;
63 } wxKeyNames[] =
64 {
65 { WXK_DELETE, wxTRANSLATE("DEL") },
66 { WXK_DELETE, wxTRANSLATE("DELETE") },
67 { WXK_BACK, wxTRANSLATE("BACK") },
68 { WXK_INSERT, wxTRANSLATE("INS") },
69 { WXK_INSERT, wxTRANSLATE("INSERT") },
70 { WXK_RETURN, wxTRANSLATE("ENTER") },
71 { WXK_RETURN, wxTRANSLATE("RETURN") },
72 { WXK_PAGEUP, wxTRANSLATE("PGUP") },
73 { WXK_PAGEDOWN, wxTRANSLATE("PGDN") },
74 { WXK_LEFT, wxTRANSLATE("LEFT") },
75 { WXK_RIGHT, wxTRANSLATE("RIGHT") },
76 { WXK_UP, wxTRANSLATE("UP") },
77 { WXK_DOWN, wxTRANSLATE("DOWN") },
78 { WXK_HOME, wxTRANSLATE("HOME") },
79 { WXK_END, wxTRANSLATE("END") },
80 { WXK_SPACE, wxTRANSLATE("SPACE") },
81 { WXK_TAB, wxTRANSLATE("TAB") },
82 { WXK_ESCAPE, wxTRANSLATE("ESC") },
83 { WXK_ESCAPE, wxTRANSLATE("ESCAPE") },
84 { WXK_CANCEL, wxTRANSLATE("CANCEL") },
85 { WXK_CLEAR, wxTRANSLATE("CLEAR") },
86 { WXK_MENU, wxTRANSLATE("MENU") },
87 { WXK_PAUSE, wxTRANSLATE("PAUSE") },
88 { WXK_CAPITAL, wxTRANSLATE("CAPITAL") },
89 { WXK_SELECT, wxTRANSLATE("SELECT") },
90 { WXK_PRINT, wxTRANSLATE("PRINT") },
91 { WXK_EXECUTE, wxTRANSLATE("EXECUTE") },
92 { WXK_SNAPSHOT, wxTRANSLATE("SNAPSHOT") },
93 { WXK_HELP, wxTRANSLATE("HELP") },
94 { WXK_ADD, wxTRANSLATE("ADD") },
95 { WXK_SEPARATOR, wxTRANSLATE("SEPARATOR") },
96 { WXK_SUBTRACT, wxTRANSLATE("SUBTRACT") },
97 { WXK_DECIMAL, wxTRANSLATE("DECIMAL") },
98 { WXK_DIVIDE, wxTRANSLATE("DIVIDE") },
99 { WXK_NUMLOCK, wxTRANSLATE("NUM_LOCK") },
100 { WXK_SCROLL, wxTRANSLATE("SCROLL_LOCK") },
101 { WXK_PAGEUP, wxTRANSLATE("PAGEUP") },
102 { WXK_PAGEDOWN, wxTRANSLATE("PAGEDOWN") },
103 { WXK_NUMPAD_SPACE, wxTRANSLATE("KP_SPACE") },
104 { WXK_NUMPAD_TAB, wxTRANSLATE("KP_TAB") },
105 { WXK_NUMPAD_ENTER, wxTRANSLATE("KP_ENTER") },
106 { WXK_NUMPAD_HOME, wxTRANSLATE("KP_HOME") },
107 { WXK_NUMPAD_LEFT, wxTRANSLATE("KP_LEFT") },
108 { WXK_NUMPAD_UP, wxTRANSLATE("KP_UP") },
109 { WXK_NUMPAD_RIGHT, wxTRANSLATE("KP_RIGHT") },
110 { WXK_NUMPAD_DOWN, wxTRANSLATE("KP_DOWN") },
111 { WXK_NUMPAD_PAGEUP, wxTRANSLATE("KP_PRIOR") },
112 { WXK_NUMPAD_PAGEUP, wxTRANSLATE("KP_PAGEUP") },
113 { WXK_NUMPAD_PAGEDOWN, wxTRANSLATE("KP_NEXT") },
114 { WXK_NUMPAD_PAGEDOWN, wxTRANSLATE("KP_PAGEDOWN") },
115 { WXK_NUMPAD_END, wxTRANSLATE("KP_END") },
116 { WXK_NUMPAD_BEGIN, wxTRANSLATE("KP_BEGIN") },
117 { WXK_NUMPAD_INSERT, wxTRANSLATE("KP_INSERT") },
118 { WXK_NUMPAD_DELETE, wxTRANSLATE("KP_DELETE") },
119 { WXK_NUMPAD_EQUAL, wxTRANSLATE("KP_EQUAL") },
120 { WXK_NUMPAD_MULTIPLY, wxTRANSLATE("KP_MULTIPLY") },
121 { WXK_NUMPAD_ADD, wxTRANSLATE("KP_ADD") },
122 { WXK_NUMPAD_SEPARATOR, wxTRANSLATE("KP_SEPARATOR") },
123 { WXK_NUMPAD_SUBTRACT, wxTRANSLATE("KP_SUBTRACT") },
124 { WXK_NUMPAD_DECIMAL, wxTRANSLATE("KP_DECIMAL") },
125 { WXK_NUMPAD_DIVIDE, wxTRANSLATE("KP_DIVIDE") },
126 { WXK_WINDOWS_LEFT, wxTRANSLATE("WINDOWS_LEFT") },
127 { WXK_WINDOWS_RIGHT, wxTRANSLATE("WINDOWS_RIGHT") },
128 { WXK_WINDOWS_MENU, wxTRANSLATE("WINDOWS_MENU") },
129 { WXK_COMMAND, wxTRANSLATE("COMMAND") },
130 };
131
132 // return true if the 2 strings refer to the same accel
133 //
134 // as accels can be either translated or not, check for both possibilities and
135 // also compare case-insensitively as the key names case doesn't count
136 static inline bool CompareAccelString(const wxString& str, const wxChar *accel)
137 {
138 return str.CmpNoCase(accel) == 0
139 #if wxUSE_INTL
140 || str.CmpNoCase(wxGetTranslation(accel)) == 0
141 #endif
142 ;
143 }
144
145 // return prefixCode+number if the string is of the form "<prefix><number>" and
146 // 0 if it isn't
147 //
148 // first and last parameter specify the valid domain for "number" part
149 static int
150 IsNumberedAccelKey(const wxString& str,
151 const wxChar *prefix,
152 wxKeyCode prefixCode,
153 unsigned first,
154 unsigned last)
155 {
156 const size_t lenPrefix = wxStrlen(prefix);
157 if ( !CompareAccelString(str.Left(lenPrefix), prefix) )
158 return 0;
159
160 unsigned long num;
161 if ( !str.Mid(lenPrefix).ToULong(&num) )
162 return 0;
163
164 if ( num < first || num > last )
165 {
166 // this must be a mistake, chances that this is a valid name of another
167 // key are vanishingly small
168 wxLogDebug(_T("Invalid key string \"%s\""), str.c_str());
169 return 0;
170 }
171
172 return prefixCode + num - first;
173 }
174
175 /* static */
176 bool
177 wxAcceleratorEntry::ParseAccel(const wxString& text, int *flagsOut, int *keyOut)
178 {
179 // the parser won't like trailing spaces
180 wxString label = text;
181 label.Trim(true); // the initial \t must be preserved so don't strip leading whitespaces
182
183 // check for accelerators: they are given after '\t'
184 int posTab = label.Find(wxT('\t'));
185 if ( posTab == wxNOT_FOUND )
186 {
187 return false;
188 }
189
190 // parse the accelerator string
191 int accelFlags = wxACCEL_NORMAL;
192 wxString current;
193 for ( size_t n = (size_t)posTab + 1; n < label.length(); n++ )
194 {
195 if ( (label[n] == '+') || (label[n] == '-') )
196 {
197 if ( CompareAccelString(current, wxTRANSLATE("ctrl")) )
198 accelFlags |= wxACCEL_CTRL;
199 else if ( CompareAccelString(current, wxTRANSLATE("alt")) )
200 accelFlags |= wxACCEL_ALT;
201 else if ( CompareAccelString(current, wxTRANSLATE("shift")) )
202 accelFlags |= wxACCEL_SHIFT;
203 else // not a recognized modifier name
204 {
205 // we may have "Ctrl-+", for example, but we still want to
206 // catch typos like "Crtl-A" so only give the warning if we
207 // have something before the current '+' or '-', else take
208 // it as a literal symbol
209 if ( current.empty() )
210 {
211 current += label[n];
212
213 // skip clearing it below
214 continue;
215 }
216 else
217 {
218 wxLogDebug(wxT("Unknown accel modifier: '%s'"),
219 current.c_str());
220 }
221 }
222
223 current.clear();
224 }
225 else // not special character
226 {
227 current += (wxChar) wxTolower(label[n]);
228 }
229 }
230
231 int keyCode;
232 const size_t len = current.length();
233 switch ( len )
234 {
235 case 0:
236 wxLogDebug(wxT("No accel key found, accel string ignored."));
237 return false;
238
239 case 1:
240 // it's just a letter
241 keyCode = current[0U];
242
243 // if the key is used with any modifiers, make it an uppercase one
244 // because Ctrl-A and Ctrl-a are the same; but keep it as is if it's
245 // used alone as 'a' and 'A' are different
246 if ( accelFlags != wxACCEL_NORMAL )
247 keyCode = wxToupper(keyCode);
248 break;
249
250 default:
251 keyCode = IsNumberedAccelKey(current, wxTRANSLATE("F"),
252 WXK_F1, 1, 12);
253 if ( !keyCode )
254 {
255 for ( size_t n = 0; n < WXSIZEOF(wxKeyNames); n++ )
256 {
257 const wxKeyName& kn = wxKeyNames[n];
258 if ( CompareAccelString(current, kn.name) )
259 {
260 keyCode = kn.code;
261 break;
262 }
263 }
264 }
265
266 if ( !keyCode )
267 keyCode = IsNumberedAccelKey(current, wxTRANSLATE("KP_"),
268 WXK_NUMPAD0, 0, 9);
269 if ( !keyCode )
270 keyCode = IsNumberedAccelKey(current, wxTRANSLATE("SPECIAL"),
271 WXK_SPECIAL1, 1, 20);
272
273 if ( !keyCode )
274 {
275 wxLogDebug(wxT("Unrecognized accel key '%s', accel string ignored."),
276 current.c_str());
277 return false;
278 }
279 }
280
281
282 wxASSERT_MSG( keyCode, _T("logic error: should have key code here") );
283
284 if ( flagsOut )
285 *flagsOut = accelFlags;
286 if ( keyOut )
287 *keyOut = keyCode;
288
289 return true;
290 }
291
292 /* static */
293 wxAcceleratorEntry *wxAcceleratorEntry::Create(const wxString& str)
294 {
295 int flags,
296 keyCode;
297 if ( !ParseAccel(str, &flags, &keyCode) )
298 return NULL;
299
300 return new wxAcceleratorEntry(flags, keyCode);
301 }
302
303 bool wxAcceleratorEntry::FromString(const wxString& str)
304 {
305 return ParseAccel(str, &m_flags, &m_keyCode);
306 }
307
308 wxString wxAcceleratorEntry::ToString() const
309 {
310 wxString text;
311
312 int flags = GetFlags();
313 if ( flags & wxACCEL_ALT )
314 text += _("Alt-");
315 if ( flags & wxACCEL_CTRL )
316 text += _("Ctrl-");
317 if ( flags & wxACCEL_SHIFT )
318 text += _("Shift-");
319
320 const int code = GetKeyCode();
321
322 if ( wxIsalnum(code) )
323 text << (wxChar)code;
324 else if ( code >= WXK_F1 && code <= WXK_F12 )
325 text << _("F") << code - WXK_F1 + 1;
326 else if ( code >= WXK_NUMPAD0 && code <= WXK_NUMPAD9 )
327 text << _("KP_") << code - WXK_NUMPAD0;
328 else if ( code >= WXK_SPECIAL1 && code <= WXK_SPECIAL20 )
329 text << _("SPECIAL") << code - WXK_SPECIAL1 + 1;
330 else // check the named keys
331 {
332 size_t n;
333 for ( n = 0; n < WXSIZEOF(wxKeyNames); n++ )
334 {
335 const wxKeyName& kn = wxKeyNames[n];
336 if ( code == kn.code )
337 {
338 text << wxGetTranslation(kn.name);
339 break;
340 }
341 }
342
343 wxASSERT_MSG( n != WXSIZEOF(wxKeyNames),
344 wxT("unknown keyboard accelerator code") );
345 }
346
347 return text;
348 }
349
350 wxAcceleratorEntry *wxGetAccelFromString(const wxString& label)
351 {
352 return wxAcceleratorEntry::Create(label);
353 }
354
355 #endif // wxUSE_ACCEL
356
357
358 // ----------------------------------------------------------------------------
359 // wxMenuItem
360 // ----------------------------------------------------------------------------
361
362 wxMenuItemBase::wxMenuItemBase(wxMenu *parentMenu,
363 int id,
364 const wxString& text,
365 const wxString& help,
366 wxItemKind kind,
367 wxMenu *subMenu)
368 {
369 wxASSERT_MSG( parentMenu != NULL, wxT("menuitem should have a menu") );
370
371 m_parentMenu = parentMenu;
372 m_subMenu = subMenu;
373 m_isEnabled = true;
374 m_isChecked = false;
375 m_id = id;
376 m_kind = kind;
377 if (m_id == wxID_ANY)
378 m_id = wxNewId();
379 if (m_id == wxID_SEPARATOR)
380 m_kind = wxITEM_SEPARATOR;
381
382 SetText(text);
383 SetHelp(help);
384 }
385
386 wxMenuItemBase::~wxMenuItemBase()
387 {
388 delete m_subMenu;
389 }
390
391 #if wxUSE_ACCEL
392
393 wxAcceleratorEntry *wxMenuItemBase::GetAccel() const
394 {
395 return wxAcceleratorEntry::Create(GetText());
396 }
397
398 void wxMenuItemBase::SetAccel(wxAcceleratorEntry *accel)
399 {
400 wxString text = m_text.BeforeFirst(wxT('\t'));
401 if ( accel )
402 {
403 text += wxT('\t');
404 text += accel->ToString();
405 }
406
407 SetText(text);
408 }
409
410 #endif // wxUSE_ACCEL
411
412 void wxMenuItemBase::SetText(const wxString& str)
413 {
414 m_text = str;
415
416 if ( m_text.empty() && !IsSeparator() )
417 {
418 wxASSERT_MSG( wxIsStockID(GetId()),
419 wxT("A non-stock menu item with an empty label?") );
420 m_text = wxGetStockLabel(GetId(), wxSTOCK_WITH_ACCELERATOR |
421 wxSTOCK_WITH_MNEMONIC);
422 }
423 }
424
425 void wxMenuItemBase::SetHelp(const wxString& str)
426 {
427 m_help = str;
428
429 if ( m_help.empty() && !IsSeparator() && wxIsStockID(GetId()) )
430 {
431 // get a stock help string
432 m_help = wxGetStockHelpString(GetId());
433 }
434 }
435
436 bool wxMenuBase::ms_locked = true;
437
438 // ----------------------------------------------------------------------------
439 // wxMenu ctor and dtor
440 // ----------------------------------------------------------------------------
441
442 void wxMenuBase::Init(long style)
443 {
444 m_menuBar = (wxMenuBar *)NULL;
445 m_menuParent = (wxMenu *)NULL;
446
447 m_invokingWindow = (wxWindow *)NULL;
448 m_style = style;
449 m_clientData = (void *)NULL;
450 m_eventHandler = this;
451 }
452
453 wxMenuBase::~wxMenuBase()
454 {
455 WX_CLEAR_LIST(wxMenuItemList, m_items);
456
457 // Actually, in GTK, the submenus have to get deleted first.
458 }
459
460 // ----------------------------------------------------------------------------
461 // wxMenu item adding/removing
462 // ----------------------------------------------------------------------------
463
464 void wxMenuBase::AddSubMenu(wxMenu *submenu)
465 {
466 wxCHECK_RET( submenu, _T("can't add a NULL submenu") );
467
468 submenu->SetParent((wxMenu *)this);
469 }
470
471 wxMenuItem* wxMenuBase::DoAppend(wxMenuItem *item)
472 {
473 wxCHECK_MSG( item, NULL, wxT("invalid item in wxMenu::Append()") );
474
475 m_items.Append(item);
476 item->SetMenu((wxMenu*)this);
477 if ( item->IsSubMenu() )
478 {
479 AddSubMenu(item->GetSubMenu());
480 }
481
482 return item;
483 }
484
485 wxMenuItem* wxMenuBase::Insert(size_t pos, wxMenuItem *item)
486 {
487 wxCHECK_MSG( item, NULL, wxT("invalid item in wxMenu::Insert") );
488
489 if ( pos == GetMenuItemCount() )
490 {
491 return DoAppend(item);
492 }
493 else
494 {
495 wxCHECK_MSG( pos < GetMenuItemCount(), NULL,
496 wxT("invalid index in wxMenu::Insert") );
497
498 return DoInsert(pos, item);
499 }
500 }
501
502 wxMenuItem* wxMenuBase::DoInsert(size_t pos, wxMenuItem *item)
503 {
504 wxCHECK_MSG( item, NULL, wxT("invalid item in wxMenu::Insert()") );
505
506 wxMenuItemList::compatibility_iterator node = m_items.Item(pos);
507 wxCHECK_MSG( node, NULL, wxT("invalid index in wxMenu::Insert()") );
508
509 m_items.Insert(node, item);
510 item->SetMenu((wxMenu*)this);
511 if ( item->IsSubMenu() )
512 {
513 AddSubMenu(item->GetSubMenu());
514 }
515
516 return item;
517 }
518
519 wxMenuItem *wxMenuBase::Remove(wxMenuItem *item)
520 {
521 wxCHECK_MSG( item, NULL, wxT("invalid item in wxMenu::Remove") );
522
523 return DoRemove(item);
524 }
525
526 wxMenuItem *wxMenuBase::DoRemove(wxMenuItem *item)
527 {
528 wxMenuItemList::compatibility_iterator node = m_items.Find(item);
529
530 // if we get here, the item is valid or one of Remove() functions is broken
531 wxCHECK_MSG( node, NULL, wxT("bug in wxMenu::Remove logic") );
532
533 // we detach the item, but we do delete the list node (i.e. don't call
534 // DetachNode() here!)
535 m_items.Erase(node);
536
537 // item isn't attached to anything any more
538 item->SetMenu((wxMenu *)NULL);
539 wxMenu *submenu = item->GetSubMenu();
540 if ( submenu )
541 {
542 submenu->SetParent((wxMenu *)NULL);
543 if ( submenu->IsAttached() )
544 submenu->Detach();
545 }
546
547 return item;
548 }
549
550 bool wxMenuBase::Delete(wxMenuItem *item)
551 {
552 wxCHECK_MSG( item, false, wxT("invalid item in wxMenu::Delete") );
553
554 return DoDelete(item);
555 }
556
557 bool wxMenuBase::DoDelete(wxMenuItem *item)
558 {
559 wxMenuItem *item2 = DoRemove(item);
560 wxCHECK_MSG( item2, false, wxT("failed to delete menu item") );
561
562 // don't delete the submenu
563 item2->SetSubMenu((wxMenu *)NULL);
564
565 delete item2;
566
567 return true;
568 }
569
570 bool wxMenuBase::Destroy(wxMenuItem *item)
571 {
572 wxCHECK_MSG( item, false, wxT("invalid item in wxMenu::Destroy") );
573
574 return DoDestroy(item);
575 }
576
577 bool wxMenuBase::DoDestroy(wxMenuItem *item)
578 {
579 wxMenuItem *item2 = DoRemove(item);
580 wxCHECK_MSG( item2, false, wxT("failed to delete menu item") );
581
582 delete item2;
583
584 return true;
585 }
586
587 // ----------------------------------------------------------------------------
588 // wxMenu searching for items
589 // ----------------------------------------------------------------------------
590
591 // Finds the item id matching the given string, wxNOT_FOUND if not found.
592 int wxMenuBase::FindItem(const wxString& text) const
593 {
594 wxString label = wxMenuItem::GetLabelFromText(text);
595 for ( wxMenuItemList::compatibility_iterator node = m_items.GetFirst();
596 node;
597 node = node->GetNext() )
598 {
599 wxMenuItem *item = node->GetData();
600 if ( item->IsSubMenu() )
601 {
602 int rc = item->GetSubMenu()->FindItem(label);
603 if ( rc != wxNOT_FOUND )
604 return rc;
605 }
606
607 // we execute this code for submenus as well to alllow finding them by
608 // name just like the ordinary items
609 if ( !item->IsSeparator() )
610 {
611 if ( item->GetLabel() == label )
612 return item->GetId();
613 }
614 }
615
616 return wxNOT_FOUND;
617 }
618
619 // recursive search for item by id
620 wxMenuItem *wxMenuBase::FindItem(int itemId, wxMenu **itemMenu) const
621 {
622 if ( itemMenu )
623 *itemMenu = NULL;
624
625 wxMenuItem *item = NULL;
626 for ( wxMenuItemList::compatibility_iterator node = m_items.GetFirst();
627 node && !item;
628 node = node->GetNext() )
629 {
630 item = node->GetData();
631
632 if ( item->GetId() == itemId )
633 {
634 if ( itemMenu )
635 *itemMenu = (wxMenu *)this;
636 }
637 else if ( item->IsSubMenu() )
638 {
639 item = item->GetSubMenu()->FindItem(itemId, itemMenu);
640 }
641 else
642 {
643 // don't exit the loop
644 item = NULL;
645 }
646 }
647
648 return item;
649 }
650
651 // non recursive search
652 wxMenuItem *wxMenuBase::FindChildItem(int id, size_t *ppos) const
653 {
654 wxMenuItem *item = (wxMenuItem *)NULL;
655 wxMenuItemList::compatibility_iterator node = GetMenuItems().GetFirst();
656
657 size_t pos;
658 for ( pos = 0; node; pos++ )
659 {
660 if ( node->GetData()->GetId() == id )
661 {
662 item = node->GetData();
663
664 break;
665 }
666
667 node = node->GetNext();
668 }
669
670 if ( ppos )
671 {
672 *ppos = item ? pos : (size_t)wxNOT_FOUND;
673 }
674
675 return item;
676 }
677
678 // find by position
679 wxMenuItem* wxMenuBase::FindItemByPosition(size_t position) const
680 {
681 wxCHECK_MSG( position < m_items.GetCount(), NULL,
682 _T("wxMenu::FindItemByPosition(): invalid menu index") );
683
684 return m_items.Item( position )->GetData();
685 }
686
687 // ----------------------------------------------------------------------------
688 // wxMenu helpers used by derived classes
689 // ----------------------------------------------------------------------------
690
691 // Update a menu and all submenus recursively. source is the object that has
692 // the update event handlers defined for it. If NULL, the menu or associated
693 // window will be used.
694 void wxMenuBase::UpdateUI(wxEvtHandler* source)
695 {
696 if (GetInvokingWindow())
697 {
698 // Don't update menus if the parent
699 // frame is about to get deleted
700 wxWindow *tlw = wxGetTopLevelParent( GetInvokingWindow() );
701 if (tlw && wxPendingDelete.Member(tlw))
702 return;
703 }
704
705 if ( !source && GetInvokingWindow() )
706 source = GetInvokingWindow()->GetEventHandler();
707 if ( !source )
708 source = GetEventHandler();
709 if ( !source )
710 source = this;
711
712 wxMenuItemList::compatibility_iterator node = GetMenuItems().GetFirst();
713 while ( node )
714 {
715 wxMenuItem* item = node->GetData();
716 if ( !item->IsSeparator() )
717 {
718 wxWindowID id = item->GetId();
719 wxUpdateUIEvent event(id);
720 event.SetEventObject( source );
721
722 if ( source->ProcessEvent(event) )
723 {
724 // if anything changed, update the changed attribute
725 if (event.GetSetText())
726 SetLabel(id, event.GetText());
727 if (event.GetSetChecked())
728 Check(id, event.GetChecked());
729 if (event.GetSetEnabled())
730 Enable(id, event.GetEnabled());
731 }
732
733 // recurse to the submenus
734 if ( item->GetSubMenu() )
735 item->GetSubMenu()->UpdateUI(source);
736 }
737 //else: item is a separator (which doesn't process update UI events)
738
739 node = node->GetNext();
740 }
741 }
742
743 bool wxMenuBase::SendEvent(int id, int checked)
744 {
745 wxCommandEvent event(wxEVT_COMMAND_MENU_SELECTED, id);
746 event.SetEventObject(this);
747 event.SetInt(checked);
748
749 bool processed = false;
750
751 // Try the menu's event handler
752 // if ( !processed )
753 {
754 wxEvtHandler *handler = GetEventHandler();
755 if ( handler )
756 processed = handler->ProcessEvent(event);
757 }
758
759 // Try the window the menu was popped up from (and up through the
760 // hierarchy)
761 if ( !processed )
762 {
763 const wxMenuBase *menu = this;
764 while ( menu )
765 {
766 wxWindow *win = menu->GetInvokingWindow();
767 if ( win )
768 {
769 processed = win->GetEventHandler()->ProcessEvent(event);
770 break;
771 }
772
773 menu = menu->GetParent();
774 }
775 }
776
777 return processed;
778 }
779
780 // ----------------------------------------------------------------------------
781 // wxMenu attaching/detaching to/from menu bar
782 // ----------------------------------------------------------------------------
783
784 wxMenuBar* wxMenuBase::GetMenuBar() const
785 {
786 if(GetParent())
787 return GetParent()->GetMenuBar();
788 return m_menuBar;
789 }
790
791 void wxMenuBase::Attach(wxMenuBarBase *menubar)
792 {
793 // use Detach() instead!
794 wxASSERT_MSG( menubar, _T("menu can't be attached to NULL menubar") );
795
796 // use IsAttached() to prevent this from happening
797 wxASSERT_MSG( !m_menuBar, _T("attaching menu twice?") );
798
799 m_menuBar = (wxMenuBar *)menubar;
800 }
801
802 void wxMenuBase::Detach()
803 {
804 // use IsAttached() to prevent this from happening
805 wxASSERT_MSG( m_menuBar, _T("detaching unattached menu?") );
806
807 m_menuBar = NULL;
808 }
809
810 // ----------------------------------------------------------------------------
811 // wxMenu functions forwarded to wxMenuItem
812 // ----------------------------------------------------------------------------
813
814 void wxMenuBase::Enable( int id, bool enable )
815 {
816 wxMenuItem *item = FindItem(id);
817
818 wxCHECK_RET( item, wxT("wxMenu::Enable: no such item") );
819
820 item->Enable(enable);
821 }
822
823 bool wxMenuBase::IsEnabled( int id ) const
824 {
825 wxMenuItem *item = FindItem(id);
826
827 wxCHECK_MSG( item, false, wxT("wxMenu::IsEnabled: no such item") );
828
829 return item->IsEnabled();
830 }
831
832 void wxMenuBase::Check( int id, bool enable )
833 {
834 wxMenuItem *item = FindItem(id);
835
836 wxCHECK_RET( item, wxT("wxMenu::Check: no such item") );
837
838 item->Check(enable);
839 }
840
841 bool wxMenuBase::IsChecked( int id ) const
842 {
843 wxMenuItem *item = FindItem(id);
844
845 wxCHECK_MSG( item, false, wxT("wxMenu::IsChecked: no such item") );
846
847 return item->IsChecked();
848 }
849
850 void wxMenuBase::SetLabel( int id, const wxString &label )
851 {
852 wxMenuItem *item = FindItem(id);
853
854 wxCHECK_RET( item, wxT("wxMenu::SetLabel: no such item") );
855
856 item->SetText(label);
857 }
858
859 wxString wxMenuBase::GetLabel( int id ) const
860 {
861 wxMenuItem *item = FindItem(id);
862
863 wxCHECK_MSG( item, wxEmptyString, wxT("wxMenu::GetLabel: no such item") );
864
865 return item->GetText();
866 }
867
868 void wxMenuBase::SetHelpString( int id, const wxString& helpString )
869 {
870 wxMenuItem *item = FindItem(id);
871
872 wxCHECK_RET( item, wxT("wxMenu::SetHelpString: no such item") );
873
874 item->SetHelp( helpString );
875 }
876
877 wxString wxMenuBase::GetHelpString( int id ) const
878 {
879 wxMenuItem *item = FindItem(id);
880
881 wxCHECK_MSG( item, wxEmptyString, wxT("wxMenu::GetHelpString: no such item") );
882
883 return item->GetHelp();
884 }
885
886 // ----------------------------------------------------------------------------
887 // wxMenuBarBase ctor and dtor
888 // ----------------------------------------------------------------------------
889
890 wxMenuBarBase::wxMenuBarBase()
891 {
892 // not attached yet
893 m_menuBarFrame = NULL;
894 }
895
896 wxMenuBarBase::~wxMenuBarBase()
897 {
898 WX_CLEAR_LIST(wxMenuList, m_menus);
899 }
900
901 // ----------------------------------------------------------------------------
902 // wxMenuBar item access: the base class versions manage m_menus list, the
903 // derived class should reflect the changes in the real menubar
904 // ----------------------------------------------------------------------------
905
906 wxMenu *wxMenuBarBase::GetMenu(size_t pos) const
907 {
908 wxMenuList::compatibility_iterator node = m_menus.Item(pos);
909 wxCHECK_MSG( node, NULL, wxT("bad index in wxMenuBar::GetMenu()") );
910
911 return node->GetData();
912 }
913
914 bool wxMenuBarBase::Append(wxMenu *menu, const wxString& WXUNUSED(title))
915 {
916 wxCHECK_MSG( menu, false, wxT("can't append NULL menu") );
917
918 m_menus.Append(menu);
919 menu->Attach(this);
920
921 return true;
922 }
923
924 bool wxMenuBarBase::Insert(size_t pos, wxMenu *menu,
925 const wxString& title)
926 {
927 if ( pos == m_menus.GetCount() )
928 {
929 return wxMenuBarBase::Append(menu, title);
930 }
931 else // not at the end
932 {
933 wxCHECK_MSG( menu, false, wxT("can't insert NULL menu") );
934
935 wxMenuList::compatibility_iterator node = m_menus.Item(pos);
936 wxCHECK_MSG( node, false, wxT("bad index in wxMenuBar::Insert()") );
937
938 m_menus.Insert(node, menu);
939 menu->Attach(this);
940
941 return true;
942 }
943 }
944
945 wxMenu *wxMenuBarBase::Replace(size_t pos, wxMenu *menu,
946 const wxString& WXUNUSED(title))
947 {
948 wxCHECK_MSG( menu, NULL, wxT("can't insert NULL menu") );
949
950 wxMenuList::compatibility_iterator node = m_menus.Item(pos);
951 wxCHECK_MSG( node, NULL, wxT("bad index in wxMenuBar::Replace()") );
952
953 wxMenu *menuOld = node->GetData();
954 node->SetData(menu);
955
956 menu->Attach(this);
957 menuOld->Detach();
958
959 return menuOld;
960 }
961
962 wxMenu *wxMenuBarBase::Remove(size_t pos)
963 {
964 wxMenuList::compatibility_iterator node = m_menus.Item(pos);
965 wxCHECK_MSG( node, NULL, wxT("bad index in wxMenuBar::Remove()") );
966
967 wxMenu *menu = node->GetData();
968 m_menus.Erase(node);
969 menu->Detach();
970
971 return menu;
972 }
973
974 int wxMenuBarBase::FindMenu(const wxString& title) const
975 {
976 wxString label = wxMenuItem::GetLabelFromText(title);
977
978 size_t count = GetMenuCount();
979 for ( size_t i = 0; i < count; i++ )
980 {
981 wxString title2 = GetLabelTop(i);
982 if ( (title2 == title) ||
983 (wxMenuItem::GetLabelFromText(title2) == label) )
984 {
985 // found
986 return (int)i;
987 }
988 }
989
990 return wxNOT_FOUND;
991
992 }
993
994 // ----------------------------------------------------------------------------
995 // wxMenuBar attaching/detaching to/from the frame
996 // ----------------------------------------------------------------------------
997
998 void wxMenuBarBase::Attach(wxFrame *frame)
999 {
1000 wxASSERT_MSG( !IsAttached(), wxT("menubar already attached!") );
1001
1002 m_menuBarFrame = frame;
1003 }
1004
1005 void wxMenuBarBase::Detach()
1006 {
1007 wxASSERT_MSG( IsAttached(), wxT("detaching unattached menubar") );
1008
1009 m_menuBarFrame = NULL;
1010 }
1011
1012 // ----------------------------------------------------------------------------
1013 // wxMenuBar searching for items
1014 // ----------------------------------------------------------------------------
1015
1016 wxMenuItem *wxMenuBarBase::FindItem(int id, wxMenu **menu) const
1017 {
1018 if ( menu )
1019 *menu = NULL;
1020
1021 wxMenuItem *item = NULL;
1022 size_t count = GetMenuCount(), i;
1023 wxMenuList::const_iterator it;
1024 for ( i = 0, it = m_menus.begin(); !item && (i < count); i++, it++ )
1025 {
1026 item = (*it)->FindItem(id, menu);
1027 }
1028
1029 return item;
1030 }
1031
1032 int wxMenuBarBase::FindMenuItem(const wxString& menu, const wxString& item) const
1033 {
1034 wxString label = wxMenuItem::GetLabelFromText(menu);
1035
1036 int i = 0;
1037 wxMenuList::compatibility_iterator node;
1038 for ( node = m_menus.GetFirst(); node; node = node->GetNext(), i++ )
1039 {
1040 if ( label == wxMenuItem::GetLabelFromText(GetLabelTop(i)) )
1041 return node->GetData()->FindItem(item);
1042 }
1043
1044 return wxNOT_FOUND;
1045 }
1046
1047 // ---------------------------------------------------------------------------
1048 // wxMenuBar functions forwarded to wxMenuItem
1049 // ---------------------------------------------------------------------------
1050
1051 void wxMenuBarBase::Enable(int id, bool enable)
1052 {
1053 wxMenuItem *item = FindItem(id);
1054
1055 wxCHECK_RET( item, wxT("attempt to enable an item which doesn't exist") );
1056
1057 item->Enable(enable);
1058 }
1059
1060 void wxMenuBarBase::Check(int id, bool check)
1061 {
1062 wxMenuItem *item = FindItem(id);
1063
1064 wxCHECK_RET( item, wxT("attempt to check an item which doesn't exist") );
1065 wxCHECK_RET( item->IsCheckable(), wxT("attempt to check an uncheckable item") );
1066
1067 item->Check(check);
1068 }
1069
1070 bool wxMenuBarBase::IsChecked(int id) const
1071 {
1072 wxMenuItem *item = FindItem(id);
1073
1074 wxCHECK_MSG( item, false, wxT("wxMenuBar::IsChecked(): no such item") );
1075
1076 return item->IsChecked();
1077 }
1078
1079 bool wxMenuBarBase::IsEnabled(int id) const
1080 {
1081 wxMenuItem *item = FindItem(id);
1082
1083 wxCHECK_MSG( item, false, wxT("wxMenuBar::IsEnabled(): no such item") );
1084
1085 return item->IsEnabled();
1086 }
1087
1088 void wxMenuBarBase::SetLabel(int id, const wxString& label)
1089 {
1090 wxMenuItem *item = FindItem(id);
1091
1092 wxCHECK_RET( item, wxT("wxMenuBar::SetLabel(): no such item") );
1093
1094 item->SetText(label);
1095 }
1096
1097 wxString wxMenuBarBase::GetLabel(int id) const
1098 {
1099 wxMenuItem *item = FindItem(id);
1100
1101 wxCHECK_MSG( item, wxEmptyString,
1102 wxT("wxMenuBar::GetLabel(): no such item") );
1103
1104 return item->GetText();
1105 }
1106
1107 void wxMenuBarBase::SetHelpString(int id, const wxString& helpString)
1108 {
1109 wxMenuItem *item = FindItem(id);
1110
1111 wxCHECK_RET( item, wxT("wxMenuBar::SetHelpString(): no such item") );
1112
1113 item->SetHelp(helpString);
1114 }
1115
1116 wxString wxMenuBarBase::GetHelpString(int id) const
1117 {
1118 wxMenuItem *item = FindItem(id);
1119
1120 wxCHECK_MSG( item, wxEmptyString,
1121 wxT("wxMenuBar::GetHelpString(): no such item") );
1122
1123 return item->GetHelp();
1124 }
1125
1126 void wxMenuBarBase::UpdateMenus( void )
1127 {
1128 wxEvtHandler* source;
1129 wxMenu* menu;
1130 int nCount = GetMenuCount();
1131 for (int n = 0; n < nCount; n++)
1132 {
1133 menu = GetMenu( n );
1134 if (menu != NULL)
1135 {
1136 source = menu->GetEventHandler();
1137 if (source != NULL)
1138 menu->UpdateUI( source );
1139 }
1140 }
1141 }
1142
1143 #endif // wxUSE_MENUS