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