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.Ok() )
            {
#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) : wxMenuImpl(peer), m_osxMenu(menu)
    {
    }

    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;
} ;

// 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() );
}

wxMenuImpl* wxMenuImpl::Create( wxMenu* peer, const wxString& title )
{
    // create the menu
    static SInt16 s_macNextMenuId = 3;
    WXHMENU menu = NULL;
    CreateNewMenu( s_macNextMenuId++ , 0 , &menu ) ;
    if ( !menu )
    {
        wxLogLastError(wxT("CreateNewMenu failed"));
        return NULL;
    }

    wxMenuImpl* c = new wxMenuCarbonImpl( peer, menu );
    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.Ok() )
	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) : wxMenuImpl(peer), m_osxMenu(menu)
	187	{
	188	}
	189
	190	virtual ~wxMenuCarbonImpl();
	191
	192	virtual void InsertOrAppend(wxMenuItem *pItem, size_t pos)
	193	{
	194	// MacOS counts menu items from 1 and inserts after, therefore having the
	195	// same effect as wx 0 based and inserting before, we must correct pos
	196	// after however for updates to be correct
	197
	198	MenuItemIndex index = pos;
	199	if ( pos == (size_t) -1 )
	200	index = CountMenuItems(m_osxMenu);
	201
	202	if ( pItem->IsSeparator() )
	203	{
	204	InsertMenuItemTextWithCFString( m_osxMenu, CFSTR(""), index, kMenuItemAttrSeparator, 0);
	205	// now switch to the Carbon 1 based counting
	206	index += 1 ;
	207	}
	208	else
	209	{
	210	InsertMenuItemTextWithCFString( m_osxMenu, CFSTR("placeholder"), index, 0, 0 );
	211
	212	// now switch to the Carbon 1 based counting
	213	index += 1 ;
	214	if ( pItem->IsSubMenu() )
	215	{
	216	MenuRef submenu = pItem->GetSubMenu()->GetHMenu();
	217	SetMenuItemHierarchicalMenu(m_osxMenu, index, submenu);
	218	// carbon is using the title of the submenu, eg in the menubar
	219	SetMenuTitleWithCFString(submenu, wxCFStringRef(pItem->GetItemLabelText()));
	220	}
	221	else
	222	{
	223	SetMenuItemCommandID( m_osxMenu, index , wxIdToMacCommand(pItem->GetId()) ) ;
	224	}
	225	}
	226
	227	wxMenuItemCarbonImpl* impl = (wxMenuItemCarbonImpl*) pItem->GetPeer();
	228	impl->AttachToParent( m_osxMenu, index );
	229	// only now can all settings be updated correctly
	230	pItem->UpdateItemText();
	231	pItem->UpdateItemStatus();
	232	pItem->UpdateItemBitmap();
	233	}
	234
	235	virtual void Remove( wxMenuItem *pItem )
	236	{
	237	wxMenuItemCarbonImpl* impl = (wxMenuItemCarbonImpl*) pItem->GetPeer();
	238	if ( impl )
	239	{
	240	MenuItemIndex i = impl->FindMenuItemIndex();
	241	if ( i > 0 )
	242	{
	243	DeleteMenuItem(m_osxMenu , i);
	244	impl->AttachToParent( NULL, 0 );
	245	}
	246	}
	247	}
	248
	249	virtual void MakeRoot()
	250	{
	251	SetRootMenu( m_osxMenu );
	252	}
	253
	254	virtual void SetTitle( const wxString& text )
	255	{
	256	SetMenuTitleWithCFString(m_osxMenu, wxCFStringRef(text));
	257	}
	258
	259	WXHMENU GetHMenu() { return m_osxMenu; }
	260
	261	virtual void PopUp( wxWindow *WXUNUSED(win), int x, int y )
	262	{
	263	long menuResult = ::PopUpMenuSelect(m_osxMenu, y, x, 0) ;
	264	if ( HiWord(menuResult) != 0 )
	265	{
	266	MenuCommand macid;
	267	GetMenuItemCommandID( GetMenuHandle(HiWord(menuResult)) , LoWord(menuResult) , &macid );
	268	int id = wxMacCommandToId( macid );
	269	wxMenuItem* item = NULL ;
	270	wxMenu* realmenu ;
	271	item = m_peer->FindItem( id, &realmenu ) ;
	272	if ( item )
	273	{
	274	m_peer->HandleCommandProcess(item, NULL );
	275	}
	276	}
	277	}
	278
	279	static wxMenuImpl* Create( wxMenu* peer, const wxString& title );
	280	static wxMenuImpl* CreateRootMenu( wxMenu* peer );
	281	protected :
	282	wxCFRef<MenuRef> m_osxMenu;
	283	} ;
	284
	285	// static const short kwxMacAppleMenuId = 1 ;
	286
	287	// Find an item given the Macintosh Menu Reference
	288
	289	WX_DECLARE_HASH_MAP(WXHMENU, wxMenu*, wxPointerHash, wxPointerEqual, MacMenuMap);
	290
	291	static MacMenuMap wxWinMacMenuList;
	292
	293	wxMenu *wxFindMenuFromMacMenu(WXHMENU inMenuRef)
	294	{
	295	MacMenuMap::iterator node = wxWinMacMenuList.find(inMenuRef);
	296
	297	return (node == wxWinMacMenuList.end()) ? NULL : node->second;
	298	}
	299
	300	void wxAssociateMenuWithMacMenu(WXHMENU inMenuRef, wxMenu *menu) ;
	301	void wxAssociateMenuWithMacMenu(WXHMENU inMenuRef, wxMenu *menu)
	302	{
	303	// adding NULL MenuRef is (first) surely a result of an error and
	304	// (secondly) breaks menu command processing
	305	wxCHECK_RET( inMenuRef != (WXHMENU) NULL, wxT("attempt to add a NULL MenuRef to menu list") );
	306
	307	wxWinMacMenuList[inMenuRef] = menu;
	308	}
	309
	310	void wxRemoveMacMenuAssociation(wxMenu *menu) ;
	311	void wxRemoveMacMenuAssociation(wxMenu *menu)
	312	{
	313	// iterate over all the elements in the class
	314	MacMenuMap::iterator it;
	315	for ( it = wxWinMacMenuList.begin(); it != wxWinMacMenuList.end(); ++it )
	316	{
	317	if ( it->second == menu )
	318	{
	319	wxWinMacMenuList.erase(it);
	320	break;
	321	}
	322	}
	323	}
	324
	325	wxMenuCarbonImpl::~wxMenuCarbonImpl()
	326	{
	327	wxRemoveMacMenuAssociation( GetWXPeer() );
	328	}
	329
	330	wxMenuImpl* wxMenuImpl::Create( wxMenu* peer, const wxString& title )
	331	{
	332	// create the menu
	333	static SInt16 s_macNextMenuId = 3;
	334	WXHMENU menu = NULL;
	335	CreateNewMenu( s_macNextMenuId++ , 0 , &menu ) ;
	336	if ( !menu )
	337	{
	338	wxLogLastError(wxT("CreateNewMenu failed"));
	339	return NULL;
	340	}
	341
	342	wxMenuImpl* c = new wxMenuCarbonImpl( peer, menu );
	343	c->SetTitle(title);
	344	wxAssociateMenuWithMacMenu( menu , peer ) ;
	345	return c;
	346	}
	347
	348	//
	349	//
	350	//
	351
	352	wxMenuItemCarbonImpl::~wxMenuItemCarbonImpl()
	353	{
	354	}
	355
	356
	357	wxMenuItemImpl* wxMenuItemImpl::Create( wxMenuItem* peer,
	358	wxMenu * WXUNUSED(pParentMenu),
	359	int WXUNUSED(id),
	360	const wxString& WXUNUSED(text),
	361	wxAcceleratorEntry *WXUNUSED(entry),
	362	const wxString& WXUNUSED(strHelp),
	363	wxItemKind WXUNUSED(kind),
	364	wxMenu *WXUNUSED(pSubMenu) )
	365	{
	366	wxMenuItemImpl* c = NULL;
	367
	368	c = new wxMenuItemCarbonImpl( peer );
	369	return c;
	370	}
	371
	372	void wxInsertMenuItemsInMenu(wxMenu* menu, MenuRef wm, MenuItemIndex insertAfter)
	373	{
	374	wxMenuItemList::compatibility_iterator node;
	375	wxMenuItem *item;
	376	wxMenu *subMenu = NULL ;
	377	bool newItems = false;
	378
	379	for (node = menu->GetMenuItems().GetFirst(); node; node = node->GetNext())
	380	{
	381	item = (wxMenuItem *)node->GetData();
	382	subMenu = item->GetSubMenu() ;
	383	if (subMenu)
	384	{
	385	wxInsertMenuItemsInMenu(subMenu, (MenuRef)subMenu->GetHMenu(), 0);
	386	}
	387	if ( item->IsSeparator() )
	388	{
	389	if ( wm && newItems)
	390	InsertMenuItemTextWithCFString( wm,
	391	CFSTR(""), insertAfter, kMenuItemAttrSeparator, 0);
	392
	393	newItems = false;
	394	}
	395	else
	396	{
	397	wxAcceleratorEntry*
	398	entry = wxAcceleratorEntry::Create( item->GetItemLabel() ) ;
	399
	400	MenuItemIndex winListPos = (MenuItemIndex)-1;
	401	OSStatus err = GetIndMenuItemWithCommandID(wm,
	402	wxIdToMacCommand ( item->GetId() ), 1, NULL, &winListPos);
	403
	404	if ( wm && err == menuItemNotFoundErr )
	405	{
	406	// NB: the only way to determine whether or not we should add
	407	// a separator is to know if we've added menu items to the menu
	408	// before the separator.
	409	newItems = true;
	410	UMAInsertMenuItem(wm, wxStripMenuCodes(item->GetItemLabel()) , wxFont::GetDefaultEncoding(), insertAfter, entry);
	411	SetMenuItemCommandID( wm , insertAfter+1 , wxIdToMacCommand ( item->GetId() ) ) ;
	412	SetMenuItemRefCon( wm , insertAfter+1 , (URefCon) item ) ;
	413	}
	414
	415	delete entry ;
	416	}
	417	}
	418	}
	419
	420