]> git.saurik.com Git - wxWidgets.git/blob - src/mac/menu.cpp
changed charset to iso8859-2
[wxWidgets.git] / src / mac / menu.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: menu.cpp
3 // Purpose: wxMenu, wxMenuBar, wxMenuItem
4 // Author: AUTHOR
5 // Modified by:
6 // Created: ??/??/98
7 // RCS-ID: $Id$
8 // Copyright: (c) AUTHOR
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12
13 // ============================================================================
14 // headers & declarations
15 // ============================================================================
16
17 // wxWindows headers
18 // -----------------
19
20 #ifdef __GNUG__
21 #pragma implementation "menu.h"
22 #pragma implementation "menuitem.h"
23 #endif
24
25 #include "wx/app.h"
26 #include "wx/menu.h"
27 #include "wx/menuitem.h"
28 #include "wx/window.h"
29 #include "wx/log.h"
30 #include "wx/utils.h"
31
32 #include "wx/mac/uma.h"
33
34 // other standard headers
35 // ----------------------
36 #include <string.h>
37
38 #if !USE_SHARED_LIBRARY
39 IMPLEMENT_DYNAMIC_CLASS(wxMenu, wxEvtHandler)
40 IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxEvtHandler)
41 #endif
42
43 // the (popup) menu title has this special id
44 static const int idMenuTitle = -2;
45 static MenuItemIndex firstUserHelpMenuItem = 0 ;
46
47 const short kwxMacMenuBarResource = 1 ;
48 const short kwxMacAppleMenuId = 1 ;
49
50 // ============================================================================
51 // implementation
52 // ============================================================================
53
54
55 // Menus
56
57 // Construct a menu with optional title (then use append)
58
59 #ifdef __DARWIN__
60 short wxMenu::s_macNextMenuId = 3 ;
61 #else
62 short wxMenu::s_macNextMenuId = 2 ;
63 #endif
64
65 void wxMenu::Init()
66 {
67 m_doBreak = FALSE;
68
69 // create the menu
70 Str255 label;
71 wxMenuItem::MacBuildMenuString( label, NULL , NULL , m_title , false );
72 m_macMenuId = s_macNextMenuId++;
73 wxCHECK_RET( s_macNextMenuId < 236 , "menu ids > 235 cannot be used for submenus on mac" );
74 m_hMenu = ::NewMenu(m_macMenuId, label);
75
76 if ( !m_hMenu )
77 {
78 wxLogLastError("CreatePopupMenu");
79 }
80
81 // if we have a title, insert it in the beginning of the menu
82 if ( !!m_title )
83 {
84 Append(idMenuTitle, m_title) ;
85 AppendSeparator() ;
86 }
87 }
88
89 wxMenu::~wxMenu()
90 {
91 if (MAC_WXHMENU(m_hMenu))
92 ::DisposeMenu(MAC_WXHMENU(m_hMenu));
93
94 #if wxUSE_ACCEL
95 // delete accels
96 WX_CLEAR_ARRAY(m_accels);
97 #endif // wxUSE_ACCEL
98 }
99
100 void wxMenu::Break()
101 {
102 // not available on the mac platform
103 }
104
105 #if wxUSE_ACCEL
106
107 int wxMenu::FindAccel(int id) const
108 {
109 size_t n, count = m_accels.GetCount();
110 for ( n = 0; n < count; n++ )
111 {
112 if ( m_accels[n]->m_command == id )
113 return n;
114 }
115
116 return wxNOT_FOUND;
117 }
118
119 void wxMenu::UpdateAccel(wxMenuItem *item)
120 {
121 // find the (new) accel for this item
122 wxAcceleratorEntry *accel = wxGetAccelFromString(item->GetText());
123 if ( accel )
124 accel->m_command = item->GetId();
125
126 // find the old one
127 int n = FindAccel(item->GetId());
128 if ( n == wxNOT_FOUND )
129 {
130 // no old, add new if any
131 if ( accel )
132 m_accels.Add(accel);
133 else
134 return; // skipping RebuildAccelTable() below
135 }
136 else
137 {
138 // replace old with new or just remove the old one if no new
139 delete m_accels[n];
140 if ( accel )
141 m_accels[n] = accel;
142 else
143 m_accels.RemoveAt(n);
144 }
145
146 if ( IsAttached() )
147 {
148 m_menuBar->RebuildAccelTable();
149 }
150 }
151
152 #endif // wxUSE_ACCEL
153
154 // function appends a new item or submenu to the menu
155 // append a new item or submenu to the menu
156 bool wxMenu::DoInsertOrAppend(wxMenuItem *pItem, size_t pos)
157 {
158 wxASSERT_MSG( pItem != NULL, "can't append NULL item to the menu" );
159 #if wxUSE_ACCEL
160 UpdateAccel(pItem);
161 #endif // wxUSE_ACCEL
162
163 if ( pItem->IsSeparator() )
164 {
165 if ( pos == (size_t)-1 )
166 {
167 MacAppendMenu(MAC_WXHMENU(m_hMenu), "\p-");
168 }
169 else
170 {
171 MacInsertMenuItem(MAC_WXHMENU(m_hMenu), "\p-" , pos);
172 }
173 }
174 else
175 {
176 wxMenu *pSubMenu = pItem->GetSubMenu() ;
177 if ( pSubMenu != NULL )
178 {
179 Str255 label;
180 wxASSERT_MSG( pSubMenu->m_hMenu != NULL , "invalid submenu added");
181 pSubMenu->m_menuParent = this ;
182 wxMenuItem::MacBuildMenuString( label , NULL , NULL , pItem->GetText() ,false);
183
184 if (wxMenuBar::MacGetInstalledMenuBar() == m_menuBar)
185 {
186 ::InsertMenu( MAC_WXHMENU( pSubMenu->m_hMenu ) , -1 ) ;
187 }
188
189 if ( pos == (size_t)-1 )
190 {
191 UMAAppendSubMenuItem(MAC_WXHMENU(m_hMenu), label, pSubMenu->m_macMenuId);
192 }
193 else
194 {
195 UMAInsertSubMenuItem(MAC_WXHMENU(m_hMenu), label , pos, pSubMenu->m_macMenuId);
196 }
197 }
198 else
199 {
200 Str255 label ;
201 UInt8 modifiers ;
202 SInt16 key ;
203 wxMenuItem::MacBuildMenuString( label, &key , &modifiers , pItem->GetText(), pItem->GetId() == wxApp::s_macAboutMenuItemId);
204 if ( label[0] == 0 )
205 {
206 // we cannot add empty menus on mac
207 label[0] = 1 ;
208 label[1] = ' ' ;
209 }
210 if ( pos == (size_t)-1 )
211 {
212 UMAAppendMenuItem(MAC_WXHMENU(m_hMenu), label,key,modifiers);
213 }
214 else
215 {
216 UMAInsertMenuItem(MAC_WXHMENU(m_hMenu), label , pos,key,modifiers);
217 }
218 if ( pItem->GetId() == idMenuTitle )
219 {
220 if ( pos == (size_t)-1 )
221 {
222 UMADisableMenuItem(MAC_WXHMENU(m_hMenu) , CountMenuItems(MAC_WXHMENU(m_hMenu) ) ) ;
223 }
224 else
225 {
226 UMADisableMenuItem(MAC_WXHMENU(m_hMenu) , pos + 1 ) ;
227 }
228 }
229 }
230 }
231 // if we're already attached to the menubar, we must update it
232 if ( IsAttached() )
233 {
234 m_menuBar->Refresh();
235 }
236 return TRUE ;
237 }
238
239 bool wxMenu::DoAppend(wxMenuItem *item)
240 {
241 return wxMenuBase::DoAppend(item) && DoInsertOrAppend(item);
242 }
243
244 bool wxMenu::DoInsert(size_t pos, wxMenuItem *item)
245 {
246 return wxMenuBase::DoInsert(pos, item) && DoInsertOrAppend(item, pos);
247 }
248
249 wxMenuItem *wxMenu::DoRemove(wxMenuItem *item)
250 {
251 // we need to find the items position in the child list
252 size_t pos;
253 wxMenuItemList::Node *node = GetMenuItems().GetFirst();
254 for ( pos = 0; node; pos++ )
255 {
256 if ( node->GetData() == item )
257 break;
258
259 node = node->GetNext();
260 }
261
262 // DoRemove() (unlike Remove) can only be called for existing item!
263 wxCHECK_MSG( node, NULL, wxT("bug in wxMenu::Remove logic") );
264
265 #if wxUSE_ACCEL
266 // remove the corresponding accel from the accel table
267 int n = FindAccel(item->GetId());
268 if ( n != wxNOT_FOUND )
269 {
270 delete m_accels[n];
271
272 m_accels.RemoveAt(n);
273 }
274 //else: this item doesn't have an accel, nothing to do
275 #endif // wxUSE_ACCEL
276
277 ::DeleteMenuItem(MAC_WXHMENU(m_hMenu) , pos + 1);
278
279 if ( IsAttached() )
280 {
281 // otherwise, the chane won't be visible
282 m_menuBar->Refresh();
283 }
284
285 // and from internal data structures
286 return wxMenuBase::DoRemove(item);
287 }
288
289 // ---------------------------------------------------------------------------
290 // accelerator helpers
291 // ---------------------------------------------------------------------------
292
293 #if wxUSE_ACCEL
294
295 // create the wxAcceleratorEntries for our accels and put them into provided
296 // array - return the number of accels we have
297 size_t wxMenu::CopyAccels(wxAcceleratorEntry *accels) const
298 {
299 size_t count = GetAccelCount();
300 for ( size_t n = 0; n < count; n++ )
301 {
302 *accels++ = *m_accels[n];
303 }
304
305 return count;
306 }
307
308 #endif // wxUSE_ACCEL
309
310 void wxMenu::SetTitle(const wxString& label)
311 {
312 Str255 title ;
313 m_title = label ;
314 wxMenuItem::MacBuildMenuString( title, NULL , NULL , label , false );
315 UMASetMenuTitle(MAC_WXHMENU(m_hMenu) , title ) ;
316 }
317 bool wxMenu::ProcessCommand(wxCommandEvent & event)
318 {
319 bool processed = FALSE;
320
321 #if WXWIN_COMPATIBILITY
322 // Try a callback
323 if (m_callback)
324 {
325 (void)(*(m_callback))(*this, event);
326 processed = TRUE;
327 }
328 #endif WXWIN_COMPATIBILITY
329
330 // Try the menu's event handler
331 if ( !processed && GetEventHandler())
332 {
333 processed = GetEventHandler()->ProcessEvent(event);
334 }
335
336 // Try the window the menu was popped up from (and up through the
337 // hierarchy)
338 wxWindow *win = GetInvokingWindow();
339 if ( !processed && win )
340 processed = win->GetEventHandler()->ProcessEvent(event);
341
342 return processed;
343 }
344
345
346 // ---------------------------------------------------------------------------
347 // other
348 // ---------------------------------------------------------------------------
349
350 wxWindow *wxMenu::GetWindow() const
351 {
352 if ( m_invokingWindow != NULL )
353 return m_invokingWindow;
354 else if ( m_menuBar != NULL)
355 return (wxWindow *) m_menuBar->GetFrame();
356
357 return NULL;
358 }
359
360 // helper functions returning the mac menu position for a certain item, note that this is
361 // mac-wise 1 - based, i.e. the first item has index 1 whereas on MSWin it has pos 0
362
363 int wxMenu::MacGetIndexFromId( int id )
364 {
365 size_t pos;
366 wxMenuItemList::Node *node = GetMenuItems().GetFirst();
367 for ( pos = 0; node; pos++ )
368 {
369 if ( node->GetData()->GetId() == id )
370 break;
371
372 node = node->GetNext();
373 }
374
375 if (!node)
376 return 0;
377
378 return pos + 1 ;
379 }
380
381 int wxMenu::MacGetIndexFromItem( wxMenuItem *pItem )
382 {
383 size_t pos;
384 wxMenuItemList::Node *node = GetMenuItems().GetFirst();
385 for ( pos = 0; node; pos++ )
386 {
387 if ( node->GetData() == pItem )
388 break;
389
390 node = node->GetNext();
391 }
392
393 if (!node)
394 return 0;
395
396 return pos + 1 ;
397 }
398
399 void wxMenu::MacEnableMenu( bool bDoEnable )
400 {
401 if ( bDoEnable )
402 UMAEnableMenuItem(MAC_WXHMENU(m_hMenu) , 0 ) ;
403 else
404 UMADisableMenuItem(MAC_WXHMENU(m_hMenu) , 0 ) ;
405
406 ::DrawMenuBar() ;
407 }
408
409 bool wxMenu::MacMenuSelect( wxEvtHandler* handler, long when , int macMenuId, int macMenuItemNum )
410 {
411 int pos;
412 wxNode *node;
413
414 if ( m_macMenuId == macMenuId )
415 {
416 node = GetMenuItems().Nth(macMenuItemNum-1);
417 if (node)
418 {
419 wxMenuItem *pItem = (wxMenuItem*)node->Data();
420
421 if (pItem->IsCheckable())
422 pItem->Check(! pItem->IsChecked());
423
424 wxCommandEvent event(wxEVT_COMMAND_MENU_SELECTED, pItem->GetId());
425 event.m_timeStamp = when;
426 event.SetEventObject(handler);
427 event.SetInt( pItem->GetId() );
428 {
429 bool processed = false ;
430
431 #if WXWIN_COMPATIBILITY
432 // Try a callback
433 if (m_callback)
434 {
435 (void) (*(m_callback)) (*this, event);
436 processed = TRUE;
437 }
438 #endif
439 // Try the menu's event handler
440 if ( !processed && handler)
441 {
442 processed = handler->ProcessEvent(event);
443 }
444
445 // Try the window the menu was popped up from (and up
446 // through the hierarchy)
447 if ( !processed && GetInvokingWindow())
448 processed = GetInvokingWindow()->GetEventHandler()->ProcessEvent(event);
449 }
450 return true ;
451 }
452 }
453 else if ( macMenuId == kHMHelpMenuID )
454 {
455 int menuItem = firstUserHelpMenuItem-1 ;
456 for (pos = 0, node = GetMenuItems().First(); node; node = node->Next(), pos++)
457 {
458 wxMenuItem * pItem = (wxMenuItem *) node->Data() ;
459
460 wxMenu *pSubMenu = pItem->GetSubMenu() ;
461 if ( pSubMenu != NULL )
462 {
463 }
464 else
465 {
466 if ( pItem->GetId() != wxApp::s_macAboutMenuItemId )
467 ++menuItem ;
468
469 if ( menuItem == macMenuItemNum )
470 {
471 wxCommandEvent event(wxEVT_COMMAND_MENU_SELECTED, pItem->GetId());
472 event.m_timeStamp = when;
473 event.SetEventObject(handler);
474 event.SetInt( pItem->GetId() );
475 {
476 bool processed = false ;
477 #if WXWIN_COMPATIBILITY
478 // Try a callback
479 if (m_callback)
480 {
481 (void) (*(m_callback)) (*this, event);
482 processed = TRUE;
483 }
484 #endif
485 // Try the menu's event handler
486 if ( !processed && handler)
487 {
488 processed = handler->ProcessEvent(event);
489 }
490
491 // Try the window the menu was popped up from (and up
492 // through the hierarchy)
493 if ( !processed && GetInvokingWindow())
494 processed = GetInvokingWindow()->GetEventHandler()->ProcessEvent(event);
495 }
496 return true ;
497 }
498 }
499 }
500 }
501
502 for (pos = 0, node = GetMenuItems().First(); node; node = node->Next(), pos++)
503 {
504 wxMenuItem * pItem = (wxMenuItem *) node->Data() ;
505
506 wxMenu *pSubMenu = pItem->GetSubMenu() ;
507 if ( pSubMenu != NULL )
508 {
509 if ( pSubMenu->MacMenuSelect( handler , when , macMenuId , macMenuItemNum ) )
510 return true ;
511 }
512 }
513
514 return false ;
515 }
516
517 // Menu Bar
518
519 /*
520
521 Mac Implementation note :
522
523 The Mac has only one global menubar, so we attempt to install the currently
524 active menubar from a frame, we currently don't take into account mdi-frames
525 which would ask for menu-merging
526
527 Secondly there is no mac api for changing a menubar that is not the current
528 menubar, so we have to wait for preparing the actual menubar until the
529 wxMenubar is to be used
530
531 We can in subsequent versions use MacInstallMenuBar to provide some sort of
532 auto-merge for MDI in case this will be necessary
533
534 */
535
536 wxMenuBar* wxMenuBar::s_macInstalledMenuBar = NULL ;
537
538 void wxMenuBar::Init()
539 {
540 m_eventHandler = this;
541 m_menuBarFrame = NULL;
542 }
543
544 wxMenuBar::wxMenuBar()
545 {
546 Init();
547 }
548
549 wxMenuBar::wxMenuBar( long WXUNUSED(style) )
550 {
551 Init();
552 }
553
554
555 wxMenuBar::wxMenuBar(int count, wxMenu *menus[], const wxString titles[])
556 {
557 Init();
558
559 m_titles.Alloc(count);
560
561 for ( int i = 0; i < count; i++ )
562 {
563 m_menus.Append(menus[i]);
564 m_titles.Add(titles[i]);
565
566 menus[i]->Attach(this);
567 }
568 }
569
570 wxMenuBar::~wxMenuBar()
571 {
572 if (s_macInstalledMenuBar == this)
573 {
574 ::ClearMenuBar();
575 s_macInstalledMenuBar = NULL;
576 }
577
578 }
579
580 void wxMenuBar::Refresh()
581 {
582 wxCHECK_RET( IsAttached(), wxT("can't refresh unatteched menubar") );
583
584 DrawMenuBar();
585 }
586
587 #if wxUSE_ACCEL
588
589 void wxMenuBar::RebuildAccelTable()
590 {
591 // merge the accelerators of all menus into one accel table
592 size_t nAccelCount = 0;
593 size_t i, count = GetMenuCount();
594 for ( i = 0; i < count; i++ )
595 {
596 nAccelCount += m_menus[i]->GetAccelCount();
597 }
598
599 if ( nAccelCount )
600 {
601 wxAcceleratorEntry *accelEntries = new wxAcceleratorEntry[nAccelCount];
602
603 nAccelCount = 0;
604 for ( i = 0; i < count; i++ )
605 {
606 nAccelCount += m_menus[i]->CopyAccels(&accelEntries[nAccelCount]);
607 }
608
609 m_accelTable = wxAcceleratorTable(nAccelCount, accelEntries);
610
611 delete [] accelEntries;
612 }
613 }
614
615 #endif // wxUSE_ACCEL
616 #ifdef WXMAKINGDLL
617 extern short gCurrentResource ;
618 #endif
619 void wxMenuBar::MacInstallMenuBar()
620 {
621 if ( s_macInstalledMenuBar == this )
622 return ;
623
624 wxStAppResource resload ;
625
626 Handle menubar = ::GetNewMBar( kwxMacMenuBarResource ) ;
627 wxString message ;
628 wxCHECK_RET( menubar != NULL, "can't read MBAR resource" );
629 ::SetMenuBar( menubar ) ;
630 #if TARGET_API_MAC_CARBON
631 ::DisposeMenuBar( menubar ) ;
632 #else
633 ::DisposeHandle( menubar ) ;
634 #endif
635
636 MenuHandle menu = ::GetMenuHandle( kwxMacAppleMenuId ) ;
637 #if TARGET_API_MAC_OS8
638 if ( CountMenuItems( menu ) == 2 )
639 {
640 ::AppendResMenu(menu, 'DRVR');
641 }
642 #endif
643
644 for (int i = 0; i < m_menus.GetCount(); i++)
645 {
646 Str255 label;
647 wxNode *node;
648 wxMenuItem *item;
649 int pos ;
650 wxMenu* menu = m_menus[i] , *subMenu = NULL ;
651
652 if( m_titles[i] == "?" || m_titles[i] == "&?" || m_titles[i] == wxApp::s_macHelpMenuTitleName )
653 {
654 MenuHandle mh = NULL ;
655 if ( UMAGetHelpMenu( &mh , &firstUserHelpMenuItem) != noErr )
656 {
657 continue ;
658 }
659
660 for ( int i = CountMenuItems( mh ) ; i >= firstUserHelpMenuItem ; --i )
661 {
662 DeleteMenuItem( mh , i ) ;
663 }
664
665 for (pos = 0 , node = menu->GetMenuItems().First(); node; node = node->Next(), pos++)
666 {
667 item = (wxMenuItem *)node->Data();
668 subMenu = item->GetSubMenu() ;
669 if (subMenu)
670 {
671 // we don't support hierarchical menus in the help menu yet
672 }
673 else
674 {
675 if ( item->IsSeparator() )
676 {
677 if ( mh )
678 MacAppendMenu(mh, "\p-" );
679 }
680 else
681 {
682 Str255 label ;
683 UInt8 modifiers ;
684 SInt16 key ;
685 wxMenuItem::MacBuildMenuString( label, &key , &modifiers , item->GetText(), item->GetId() != wxApp::s_macAboutMenuItemId); // no shortcut in about menu
686 if ( label[0] == 0 )
687 {
688 // we cannot add empty menus on mac
689 label[0] = 1 ;
690 label[1] = ' ' ;
691 }
692 if ( item->GetId() == wxApp::s_macAboutMenuItemId )
693 {
694 ::SetMenuItemText( GetMenuHandle( kwxMacAppleMenuId ) , 1 , label );
695 UMAEnableMenuItem( GetMenuHandle( kwxMacAppleMenuId ) , 1 );
696 }
697 else
698 {
699 if ( mh )
700 UMAAppendMenuItem(mh, label , key , modifiers );
701 }
702 }
703 }
704 }
705 }
706 else
707 {
708 wxMenuItem::MacBuildMenuString( label, NULL , NULL , m_titles[i] , false );
709 UMASetMenuTitle( MAC_WXHMENU(menu->GetHMenu()) , label ) ;
710 wxArrayPtrVoid submenus ;
711
712 for (pos = 0, node = menu->GetMenuItems().First(); node; node = node->Next(), pos++)
713 {
714 item = (wxMenuItem *)node->Data();
715 subMenu = item->GetSubMenu() ;
716 if (subMenu)
717 {
718 submenus.Add(subMenu) ;
719 }
720 }
721 ::InsertMenu(MAC_WXHMENU(m_menus[i]->GetHMenu()), 0);
722 for ( int i = 0 ; i < submenus.GetCount() ; ++i )
723 {
724 wxMenu* submenu = (wxMenu*) submenus[i] ;
725 wxNode *subnode;
726 wxMenuItem *subitem;
727 int subpos ;
728 for ( subpos = 0 , subnode = submenu->GetMenuItems().First(); subnode; subnode = subnode->Next(), subpos++)
729 {
730 subitem = (wxMenuItem *)subnode->Data();
731 wxMenu* itsSubMenu = subitem->GetSubMenu() ;
732 if (itsSubMenu)
733 {
734 submenus.Add(itsSubMenu) ;
735 }
736 }
737 ::InsertMenu( MAC_WXHMENU(submenu->GetHMenu()) , -1 ) ;
738 }
739 }
740 }
741 ::DrawMenuBar() ;
742 s_macInstalledMenuBar = this;
743 }
744
745 void wxMenuBar::EnableTop(size_t pos, bool enable)
746 {
747 wxCHECK_RET( IsAttached(), wxT("doesn't work with unattached menubars") );
748 m_menus[pos]->MacEnableMenu( enable ) ;
749 Refresh();
750 }
751
752 void wxMenuBar::SetLabelTop(size_t pos, const wxString& label)
753 {
754 wxCHECK_RET( pos < GetMenuCount(), wxT("invalid menu index") );
755
756 m_titles[pos] = label;
757
758 if ( !IsAttached() )
759 {
760 return;
761 }
762
763 m_menus[pos]->SetTitle( label ) ;
764 if (wxMenuBar::s_macInstalledMenuBar == this) // are we currently installed ?
765 {
766 ::SetMenuBar( GetMenuBar() ) ;
767 ::InvalMenuBar() ;
768 }
769 }
770
771 wxString wxMenuBar::GetLabelTop(size_t pos) const
772 {
773 wxCHECK_MSG( pos < GetMenuCount(), wxEmptyString,
774 wxT("invalid menu index in wxMenuBar::GetLabelTop") );
775
776 return m_titles[pos];
777 }
778
779 int wxMenuBar::FindMenu(const wxString& title)
780 {
781 wxString menuTitle = wxStripMenuCodes(title);
782
783 size_t count = GetMenuCount();
784 for ( size_t i = 0; i < count; i++ )
785 {
786 wxString title = wxStripMenuCodes(m_titles[i]);
787 if ( menuTitle == title )
788 return i;
789 }
790
791 return wxNOT_FOUND;
792
793 }
794
795
796 // ---------------------------------------------------------------------------
797 // wxMenuBar construction
798 // ---------------------------------------------------------------------------
799
800 // ---------------------------------------------------------------------------
801 // wxMenuBar construction
802 // ---------------------------------------------------------------------------
803
804 wxMenu *wxMenuBar::Replace(size_t pos, wxMenu *menu, const wxString& title)
805 {
806 wxMenu *menuOld = wxMenuBarBase::Replace(pos, menu, title);
807 if ( !menuOld )
808 return FALSE;
809 m_titles[pos] = title;
810
811 if ( IsAttached() )
812 {
813 if (s_macInstalledMenuBar == this)
814 {
815 ::DeleteMenu( menuOld->MacGetMenuId() /* m_menus[pos]->MacGetMenuId() */ ) ;
816 {
817 Str255 label;
818 wxMenuItem::MacBuildMenuString( label, NULL , NULL , title , false );
819 UMASetMenuTitle( MAC_WXHMENU(menu->GetHMenu()) , label ) ;
820 if ( pos == m_menus.GetCount() - 1)
821 {
822 ::InsertMenu( MAC_WXHMENU(menu->GetHMenu()) , 0 ) ;
823 }
824 else
825 {
826 ::InsertMenu( MAC_WXHMENU(menu->GetHMenu()) , m_menus[pos+1]->MacGetMenuId() ) ;
827 }
828 }
829 }
830
831
832 #if wxUSE_ACCEL
833 if ( menuOld->HasAccels() || menu->HasAccels() )
834 {
835 // need to rebuild accell table
836 RebuildAccelTable();
837 }
838 #endif // wxUSE_ACCEL
839
840 Refresh();
841 }
842
843 return menuOld;
844 }
845
846 bool wxMenuBar::Insert(size_t pos, wxMenu *menu, const wxString& title)
847 {
848 if ( !wxMenuBarBase::Insert(pos, menu, title) )
849 return FALSE;
850
851 m_titles.Insert(title, pos);
852
853 Str255 label ;
854 wxMenuItem::MacBuildMenuString( label, NULL , NULL , title , false );
855 UMASetMenuTitle( MAC_WXHMENU(menu->GetHMenu()) , label ) ;
856
857 if ( IsAttached() )
858 {
859 if ( pos == (size_t) -1 || pos + 1 == m_menus.GetCount() )
860 {
861 ::InsertMenu( MAC_WXHMENU(menu->GetHMenu()) , 0 ) ;
862 }
863 else
864 {
865 ::InsertMenu( MAC_WXHMENU(menu->GetHMenu()) , m_menus[pos+1]->MacGetMenuId() ) ;
866 }
867
868 #if wxUSE_ACCEL
869 if ( menu->HasAccels() )
870 {
871 // need to rebuild accell table
872 RebuildAccelTable();
873 }
874 #endif // wxUSE_ACCEL
875
876 Refresh();
877 }
878
879 return TRUE;
880 }
881
882 void wxMenuBar::MacMenuSelect(wxEvtHandler* handler, long when , int macMenuId, int macMenuItemNum)
883 {
884 // first scan fast for direct commands, i.e. menus which have these commands directly in their own list
885
886 if ( macMenuId == kwxMacAppleMenuId && macMenuItemNum == 1 )
887 {
888 wxCommandEvent event(wxEVT_COMMAND_MENU_SELECTED, wxApp::s_macAboutMenuItemId );
889 event.m_timeStamp = when;
890 event.SetEventObject(handler);
891 event.SetInt( wxApp::s_macAboutMenuItemId );
892 handler->ProcessEvent(event);
893 }
894 else
895 {
896 for (int i = 0; i < m_menus.GetCount() ; i++)
897 {
898 if ( m_menus[i]->MacGetMenuId() == macMenuId || ( macMenuId == kHMHelpMenuID && ( m_titles[i] == "?" || m_titles[i] == "&?" || m_titles[i] == wxApp::s_macHelpMenuTitleName ) ) )
899 {
900 if ( m_menus[i]->MacMenuSelect( handler , when , macMenuId , macMenuItemNum ) )
901 return ;
902 else
903 {
904 //TODO flag this as an error since it must contain the item
905 return ;
906 }
907 }
908 }
909
910 for (int i = 0; i < m_menus.GetCount(); i++)
911 {
912 if ( m_menus[i]->MacMenuSelect( handler , when , macMenuId , macMenuItemNum ) )
913 {
914 break ;
915 }
916 }
917 }
918 }
919
920 wxMenu *wxMenuBar::Remove(size_t pos)
921 {
922 wxMenu *menu = wxMenuBarBase::Remove(pos);
923 if ( !menu )
924 return NULL;
925
926 if ( IsAttached() )
927 {
928 if (s_macInstalledMenuBar == this)
929 {
930 ::DeleteMenu( menu->MacGetMenuId() /* m_menus[pos]->MacGetMenuId() */ ) ;
931 }
932
933 menu->Detach();
934
935 #if wxUSE_ACCEL
936 if ( menu->HasAccels() )
937 {
938 // need to rebuild accell table
939 RebuildAccelTable();
940 }
941 #endif // wxUSE_ACCEL
942
943 Refresh();
944 }
945
946 m_titles.Remove(pos);
947
948 return menu;
949 }
950
951 bool wxMenuBar::Append(wxMenu *menu, const wxString& title)
952 {
953 WXHMENU submenu = menu ? menu->GetHMenu() : 0;
954 wxCHECK_MSG( submenu, FALSE, wxT("can't append invalid menu to menubar") );
955
956 if ( !wxMenuBarBase::Append(menu, title) )
957 return FALSE;
958
959 m_titles.Add(title);
960
961 Str255 label ;
962 wxMenuItem::MacBuildMenuString( label, NULL , NULL , title , false );
963 UMASetMenuTitle( MAC_WXHMENU(menu->GetHMenu()) , label ) ;
964
965 if ( IsAttached() )
966 {
967 if (s_macInstalledMenuBar == this)
968 {
969 ::InsertMenu( MAC_WXHMENU(menu->GetHMenu()) , 0 ) ;
970 }
971
972 #if wxUSE_ACCEL
973 if ( menu->HasAccels() )
974 {
975 // need to rebuild accell table
976 RebuildAccelTable();
977 }
978 #endif // wxUSE_ACCEL
979
980 Refresh();
981 }
982
983 return TRUE;
984 }
985
986 void wxMenuBar::Detach()
987 {
988 wxMenuBarBase::Detach() ;
989 }
990
991 void wxMenuBar::Attach(wxFrame *frame)
992 {
993 wxMenuBarBase::Attach( frame ) ;
994
995 #if wxUSE_ACCEL
996 RebuildAccelTable();
997 #endif // wxUSE_ACCEL
998 }
999 // ---------------------------------------------------------------------------
1000 // wxMenuBar searching for menu items
1001 // ---------------------------------------------------------------------------
1002
1003 // Find the itemString in menuString, and return the item id or wxNOT_FOUND
1004 int wxMenuBar::FindMenuItem(const wxString& menuString,
1005 const wxString& itemString) const
1006 {
1007 wxString menuLabel = wxStripMenuCodes(menuString);
1008 size_t count = GetMenuCount();
1009 for ( size_t i = 0; i < count; i++ )
1010 {
1011 wxString title = wxStripMenuCodes(m_titles[i]);
1012 if ( menuString == title )
1013 return m_menus[i]->FindItem(itemString);
1014 }
1015
1016 return wxNOT_FOUND;
1017 }
1018
1019 wxMenuItem *wxMenuBar::FindItem(int id, wxMenu **itemMenu) const
1020 {
1021 if ( itemMenu )
1022 *itemMenu = NULL;
1023
1024 wxMenuItem *item = NULL;
1025 size_t count = GetMenuCount();
1026 for ( size_t i = 0; !item && (i < count); i++ )
1027 {
1028 item = m_menus[i]->FindItem(id, itemMenu);
1029 }
1030
1031 return item;
1032 }
1033
1034