src/osx/carbon/menu.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/osx/carbon/menu.cpp
// Purpose:     wxMenu, wxMenuBar, wxMenuItem
// Author:      Stefan Csomor
// Modified by:
// Created:     1998-01-01
// RCS-ID:      $Id$
// Copyright:   (c) Stefan Csomor
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// ============================================================================
// headers & declarations
// ============================================================================

// wxWidgets headers
// -----------------

#include "wx/wxprec.h"

#include "wx/menu.h"

#ifndef WX_PRECOMP
    #include "wx/log.h"
    #include "wx/app.h"
    #include "wx/utils.h"
    #include "wx/frame.h"
    #include "wx/menuitem.h"
#endif

#include "wx/osx/private.h"
#include "wx/stockitem.h"

// other standard headers
// ----------------------
#include <string.h>

// under carbon there's no such thing as a MenuItemRef, everything is done
// on the 'parent' menu via index APIs (first line having index 1 !)
// so to make things still work, we store the wxMenuItemImpl instance as a
// RefCon at the respective menu line

class wxMenuItemCarbonImpl : public wxMenuItemImpl
{
public :
    wxMenuItemCarbonImpl( wxMenuItem* peer ) : wxMenuItemImpl(peer)
    {
        // the parent menu ref is only set, once the item has been attached
        m_parentMenuRef = NULL;
    }

    ~wxMenuItemCarbonImpl();

    void SetBitmap( const wxBitmap& bitmap )
    {
        MenuItemIndex i = FindMenuItemIndex() ;
        if ( i > 0 )
        {
            if ( bitmap.IsOk() )
            {
#if wxUSE_BMPBUTTON
                ControlButtonContentInfo info ;
                wxMacCreateBitmapButton( &info , bitmap ) ;
                if ( info.contentType != kControlNoContent )
                {
                    if ( info.contentType == kControlContentIconRef )
                        SetMenuItemIconHandle( m_parentMenuRef, i ,
                            kMenuIconRefType , (Handle) info.u.iconRef ) ;
                    else if ( info.contentType == kControlContentCGImageRef )
                       SetMenuItemIconHandle( m_parentMenuRef, i ,
                            kMenuCGImageRefType , (Handle) info.u.imageRef ) ;
                }
                wxMacReleaseBitmapButton( &info ) ;
#endif
            }
        }
    }

    void Enable( bool enable )
    {
        MenuItemIndex i = FindMenuItemIndex() ;
        if ( i > 0 )
        {

            if ( GetWXPeer()->GetId() == wxApp::s_macPreferencesMenuItemId)
            {
                if ( enable )
                    EnableMenuCommand( NULL , kHICommandPreferences ) ;
                else
                    DisableMenuCommand( NULL , kHICommandPreferences ) ;
            }
            else if ( GetWXPeer()->GetId() == wxApp::s_macExitMenuItemId)
            {
                if ( enable )
                    EnableMenuCommand( NULL , kHICommandQuit ) ;
                else
                    DisableMenuCommand( NULL , kHICommandQuit ) ;
            }

            if ( enable )
                EnableMenuItem(m_parentMenuRef , i);
            else
                DisableMenuItem(m_parentMenuRef , i);

            if ( GetWXPeer()->IsSubMenu() )
            {
                UMAEnableMenuItem( GetWXPeer()->GetSubMenu()->GetHMenu() , 0 , enable ) ;
            }
        }
    }

    void Check( bool check )
    {
        MenuItemIndex i = FindMenuItemIndex() ;
        if ( i > 0 )
        {
            if ( check )
                ::SetItemMark( m_parentMenuRef, i, 0x12 ) ; // checkmark
            else
                ::SetItemMark( m_parentMenuRef, i, 0 ) ; // no mark
        }
    }

    void Hide( bool hide )
    {
        MenuItemIndex i = FindMenuItemIndex() ;
        if ( i > 0 )
        {
            if ( hide )
                ChangeMenuItemAttributes( m_parentMenuRef, i, kMenuItemAttrHidden, 0 );
            else
                ChangeMenuItemAttributes( m_parentMenuRef, i, 0 , kMenuItemAttrHidden );
        }
    }

    void SetLabel( const wxString& text, wxAcceleratorEntry *entry )
    {
        MenuItemIndex i = FindMenuItemIndex() ;
        if ( i > 0 )
        {
            SetMenuItemTextWithCFString( m_parentMenuRef, i, wxCFStringRef(text));
            UMASetMenuItemShortcut( m_parentMenuRef, i , entry ) ;
         }
    }

    void * GetHMenuItem() { return NULL; }

    // Carbon Only

    void AttachToParent( MenuRef parentMenuRef, MenuItemIndex index )
    {
        m_parentMenuRef = parentMenuRef;
        if ( m_parentMenuRef && index > 0 )
            SetMenuItemRefCon( m_parentMenuRef, index, (URefCon) m_peer );
    }

    MenuItemIndex FindMenuItemIndex()
    {
        MenuItemIndex hit = 0 ;
        if ( m_parentMenuRef )
        {
            for ( MenuItemIndex i = 1 ; i <= CountMenuItems(m_parentMenuRef) ; ++i )
            {
                URefCon storedRef = 0;
                GetMenuItemRefCon(m_parentMenuRef, i, &storedRef );
                if ( storedRef == (URefCon) m_peer )
                {
                    hit = i;
                    break;
                }
            }
        }
        return hit;
    }
protected :
    MenuRef m_parentMenuRef;
} ;

//
// wxMenuImpl
//

class wxMenuCarbonImpl : public wxMenuImpl
{
public :
    wxMenuCarbonImpl( wxMenu* peer , MenuRef menu , MenuRef oldMenu , SInt16 menuId)
        : wxMenuImpl(peer), m_osxMenu(menu), m_oldMenuRef(oldMenu), m_menuId(menuId)
    {
    }

    virtual ~wxMenuCarbonImpl();

    virtual void InsertOrAppend(wxMenuItem *pItem, size_t pos)
    {
        // MacOS counts menu items from 1 and inserts after, therefore having the
        // same effect as wx 0 based and inserting before, we must correct pos
        // after however for updates to be correct

        MenuItemIndex index = pos;
        if ( pos == (size_t) -1 )
            index = CountMenuItems(m_osxMenu);

        if ( pItem->IsSeparator() )
        {
            InsertMenuItemTextWithCFString( m_osxMenu, CFSTR(""), index, kMenuItemAttrSeparator, 0);
            // now switch to the Carbon 1 based counting
            index += 1 ;
        }
        else
        {
            InsertMenuItemTextWithCFString( m_osxMenu, CFSTR("placeholder"), index, 0, 0 );

            // now switch to the Carbon 1 based counting
            index += 1 ;
            if ( pItem->IsSubMenu() )
            {
                MenuRef submenu = pItem->GetSubMenu()->GetHMenu();
                SetMenuItemHierarchicalMenu(m_osxMenu, index, submenu);
                // carbon is using the title of the submenu, eg in the menubar
                SetMenuTitleWithCFString(submenu, wxCFStringRef(pItem->GetItemLabelText()));
            }
            else
            {
                SetMenuItemCommandID( m_osxMenu, index , wxIdToMacCommand(pItem->GetId()) ) ;
            }
        }

        wxMenuItemCarbonImpl* impl = (wxMenuItemCarbonImpl*) pItem->GetPeer();
        impl->AttachToParent( m_osxMenu, index );
        // only now can all settings be updated correctly
        pItem->UpdateItemText();
        pItem->UpdateItemStatus();
        pItem->UpdateItemBitmap();
    }

    virtual void Remove( wxMenuItem *pItem )
    {
        wxMenuItemCarbonImpl* impl = (wxMenuItemCarbonImpl*) pItem->GetPeer();
        if ( impl )
        {
            MenuItemIndex i = impl->FindMenuItemIndex();
            if ( i > 0 )
            {
                DeleteMenuItem(m_osxMenu , i);
                impl->AttachToParent( NULL, 0 );
            }
        }
    }

    virtual void MakeRoot()
    {
        SetRootMenu( m_osxMenu );
    }

    virtual void SetTitle( const wxString& text )
    {
        SetMenuTitleWithCFString(m_osxMenu, wxCFStringRef(text));
    }

    WXHMENU GetHMenu() { return m_osxMenu; }

    virtual void PopUp( wxWindow *WXUNUSED(win), int x, int y )
    {
        long menuResult = ::PopUpMenuSelect(m_osxMenu, y, x, 0) ;
        if ( HiWord(menuResult) != 0 )
        {
            MenuCommand macid;
            GetMenuItemCommandID( GetMenuHandle(HiWord(menuResult)) , LoWord(menuResult) , &macid );
            int id = wxMacCommandToId( macid );
            wxMenuItem* item = NULL ;
            wxMenu* realmenu ;
            item = m_peer->FindItem( id, &realmenu ) ;
            if ( item )
            {
                m_peer->HandleCommandProcess(item, NULL );
            }
        }
    }

    static wxMenuImpl* Create( wxMenu* peer, const wxString& title );
    static wxMenuImpl* CreateRootMenu( wxMenu* peer );
protected :
    wxCFRef<MenuRef> m_osxMenu;
    MenuRef m_oldMenuRef;
    SInt16 m_menuId;
} ;

// static const short kwxMacAppleMenuId = 1 ;

// Find an item given the Macintosh Menu Reference

WX_DECLARE_HASH_MAP(WXHMENU, wxMenu*, wxPointerHash, wxPointerEqual, MacMenuMap);

static MacMenuMap wxWinMacMenuList;

wxMenu *wxFindMenuFromMacMenu(WXHMENU inMenuRef)
{
    MacMenuMap::iterator node = wxWinMacMenuList.find(inMenuRef);

    return (node == wxWinMacMenuList.end()) ? NULL : node->second;
}

void wxAssociateMenuWithMacMenu(WXHMENU inMenuRef, wxMenu *menu) ;
void wxAssociateMenuWithMacMenu(WXHMENU inMenuRef, wxMenu *menu)
{
    // adding NULL MenuRef is (first) surely a result of an error and
    // (secondly) breaks menu command processing
    wxCHECK_RET( inMenuRef != (WXHMENU) NULL, wxT("attempt to add a NULL MenuRef to menu list") );

    wxWinMacMenuList[inMenuRef] = menu;
}

void wxRemoveMacMenuAssociation(wxMenu *menu) ;
void wxRemoveMacMenuAssociation(wxMenu *menu)
{
   // iterate over all the elements in the class
    MacMenuMap::iterator it;
    for ( it = wxWinMacMenuList.begin(); it != wxWinMacMenuList.end(); ++it )
    {
        if ( it->second == menu )
        {
            wxWinMacMenuList.erase(it);
            break;
        }
    }
}

wxMenuCarbonImpl::~wxMenuCarbonImpl()
{
    wxRemoveMacMenuAssociation( GetWXPeer() );
    // restore previous menu
    m_osxMenu.reset();
    if ( m_menuId > 0 )
        MacDeleteMenu(m_menuId);
    if ( m_oldMenuRef )
        MacInsertMenu(m_oldMenuRef, -1);
}

wxMenuImpl* wxMenuImpl::Create( wxMenu* peer, const wxString& title )
{
    // create the menu
    static SInt16 s_macNextMenuId = 3;
    SInt16 menuId = s_macNextMenuId++;
    // save existing menu in case we're embedding into an application
    // or sharing outside UI elements.
    WXHMENU oldMenu = GetMenuHandle(menuId);
    if ( oldMenu )
        MacDeleteMenu(menuId);
    WXHMENU menu = NULL;
    CreateNewMenu( menuId , 0 , &menu ) ;
    if ( !menu )
    {
        wxLogLastError(wxT("CreateNewMenu failed"));
        if ( oldMenu )
            MacInsertMenu(oldMenu, -1);
        return NULL;
    }

    wxMenuImpl* c = new wxMenuCarbonImpl( peer, menu, oldMenu, menuId );
    c->SetTitle(title);
    wxAssociateMenuWithMacMenu( menu , peer ) ;
    return c;
}

//
//
//

wxMenuItemCarbonImpl::~wxMenuItemCarbonImpl()
{
}


wxMenuItemImpl* wxMenuItemImpl::Create( wxMenuItem* peer,
                        wxMenu * WXUNUSED(pParentMenu),
                       int WXUNUSED(id),
                       const wxString& WXUNUSED(text),
                       wxAcceleratorEntry *WXUNUSED(entry),
                       const wxString& WXUNUSED(strHelp),
                       wxItemKind WXUNUSED(kind),
                       wxMenu *WXUNUSED(pSubMenu) )
{
    wxMenuItemImpl* c = NULL;

    c = new wxMenuItemCarbonImpl( peer );
    return c;
}

void wxInsertMenuItemsInMenu(wxMenu* menu, MenuRef wm, MenuItemIndex insertAfter)
{
    wxMenuItemList::compatibility_iterator node;
    wxMenuItem *item;
    wxMenu *subMenu = NULL ;
    bool newItems = false;

    for (node = menu->GetMenuItems().GetFirst(); node; node = node->GetNext())
    {
        item = (wxMenuItem *)node->GetData();
        subMenu = item->GetSubMenu() ;
        if (subMenu)
        {
            wxInsertMenuItemsInMenu(subMenu, (MenuRef)subMenu->GetHMenu(), 0);
        }
        if ( item->IsSeparator() )
        {
            if ( wm && newItems)
                InsertMenuItemTextWithCFString( wm,
                    CFSTR(""), insertAfter, kMenuItemAttrSeparator, 0);

            newItems = false;
        }
        else
        {
            wxAcceleratorEntry*
                entry = wxAcceleratorEntry::Create( item->GetItemLabel() ) ;

            MenuItemIndex winListPos = (MenuItemIndex)-1;
            OSStatus err = GetIndMenuItemWithCommandID(wm,
                        wxIdToMacCommand ( item->GetId() ), 1, NULL, &winListPos);

            if ( wm && err == menuItemNotFoundErr )
            {
                // NB: the only way to determine whether or not we should add
                // a separator is to know if we've added menu items to the menu
                // before the separator.
                newItems = true;
                UMAInsertMenuItem(wm, wxStripMenuCodes(item->GetItemLabel()) , wxFont::GetDefaultEncoding(), insertAfter, entry);
                SetMenuItemCommandID( wm , insertAfter+1 , wxIdToMacCommand ( item->GetId() ) ) ;
                SetMenuItemRefCon( wm , insertAfter+1 , (URefCon) item ) ;
            }

            delete entry ;
        }
    }
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/osx/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/osx/private.h"
	32	#include "wx/stockitem.h"
	33
	34	// other standard headers
	35	// ----------------------
	36	#include <string.h>
	37
	38	// under carbon there's no such thing as a MenuItemRef, everything is done
	39	// on the 'parent' menu via index APIs (first line having index 1 !)
	40	// so to make things still work, we store the wxMenuItemImpl instance as a
	41	// RefCon at the respective menu line
	42
	43	class wxMenuItemCarbonImpl : public wxMenuItemImpl
	44	{
	45	public :
	46	wxMenuItemCarbonImpl( wxMenuItem* peer ) : wxMenuItemImpl(peer)
	47	{
	48	// the parent menu ref is only set, once the item has been attached
	49	m_parentMenuRef = NULL;
	50	}
	51
	52	~wxMenuItemCarbonImpl();
	53
	54	void SetBitmap( const wxBitmap& bitmap )
	55	{
	56	MenuItemIndex i = FindMenuItemIndex() ;
	57	if ( i > 0 )
	58	{
	59	if ( bitmap.IsOk() )
	60	{
	61	#if wxUSE_BMPBUTTON
	62	ControlButtonContentInfo info ;
	63	wxMacCreateBitmapButton( &info , bitmap ) ;
	64	if ( info.contentType != kControlNoContent )
	65	{
	66	if ( info.contentType == kControlContentIconRef )
	67	SetMenuItemIconHandle( m_parentMenuRef, i ,
	68	kMenuIconRefType , (Handle) info.u.iconRef ) ;
	69	else if ( info.contentType == kControlContentCGImageRef )
	70	SetMenuItemIconHandle( m_parentMenuRef, i ,
	71	kMenuCGImageRefType , (Handle) info.u.imageRef ) ;
	72	}
	73	wxMacReleaseBitmapButton( &info ) ;
	74	#endif
	75	}
	76	}
	77	}
	78
	79	void Enable( bool enable )
	80	{
	81	MenuItemIndex i = FindMenuItemIndex() ;
	82	if ( i > 0 )
	83	{
	84
	85	if ( GetWXPeer()->GetId() == wxApp::s_macPreferencesMenuItemId)
	86	{
	87	if ( enable )
	88	EnableMenuCommand( NULL , kHICommandPreferences ) ;
	89	else
	90	DisableMenuCommand( NULL , kHICommandPreferences ) ;
	91	}
	92	else if ( GetWXPeer()->GetId() == wxApp::s_macExitMenuItemId)
	93	{
	94	if ( enable )
	95	EnableMenuCommand( NULL , kHICommandQuit ) ;
	96	else
	97	DisableMenuCommand( NULL , kHICommandQuit ) ;
	98	}
	99
	100	if ( enable )
	101	EnableMenuItem(m_parentMenuRef , i);
	102	else
	103	DisableMenuItem(m_parentMenuRef , i);
	104
	105	if ( GetWXPeer()->IsSubMenu() )
	106	{
	107	UMAEnableMenuItem( GetWXPeer()->GetSubMenu()->GetHMenu() , 0 , enable ) ;
	108	}
	109	}
	110	}
	111
	112	void Check( bool check )
	113	{
	114	MenuItemIndex i = FindMenuItemIndex() ;
	115	if ( i > 0 )
	116	{
	117	if ( check )
	118	::SetItemMark( m_parentMenuRef, i, 0x12 ) ; // checkmark
	119	else
	120	::SetItemMark( m_parentMenuRef, i, 0 ) ; // no mark
	121	}
	122	}
	123
	124	void Hide( bool hide )
	125	{
	126	MenuItemIndex i = FindMenuItemIndex() ;
	127	if ( i > 0 )
	128	{
	129	if ( hide )
	130	ChangeMenuItemAttributes( m_parentMenuRef, i, kMenuItemAttrHidden, 0 );
	131	else
	132	ChangeMenuItemAttributes( m_parentMenuRef, i, 0 , kMenuItemAttrHidden );
	133	}
	134	}
	135
	136	void SetLabel( const wxString& text, wxAcceleratorEntry *entry )
	137	{
	138	MenuItemIndex i = FindMenuItemIndex() ;
	139	if ( i > 0 )
	140	{
	141	SetMenuItemTextWithCFString( m_parentMenuRef, i, wxCFStringRef(text));
	142	UMASetMenuItemShortcut( m_parentMenuRef, i , entry ) ;
	143	}
	144	}
	145
	146	void * GetHMenuItem() { return NULL; }
	147
	148	// Carbon Only
	149
	150	void AttachToParent( MenuRef parentMenuRef, MenuItemIndex index )
	151	{
	152	m_parentMenuRef = parentMenuRef;
	153	if ( m_parentMenuRef && index > 0 )
	154	SetMenuItemRefCon( m_parentMenuRef, index, (URefCon) m_peer );
	155	}
	156
	157	MenuItemIndex FindMenuItemIndex()
	158	{
	159	MenuItemIndex hit = 0 ;
	160	if ( m_parentMenuRef )
	161	{
	162	for ( MenuItemIndex i = 1 ; i <= CountMenuItems(m_parentMenuRef) ; ++i )
	163	{
	164	URefCon storedRef = 0;
	165	GetMenuItemRefCon(m_parentMenuRef, i, &storedRef );
	166	if ( storedRef == (URefCon) m_peer )
	167	{
	168	hit = i;
	169	break;
	170	}
	171	}
	172	}
	173	return hit;
	174	}
	175	protected :
	176	MenuRef m_parentMenuRef;
	177	} ;
	178
	179	//
	180	// wxMenuImpl
	181	//
	182
	183	class wxMenuCarbonImpl : public wxMenuImpl
	184	{
	185	public :
	186	wxMenuCarbonImpl( wxMenu* peer , MenuRef menu , MenuRef oldMenu , SInt16 menuId)
	187	: wxMenuImpl(peer), m_osxMenu(menu), m_oldMenuRef(oldMenu), m_menuId(menuId)
	188	{
	189	}
	190
	191	virtual ~wxMenuCarbonImpl();
	192
	193	virtual void InsertOrAppend(wxMenuItem *pItem, size_t pos)
	194	{
	195	// MacOS counts menu items from 1 and inserts after, therefore having the
	196	// same effect as wx 0 based and inserting before, we must correct pos
	197	// after however for updates to be correct
	198
	199	MenuItemIndex index = pos;
	200	if ( pos == (size_t) -1 )
	201	index = CountMenuItems(m_osxMenu);
	202
	203	if ( pItem->IsSeparator() )
	204	{
	205	InsertMenuItemTextWithCFString( m_osxMenu, CFSTR(""), index, kMenuItemAttrSeparator, 0);
	206	// now switch to the Carbon 1 based counting
	207	index += 1 ;
	208	}
	209	else
	210	{
	211	InsertMenuItemTextWithCFString( m_osxMenu, CFSTR("placeholder"), index, 0, 0 );
	212
	213	// now switch to the Carbon 1 based counting
	214	index += 1 ;
	215	if ( pItem->IsSubMenu() )
	216	{
	217	MenuRef submenu = pItem->GetSubMenu()->GetHMenu();
	218	SetMenuItemHierarchicalMenu(m_osxMenu, index, submenu);
	219	// carbon is using the title of the submenu, eg in the menubar
	220	SetMenuTitleWithCFString(submenu, wxCFStringRef(pItem->GetItemLabelText()));
	221	}
	222	else
	223	{
	224	SetMenuItemCommandID( m_osxMenu, index , wxIdToMacCommand(pItem->GetId()) ) ;
	225	}
	226	}
	227
	228	wxMenuItemCarbonImpl* impl = (wxMenuItemCarbonImpl*) pItem->GetPeer();
	229	impl->AttachToParent( m_osxMenu, index );
	230	// only now can all settings be updated correctly
	231	pItem->UpdateItemText();
	232	pItem->UpdateItemStatus();
	233	pItem->UpdateItemBitmap();
	234	}
	235
	236	virtual void Remove( wxMenuItem *pItem )
	237	{
	238	wxMenuItemCarbonImpl* impl = (wxMenuItemCarbonImpl*) pItem->GetPeer();
	239	if ( impl )
	240	{
	241	MenuItemIndex i = impl->FindMenuItemIndex();
	242	if ( i > 0 )
	243	{
	244	DeleteMenuItem(m_osxMenu , i);
	245	impl->AttachToParent( NULL, 0 );
	246	}
	247	}
	248	}
	249
	250	virtual void MakeRoot()
	251	{
	252	SetRootMenu( m_osxMenu );
	253	}
	254
	255	virtual void SetTitle( const wxString& text )
	256	{
	257	SetMenuTitleWithCFString(m_osxMenu, wxCFStringRef(text));
	258	}
	259
	260	WXHMENU GetHMenu() { return m_osxMenu; }
	261
	262	virtual void PopUp( wxWindow *WXUNUSED(win), int x, int y )
	263	{
	264	long menuResult = ::PopUpMenuSelect(m_osxMenu, y, x, 0) ;
	265	if ( HiWord(menuResult) != 0 )
	266	{
	267	MenuCommand macid;
	268	GetMenuItemCommandID( GetMenuHandle(HiWord(menuResult)) , LoWord(menuResult) , &macid );
	269	int id = wxMacCommandToId( macid );
	270	wxMenuItem* item = NULL ;
	271	wxMenu* realmenu ;
	272	item = m_peer->FindItem( id, &realmenu ) ;
	273	if ( item )
	274	{
	275	m_peer->HandleCommandProcess(item, NULL );
	276	}
	277	}
	278	}
	279
	280	static wxMenuImpl* Create( wxMenu* peer, const wxString& title );
	281	static wxMenuImpl* CreateRootMenu( wxMenu* peer );
	282	protected :
	283	wxCFRef<MenuRef> m_osxMenu;
	284	MenuRef m_oldMenuRef;
	285	SInt16 m_menuId;
	286	} ;
	287
	288	// static const short kwxMacAppleMenuId = 1 ;
	289
	290	// Find an item given the Macintosh Menu Reference
	291
	292	WX_DECLARE_HASH_MAP(WXHMENU, wxMenu*, wxPointerHash, wxPointerEqual, MacMenuMap);
	293
	294	static MacMenuMap wxWinMacMenuList;
	295
	296	wxMenu *wxFindMenuFromMacMenu(WXHMENU inMenuRef)
	297	{
	298	MacMenuMap::iterator node = wxWinMacMenuList.find(inMenuRef);
	299
	300	return (node == wxWinMacMenuList.end()) ? NULL : node->second;
	301	}
	302
	303	void wxAssociateMenuWithMacMenu(WXHMENU inMenuRef, wxMenu *menu) ;
	304	void wxAssociateMenuWithMacMenu(WXHMENU inMenuRef, wxMenu *menu)
	305	{
	306	// adding NULL MenuRef is (first) surely a result of an error and
	307	// (secondly) breaks menu command processing
	308	wxCHECK_RET( inMenuRef != (WXHMENU) NULL, wxT("attempt to add a NULL MenuRef to menu list") );
	309
	310	wxWinMacMenuList[inMenuRef] = menu;
	311	}
	312
	313	void wxRemoveMacMenuAssociation(wxMenu *menu) ;
	314	void wxRemoveMacMenuAssociation(wxMenu *menu)
	315	{
	316	// iterate over all the elements in the class
	317	MacMenuMap::iterator it;
	318	for ( it = wxWinMacMenuList.begin(); it != wxWinMacMenuList.end(); ++it )
	319	{
	320	if ( it->second == menu )
	321	{
	322	wxWinMacMenuList.erase(it);
	323	break;
	324	}
	325	}
	326	}
	327
	328	wxMenuCarbonImpl::~wxMenuCarbonImpl()
	329	{
	330	wxRemoveMacMenuAssociation( GetWXPeer() );
	331	// restore previous menu
	332	m_osxMenu.reset();
	333	if ( m_menuId > 0 )
	334	MacDeleteMenu(m_menuId);
	335	if ( m_oldMenuRef )
	336	MacInsertMenu(m_oldMenuRef, -1);
	337	}
	338
	339	wxMenuImpl* wxMenuImpl::Create( wxMenu* peer, const wxString& title )
	340	{
	341	// create the menu
	342	static SInt16 s_macNextMenuId = 3;
	343	SInt16 menuId = s_macNextMenuId++;
	344	// save existing menu in case we're embedding into an application
	345	// or sharing outside UI elements.
	346	WXHMENU oldMenu = GetMenuHandle(menuId);
	347	if ( oldMenu )
	348	MacDeleteMenu(menuId);
	349	WXHMENU menu = NULL;
	350	CreateNewMenu( menuId , 0 , &menu ) ;
	351	if ( !menu )
	352	{
	353	wxLogLastError(wxT("CreateNewMenu failed"));
	354	if ( oldMenu )
	355	MacInsertMenu(oldMenu, -1);
	356	return NULL;
	357	}
	358
	359	wxMenuImpl* c = new wxMenuCarbonImpl( peer, menu, oldMenu, menuId );
	360	c->SetTitle(title);
	361	wxAssociateMenuWithMacMenu( menu , peer ) ;
	362	return c;
	363	}
	364
	365	//
	366	//
	367	//
	368
	369	wxMenuItemCarbonImpl::~wxMenuItemCarbonImpl()
	370	{
	371	}
	372
	373
	374	wxMenuItemImpl* wxMenuItemImpl::Create( wxMenuItem* peer,
	375	wxMenu * WXUNUSED(pParentMenu),
	376	int WXUNUSED(id),
	377	const wxString& WXUNUSED(text),
	378	wxAcceleratorEntry *WXUNUSED(entry),
	379	const wxString& WXUNUSED(strHelp),
	380	wxItemKind WXUNUSED(kind),
	381	wxMenu *WXUNUSED(pSubMenu) )
	382	{
	383	wxMenuItemImpl* c = NULL;
	384
	385	c = new wxMenuItemCarbonImpl( peer );
	386	return c;
	387	}
	388
	389	void wxInsertMenuItemsInMenu(wxMenu* menu, MenuRef wm, MenuItemIndex insertAfter)
	390	{
	391	wxMenuItemList::compatibility_iterator node;
	392	wxMenuItem *item;
	393	wxMenu *subMenu = NULL ;
	394	bool newItems = false;
	395
	396	for (node = menu->GetMenuItems().GetFirst(); node; node = node->GetNext())
	397	{
	398	item = (wxMenuItem *)node->GetData();
	399	subMenu = item->GetSubMenu() ;
	400	if (subMenu)
	401	{
	402	wxInsertMenuItemsInMenu(subMenu, (MenuRef)subMenu->GetHMenu(), 0);
	403	}
	404	if ( item->IsSeparator() )
	405	{
	406	if ( wm && newItems)
	407	InsertMenuItemTextWithCFString( wm,
	408	CFSTR(""), insertAfter, kMenuItemAttrSeparator, 0);
	409
	410	newItems = false;
	411	}
	412	else
	413	{
	414	wxAcceleratorEntry*
	415	entry = wxAcceleratorEntry::Create( item->GetItemLabel() ) ;
	416
	417	MenuItemIndex winListPos = (MenuItemIndex)-1;
	418	OSStatus err = GetIndMenuItemWithCommandID(wm,
	419	wxIdToMacCommand ( item->GetId() ), 1, NULL, &winListPos);
	420
	421	if ( wm && err == menuItemNotFoundErr )
	422	{
	423	// NB: the only way to determine whether or not we should add
	424	// a separator is to know if we've added menu items to the menu
	425	// before the separator.
	426	newItems = true;
	427	UMAInsertMenuItem(wm, wxStripMenuCodes(item->GetItemLabel()) , wxFont::GetDefaultEncoding(), insertAfter, entry);
	428	SetMenuItemCommandID( wm , insertAfter+1 , wxIdToMacCommand ( item->GetId() ) ) ;
	429	SetMenuItemRefCon( wm , insertAfter+1 , (URefCon) item ) ;
	430	}
	431
	432	delete entry ;
	433	}
	434	}
	435	}
	436
	437