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