src/stubs/menu.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        menu.cpp
// Purpose:     wxMenu, wxMenuBar, wxMenuItem
// Author:      AUTHOR
// Modified by:
// Created:     ??/??/98
// RCS-ID:      $Id$
// Copyright:   (c) AUTHOR
// Licence:   	wxWindows licence
/////////////////////////////////////////////////////////////////////////////


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

// wxWindows headers
// -----------------

#ifdef __GNUG__
#pragma implementation "menu.h"
#pragma implementation "menuitem.h"
#endif

#include "wx/menu.h"
#include "wx/menuitem.h"
#include "wx/log.h"
#include "wx/utils.h"

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

#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxMenu, wxEvtHandler)
IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxEvtHandler)
#endif

// ============================================================================
// implementation
// ============================================================================

// Menus

// Construct a menu with optional title (then use append)
wxMenu::wxMenu(const wxString& title, const wxFunction func)
{
    m_title = title;
    m_parent = NULL;
    m_eventHandler = this;
    m_noItems = 0;
    m_menuBar = NULL;
    m_clientData = (void*) NULL;
    if (m_title != "")
    {
        Append(-2, m_title) ;
        AppendSeparator() ;
    }

    Callback(func);

    // TODO create menu
}

// The wxWindow destructor will take care of deleting the submenus.
wxMenu::~wxMenu()
{
    // TODO destroy menu and children

    wxNode *node = m_menuItems.First();
    while (node)
    {
        wxMenuItem *item = (wxMenuItem *)node->Data();

        // Delete child menus.
        // Beware: they must not be appended to children list!!!
        // (because order of delete is significant)
        if (item->GetSubMenu())
            item->DeleteSubMenu();

        wxNode *next = node->Next();
        delete item;
        delete node;
        node = next;
    }
}

void wxMenu::Break()
{
    // TODO
}

// function appends a new item or submenu to the menu
void wxMenu::Append(wxMenuItem *pItem)
{
    // TODO

    wxCHECK_RET( pItem != NULL, "can't append NULL item to the menu" );

    m_menuItems.Append(pItem);

    m_noItems++;
}

void wxMenu::AppendSeparator()
{
    // TODO
    Append(new wxMenuItem(this, ID_SEPARATOR));
}

// Pullright item
void wxMenu::Append(int Id, const wxString& label, wxMenu *SubMenu,
                    const wxString& helpString)
{
    Append(new wxMenuItem(this, Id, label, helpString, FALSE, SubMenu));
}

// Ordinary menu item
void wxMenu::Append(int Id, const wxString& label,
                    const wxString& helpString, bool checkable)
{
  // 'checkable' parameter is useless for Windows.
    Append(new wxMenuItem(this, Id, label, helpString, checkable));
}

void wxMenu::Delete(int id)
{
    wxNode *node;
    wxMenuItem *item;
    int pos;

    for (pos = 0, node = m_menuItems.First(); node; node = node->Next(), pos++) {
	 item = (wxMenuItem *)node->Data();
	 if (item->GetId() == id)
		break;
    }

    if (!node)
	return;

    m_menuItems.DeleteNode(node);
    delete item;

    // TODO
}

void wxMenu::Enable(int Id, bool Flag)
{
    wxMenuItem *item = FindItemForId(Id);
    wxCHECK_RET( item != NULL, "can't enable non-existing menu item" );

    item->Enable(Flag);
}

bool wxMenu::Enabled(int Id) const
{
    wxMenuItem *item = FindItemForId(Id);
    wxCHECK( item != NULL, FALSE );

    return item->IsEnabled();
}

void wxMenu::Check(int Id, bool Flag)
{
    wxMenuItem *item = FindItemForId(Id);
    wxCHECK_RET( item != NULL, "can't get status of non-existing menu item" );

    item->Check(Flag);
}

bool wxMenu::Checked(int Id) const
{
    wxMenuItem *item = FindItemForId(Id);
    wxCHECK( item != NULL, FALSE );

    return item->IsChecked();
}

void wxMenu::SetTitle(const wxString& label)
{
    m_title = label ;
    // TODO
}

const wxString wxMenu::GetTitle() const
{
    return m_title;
}

void wxMenu::SetLabel(int id, const wxString& label)
{
    wxMenuItem *item = FindItemForId(id) ;
    if (item==NULL)
        return;

    if (item->GetSubMenu()==NULL)
    {
        // TODO
    }
    else
    {
        // TODO
    }
    item->SetName(label);
}

wxString wxMenu::GetLabel(int Id) const
{
    // TODO
    return wxString("") ;
}

// Finds the item id matching the given string, -1 if not found.
int wxMenu::FindItem (const wxString& itemString) const
{
    char buf1[200];
    char buf2[200];
    wxStripMenuCodes ((char *)(const char *)itemString, buf1);

    for (wxNode * node = m_menuItems.First (); node; node = node->Next ())
    {
      wxMenuItem *item = (wxMenuItem *) node->Data ();
      if (item->GetSubMenu())
      {
        int ans = item->GetSubMenu()->FindItem(itemString);
        if (ans > -1)
          return ans;
      }
      if ( !item->IsSeparator() )
      {
        wxStripMenuCodes((char *)item->GetName().c_str(), buf2);
        if (strcmp(buf1, buf2) == 0)
          return item->GetId();
      }
    }

    return -1;
}

wxMenuItem *wxMenu::FindItemForId(int itemId, wxMenu ** itemMenu) const
{
    if (itemMenu)
        *itemMenu = NULL;
    for (wxNode * node = m_menuItems.First (); node; node = node->Next ())
    {
        wxMenuItem *item = (wxMenuItem *) node->Data ();

        if (item->GetId() == itemId)
        {
            if (itemMenu)
                *itemMenu = (wxMenu *) this;
            return item;
        }

        if (item->GetSubMenu())
        {
            wxMenuItem *ans = item->GetSubMenu()->FindItemForId (itemId, itemMenu);
            if (ans)
                return ans;
        }
    }

    if (itemMenu)
        *itemMenu = NULL;
    return NULL;
}

void wxMenu::SetHelpString(int itemId, const wxString& helpString)
{
    wxMenuItem *item = FindItemForId (itemId);
    if (item)
        item->SetHelp(helpString);
}

wxString wxMenu::GetHelpString (int itemId) const
{
    wxMenuItem *item = FindItemForId (itemId);
    wxString str("");
    return (item == NULL) ? str : item->GetHelp();
}

void wxMenu::ProcessCommand(wxCommandEvent & event)
{
    bool processed = FALSE;

    // Try a callback
    if (m_callback)
    {
            (void) (*(m_callback)) (*this, event);
            processed = TRUE;
    }

    // Try the menu's event handler
    if ( !processed && GetEventHandler())
    {
            processed = GetEventHandler()->ProcessEvent(event);
    }
/* TODO
    // Try the window the menu was popped up from (and up
    // through the hierarchy)
    if ( !processed && GetInvokingWindow())
        processed = GetInvokingWindow()->ProcessEvent(event);
*/
}

// Update a menu and all submenus recursively.
// source is the object that has the update event handlers
// defined for it. If NULL, the menu or associated window
// will be used.
void wxMenu::UpdateUI(wxEvtHandler* source)
{
  if (!source && GetInvokingWindow())
    source = GetInvokingWindow()->GetEventHandler();
  if (!source)
    source = GetEventHandler();
  if (!source)
    source = this;

  wxNode* node = GetItems().First();
  while (node)
  {
    wxMenuItem* item = (wxMenuItem*) node->Data();
    if ( !item->IsSeparator() )
    {
      wxWindowID id = item->GetId();
      wxUpdateUIEvent event(id);
      event.SetEventObject( source );

      if (source->ProcessEvent(event))
      {
        if (event.GetSetText())
          SetLabel(id, event.GetText());
        if (event.GetSetChecked())
          Check(id, event.GetChecked());
        if (event.GetSetEnabled())
          Enable(id, event.GetEnabled());
      }

      if (item->GetSubMenu())
        item->GetSubMenu()->UpdateUI(source);
    }
    node = node->Next();
  }
}

bool wxWindow::PopupMenu(wxMenu *menu, int x, int y)
{
    menu->SetInvokingWindow(this);
    menu->UpdateUI();

    // TODO
    return FALSE;
}

// Menu Bar
wxMenuBar::wxMenuBar()
{
    m_eventHandler = this;
    m_menuCount = 0;
    m_menus = NULL;
    m_titles = NULL;
    m_menuBarFrame = NULL;

    // TODO
}

wxMenuBar::wxMenuBar(int n, wxMenu *menus[], const wxString titles[])
{
    m_eventHandler = this;
    m_menuCount = n;
    m_menus = menus;
    m_titles = new wxString[n];
    int i;
    for ( i = 0; i < n; i++ )
	m_titles[i] = titles[i];
    m_menuBarFrame = NULL;

    // TODO
}

wxMenuBar::~wxMenuBar()
{
    int i;
    for (i = 0; i < m_menuCount; i++)
    {
        delete m_menus[i];
    }
    delete[] m_menus;
    delete[] m_titles;

    // TODO
}

// Must only be used AFTER menu has been attached to frame,
// otherwise use individual menus to enable/disable items
void wxMenuBar::Enable(int id, bool flag)
{
    wxMenu *itemMenu = NULL;
    wxMenuItem *item = FindItemForId(id, &itemMenu) ;
    if (!item)
        return;

    // TODO
}

void wxMenuBar::EnableTop(int pos, bool flag)
{
    // TODO
}

// Must only be used AFTER menu has been attached to frame,
// otherwise use individual menus
void wxMenuBar::Check(int id, bool flag)
{
    wxMenu *itemMenu = NULL;
    wxMenuItem *item = FindItemForId(id, &itemMenu) ;
    if (!item)
        return;

    if (!item->IsCheckable())
        return ;

    // TODO
}

bool wxMenuBar::Checked(int id) const
{
    wxMenu *itemMenu = NULL;
    wxMenuItem *item = FindItemForId(id, &itemMenu) ;
    if (!item)
        return FALSE;

    // TODO
    return FALSE;
}

bool wxMenuBar::Enabled(int id) const
{
    wxMenu *itemMenu = NULL;
    wxMenuItem *item = FindItemForId(id, &itemMenu) ;
    if (!item)
        return FALSE;

    // TODO
    return FALSE ;
}


void wxMenuBar::SetLabel(int id, const wxString& label)
{
    wxMenu *itemMenu = NULL;
    wxMenuItem *item = FindItemForId(id, &itemMenu) ;

    if (!item)
        return;

    // TODO
}

wxString wxMenuBar::GetLabel(int id) const
{
    wxMenu *itemMenu = NULL;
    wxMenuItem *item = FindItemForId(id, &itemMenu) ;

    if (!item)
        return wxString("");

    // TODO
    return wxString("") ;
}

void wxMenuBar::SetLabelTop(int pos, const wxString& label)
{
    // TODO
}

wxString wxMenuBar::GetLabelTop(int pos) const
{
    // TODO
    return wxString("");
}

bool wxMenuBar::OnDelete(wxMenu *a_menu, int pos)
{
    // TODO
    return FALSE;
}

bool wxMenuBar::OnAppend(wxMenu *a_menu, const char *title)
{
    // TODO
    return FALSE;
}

void wxMenuBar::Append (wxMenu * menu, const wxString& title)
{
    if (!OnAppend(menu, title))
        return;

    m_menuCount ++;
    wxMenu **new_menus = new wxMenu *[m_menuCount];
    wxString *new_titles = new wxString[m_menuCount];
    int i;

    for (i = 0; i < m_menuCount - 1; i++)
	{
        new_menus[i] = m_menus[i];
        m_menus[i] = NULL;
        new_titles[i] = m_titles[i];
        m_titles[i] = "";
    }
    if (m_menus)
    {
        delete[]m_menus;
        delete[]m_titles;
    }
    m_menus = new_menus;
    m_titles = new_titles;

    m_menus[m_menuCount - 1] = (wxMenu *)menu;
    m_titles[m_menuCount - 1] = title;

    // TODO
}

void wxMenuBar::Delete(wxMenu * menu, int i)
{
    int j;
    int ii = (int) i;

    if (menu != 0)
    {
	    for (ii = 0; ii < m_menuCount; ii++)
        {
            if (m_menus[ii] == menu)
            break;
	    }
        if (ii >= m_menuCount)
            return;
    } else
    {
        if (ii < 0 || ii >= m_menuCount)
            return;
        menu = m_menus[ii];
    }

    if (!OnDelete(menu, ii))
        return;

    menu->SetParent(NULL);

    -- m_menuCount;
    for (j = ii; j < m_menuCount; j++)
    {
        m_menus[j] = m_menus[j + 1];
        m_titles[j] = m_titles[j + 1];
    }
}

// Find the menu menuString, item itemString, and return the item id.
// Returns -1 if none found.
int wxMenuBar::FindMenuItem (const wxString& menuString, const wxString& itemString) const
{
    char buf1[200];
    char buf2[200];
    wxStripMenuCodes ((char *)(const char *)menuString, buf1);
    int i;
    for (i = 0; i < m_menuCount; i++)
    {
        wxStripMenuCodes ((char *)(const char *)m_titles[i], buf2);
        if (strcmp (buf1, buf2) == 0)
            return m_menus[i]->FindItem (itemString);
    }
    return -1;
}

wxMenuItem *wxMenuBar::FindItemForId (int Id, wxMenu ** itemMenu) const
{
    if (itemMenu)
        *itemMenu = NULL;

    wxMenuItem *item = NULL;
    int i;
    for (i = 0; i < m_menuCount; i++)
        if ((item = m_menus[i]->FindItemForId (Id, itemMenu)))
            return item;
    return NULL;
}

void wxMenuBar::SetHelpString (int Id, const wxString& helpString)
{
    int i;
    for (i = 0; i < m_menuCount; i++)
    {
        if (m_menus[i]->FindItemForId (Id))
        {
            m_menus[i]->SetHelpString (Id, helpString);
            return;
        }
    }
}

wxString wxMenuBar::GetHelpString (int Id) const
{
    int i;
    for (i = 0; i < m_menuCount; i++)
    {
        if (m_menus[i]->FindItemForId (Id))
            return wxString(m_menus[i]->GetHelpString (Id));
    }
    return wxString("");
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: menu.cpp
	3	// Purpose: wxMenu, wxMenuBar, wxMenuItem
	4	// Author: AUTHOR
	5	// Modified by:
	6	// Created: ??/??/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) AUTHOR
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12
	13	// ============================================================================
	14	// headers & declarations
	15	// ============================================================================
	16
	17	// wxWindows headers
	18	// -----------------
	19
	20	#ifdef __GNUG__
	21	#pragma implementation "menu.h"
	22	#pragma implementation "menuitem.h"
	23	#endif
	24
	25	#include "wx/menu.h"
	26	#include "wx/menuitem.h"
	27	#include "wx/log.h"
	28	#include "wx/utils.h"
	29
	30	// other standard headers
	31	// ----------------------
	32	#include <string.h>
	33
	34	#if !USE_SHARED_LIBRARY
	35	IMPLEMENT_DYNAMIC_CLASS(wxMenu, wxEvtHandler)
	36	IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxEvtHandler)
	37	#endif
	38
	39	// ============================================================================
	40	// implementation
	41	// ============================================================================
	42
	43	// Menus
	44
	45	// Construct a menu with optional title (then use append)
	46	wxMenu::wxMenu(const wxString& title, const wxFunction func)
	47	{
	48	m_title = title;
	49	m_parent = NULL;
	50	m_eventHandler = this;
	51	m_noItems = 0;
	52	m_menuBar = NULL;
	53	m_clientData = (void*) NULL;
	54	if (m_title != "")
	55	{
	56	Append(-2, m_title) ;
	57	AppendSeparator() ;
	58	}
	59
	60	Callback(func);
	61
	62	// TODO create menu
	63	}
	64
	65	// The wxWindow destructor will take care of deleting the submenus.
	66	wxMenu::~wxMenu()
	67	{
	68	// TODO destroy menu and children
	69
	70	wxNode *node = m_menuItems.First();
	71	while (node)
	72	{
	73	wxMenuItem item = (wxMenuItem )node->Data();
	74
	75	// Delete child menus.
	76	// Beware: they must not be appended to children list!!!
	77	// (because order of delete is significant)
	78	if (item->GetSubMenu())
	79	item->DeleteSubMenu();
	80
	81	wxNode *next = node->Next();
	82	delete item;
	83	delete node;
	84	node = next;
	85	}
	86	}
	87
	88	void wxMenu::Break()
	89	{
	90	// TODO
	91	}
	92
	93	// function appends a new item or submenu to the menu
	94	void wxMenu::Append(wxMenuItem *pItem)
	95	{
	96	// TODO
	97
	98	wxCHECK_RET( pItem != NULL, "can't append NULL item to the menu" );
	99
	100	m_menuItems.Append(pItem);
	101
	102	m_noItems++;
	103	}
	104
	105	void wxMenu::AppendSeparator()
	106	{
	107	// TODO
	108	Append(new wxMenuItem(this, ID_SEPARATOR));
	109	}
	110
	111	// Pullright item
	112	void wxMenu::Append(int Id, const wxString& label, wxMenu *SubMenu,
	113	const wxString& helpString)
	114	{
	115	Append(new wxMenuItem(this, Id, label, helpString, FALSE, SubMenu));
	116	}
	117
	118	// Ordinary menu item
	119	void wxMenu::Append(int Id, const wxString& label,
	120	const wxString& helpString, bool checkable)
	121	{
	122	// 'checkable' parameter is useless for Windows.
	123	Append(new wxMenuItem(this, Id, label, helpString, checkable));
	124	}
	125
	126	void wxMenu::Delete(int id)
	127	{
	128	wxNode *node;
	129	wxMenuItem *item;
	130	int pos;
	131
	132	for (pos = 0, node = m_menuItems.First(); node; node = node->Next(), pos++) {
	133	item = (wxMenuItem *)node->Data();
	134	if (item->GetId() == id)
	135	break;
	136	}
	137
	138	if (!node)
	139	return;
	140
	141	m_menuItems.DeleteNode(node);
	142	delete item;
	143
	144	// TODO
	145	}
	146
	147	void wxMenu::Enable(int Id, bool Flag)
	148	{
	149	wxMenuItem *item = FindItemForId(Id);
	150	wxCHECK_RET( item != NULL, "can't enable non-existing menu item" );
	151
	152	item->Enable(Flag);
	153	}
	154
	155	bool wxMenu::Enabled(int Id) const
	156	{
	157	wxMenuItem *item = FindItemForId(Id);
	158	wxCHECK( item != NULL, FALSE );
	159
	160	return item->IsEnabled();
	161	}
	162
	163	void wxMenu::Check(int Id, bool Flag)
	164	{
	165	wxMenuItem *item = FindItemForId(Id);
	166	wxCHECK_RET( item != NULL, "can't get status of non-existing menu item" );
	167
	168	item->Check(Flag);
	169	}
	170
	171	bool wxMenu::Checked(int Id) const
	172	{
	173	wxMenuItem *item = FindItemForId(Id);
	174	wxCHECK( item != NULL, FALSE );
	175
	176	return item->IsChecked();
	177	}
	178
	179	void wxMenu::SetTitle(const wxString& label)
	180	{
	181	m_title = label ;
	182	// TODO
	183	}
	184
	185	const wxString wxMenu::GetTitle() const
	186	{
	187	return m_title;
	188	}
	189
	190	void wxMenu::SetLabel(int id, const wxString& label)
	191	{
	192	wxMenuItem *item = FindItemForId(id) ;
	193	if (item==NULL)
	194	return;
	195
	196	if (item->GetSubMenu()==NULL)
	197	{
	198	// TODO
	199	}
	200	else
	201	{
	202	// TODO
	203	}
	204	item->SetName(label);
	205	}
	206
	207	wxString wxMenu::GetLabel(int Id) const
	208	{
	209	// TODO
	210	return wxString("") ;
	211	}
	212
	213	// Finds the item id matching the given string, -1 if not found.
	214	int wxMenu::FindItem (const wxString& itemString) const
	215	{
	216	char buf1[200];
	217	char buf2[200];
	218	wxStripMenuCodes ((char )(const char )itemString, buf1);
	219
	220	for (wxNode * node = m_menuItems.First (); node; node = node->Next ())
	221	{
	222	wxMenuItem item = (wxMenuItem ) node->Data ();
	223	if (item->GetSubMenu())
	224	{
	225	int ans = item->GetSubMenu()->FindItem(itemString);
	226	if (ans > -1)
	227	return ans;
	228	}
	229	if ( !item->IsSeparator() )
	230	{
	231	wxStripMenuCodes((char *)item->GetName().c_str(), buf2);
	232	if (strcmp(buf1, buf2) == 0)
	233	return item->GetId();
	234	}
	235	}
	236
	237	return -1;
	238	}
	239
	240	wxMenuItem wxMenu::FindItemForId(int itemId, wxMenu * itemMenu) const
	241	{
	242	if (itemMenu)
	243	*itemMenu = NULL;
	244	for (wxNode * node = m_menuItems.First (); node; node = node->Next ())
	245	{
	246	wxMenuItem item = (wxMenuItem ) node->Data ();
	247
	248	if (item->GetId() == itemId)
	249	{
	250	if (itemMenu)
	251	itemMenu = (wxMenu ) this;
	252	return item;
	253	}
	254
	255	if (item->GetSubMenu())
	256	{
	257	wxMenuItem *ans = item->GetSubMenu()->FindItemForId (itemId, itemMenu);
	258	if (ans)
	259	return ans;
	260	}
	261	}
	262
	263	if (itemMenu)
	264	*itemMenu = NULL;
	265	return NULL;
	266	}
	267
	268	void wxMenu::SetHelpString(int itemId, const wxString& helpString)
	269	{
	270	wxMenuItem *item = FindItemForId (itemId);
	271	if (item)
	272	item->SetHelp(helpString);
	273	}
	274
	275	wxString wxMenu::GetHelpString (int itemId) const
	276	{
	277	wxMenuItem *item = FindItemForId (itemId);
	278	wxString str("");
	279	return (item == NULL) ? str : item->GetHelp();
	280	}
	281
	282	void wxMenu::ProcessCommand(wxCommandEvent & event)
	283	{
	284	bool processed = FALSE;
	285
	286	// Try a callback
	287	if (m_callback)
	288	{
	289	(void) ((m_callback)) (this, event);
	290	processed = TRUE;
	291	}
	292
	293	// Try the menu's event handler
	294	if ( !processed && GetEventHandler())
	295	{
	296	processed = GetEventHandler()->ProcessEvent(event);
	297	}
	298	/* TODO
	299	// Try the window the menu was popped up from (and up
	300	// through the hierarchy)
	301	if ( !processed && GetInvokingWindow())
	302	processed = GetInvokingWindow()->ProcessEvent(event);
	303	*/
	304	}
	305
	306	// Update a menu and all submenus recursively.
	307	// source is the object that has the update event handlers
	308	// defined for it. If NULL, the menu or associated window
	309	// will be used.
	310	void wxMenu::UpdateUI(wxEvtHandler* source)
	311	{
	312	if (!source && GetInvokingWindow())
	313	source = GetInvokingWindow()->GetEventHandler();
	314	if (!source)
	315	source = GetEventHandler();
	316	if (!source)
	317	source = this;
	318
	319	wxNode* node = GetItems().First();
	320	while (node)
	321	{
	322	wxMenuItem* item = (wxMenuItem*) node->Data();
	323	if ( !item->IsSeparator() )
	324	{
	325	wxWindowID id = item->GetId();
	326	wxUpdateUIEvent event(id);
	327	event.SetEventObject( source );
	328
	329	if (source->ProcessEvent(event))
	330	{
	331	if (event.GetSetText())
	332	SetLabel(id, event.GetText());
	333	if (event.GetSetChecked())
	334	Check(id, event.GetChecked());
	335	if (event.GetSetEnabled())
	336	Enable(id, event.GetEnabled());
	337	}
	338
	339	if (item->GetSubMenu())
	340	item->GetSubMenu()->UpdateUI(source);
	341	}
	342	node = node->Next();
	343	}
	344	}
	345
	346	bool wxWindow::PopupMenu(wxMenu *menu, int x, int y)
	347	{
	348	menu->SetInvokingWindow(this);
	349	menu->UpdateUI();
	350
	351	// TODO
	352	return FALSE;
	353	}
	354
	355	// Menu Bar
	356	wxMenuBar::wxMenuBar()
	357	{
	358	m_eventHandler = this;
	359	m_menuCount = 0;
	360	m_menus = NULL;
	361	m_titles = NULL;
	362	m_menuBarFrame = NULL;
	363
	364	// TODO
	365	}
	366
	367	wxMenuBar::wxMenuBar(int n, wxMenu *menus[], const wxString titles[])
	368	{
	369	m_eventHandler = this;
	370	m_menuCount = n;
	371	m_menus = menus;
	372	m_titles = new wxString[n];
	373	int i;
	374	for ( i = 0; i < n; i++ )
	375	m_titles[i] = titles[i];
	376	m_menuBarFrame = NULL;
	377
	378	// TODO
	379	}
	380
	381	wxMenuBar::~wxMenuBar()
	382	{
	383	int i;
	384	for (i = 0; i < m_menuCount; i++)
	385	{
	386	delete m_menus[i];
	387	}
	388	delete[] m_menus;
	389	delete[] m_titles;
	390
	391	// TODO
	392	}
	393
	394	// Must only be used AFTER menu has been attached to frame,
	395	// otherwise use individual menus to enable/disable items
	396	void wxMenuBar::Enable(int id, bool flag)
	397	{
	398	wxMenu *itemMenu = NULL;
	399	wxMenuItem *item = FindItemForId(id, &itemMenu) ;
	400	if (!item)
	401	return;
	402
	403	// TODO
	404	}
	405
	406	void wxMenuBar::EnableTop(int pos, bool flag)
	407	{
	408	// TODO
	409	}
	410
	411	// Must only be used AFTER menu has been attached to frame,
	412	// otherwise use individual menus
	413	void wxMenuBar::Check(int id, bool flag)
	414	{
	415	wxMenu *itemMenu = NULL;
	416	wxMenuItem *item = FindItemForId(id, &itemMenu) ;
	417	if (!item)
	418	return;
	419
	420	if (!item->IsCheckable())
	421	return ;
	422
	423	// TODO
	424	}
	425
	426	bool wxMenuBar::Checked(int id) const
	427	{
	428	wxMenu *itemMenu = NULL;
	429	wxMenuItem *item = FindItemForId(id, &itemMenu) ;
	430	if (!item)
	431	return FALSE;
	432
	433	// TODO
	434	return FALSE;
	435	}
	436
	437	bool wxMenuBar::Enabled(int id) const
	438	{
	439	wxMenu *itemMenu = NULL;
	440	wxMenuItem *item = FindItemForId(id, &itemMenu) ;
	441	if (!item)
	442	return FALSE;
	443
	444	// TODO
	445	return FALSE ;
	446	}
	447
	448
	449	void wxMenuBar::SetLabel(int id, const wxString& label)
	450	{
	451	wxMenu *itemMenu = NULL;
	452	wxMenuItem *item = FindItemForId(id, &itemMenu) ;
	453
	454	if (!item)
	455	return;
	456
	457	// TODO
	458	}
	459
	460	wxString wxMenuBar::GetLabel(int id) const
	461	{
	462	wxMenu *itemMenu = NULL;
	463	wxMenuItem *item = FindItemForId(id, &itemMenu) ;
	464
	465	if (!item)
	466	return wxString("");
	467
	468	// TODO
	469	return wxString("") ;
	470	}
	471
	472	void wxMenuBar::SetLabelTop(int pos, const wxString& label)
	473	{
	474	// TODO
	475	}
	476
	477	wxString wxMenuBar::GetLabelTop(int pos) const
	478	{
	479	// TODO
	480	return wxString("");
	481	}
	482
	483	bool wxMenuBar::OnDelete(wxMenu *a_menu, int pos)
	484	{
	485	// TODO
	486	return FALSE;
	487	}
	488
	489	bool wxMenuBar::OnAppend(wxMenu a_menu, const char title)
	490	{
	491	// TODO
	492	return FALSE;
	493	}
	494
	495	void wxMenuBar::Append (wxMenu * menu, const wxString& title)
	496	{
	497	if (!OnAppend(menu, title))
	498	return;
	499
	500	m_menuCount ++;
	501	wxMenu *new_menus = new wxMenu [m_menuCount];
	502	wxString *new_titles = new wxString[m_menuCount];
	503	int i;
	504
	505	for (i = 0; i < m_menuCount - 1; i++)
	506	{
	507	new_menus[i] = m_menus[i];
	508	m_menus[i] = NULL;
	509	new_titles[i] = m_titles[i];
	510	m_titles[i] = "";
	511	}
	512	if (m_menus)
	513	{
	514	delete[]m_menus;
	515	delete[]m_titles;
	516	}
	517	m_menus = new_menus;
	518	m_titles = new_titles;
	519
	520	m_menus[m_menuCount - 1] = (wxMenu *)menu;
	521	m_titles[m_menuCount - 1] = title;
	522
	523	// TODO
	524	}
	525
	526	void wxMenuBar::Delete(wxMenu * menu, int i)
	527	{
	528	int j;
	529	int ii = (int) i;
	530
	531	if (menu != 0)
	532	{
	533	for (ii = 0; ii < m_menuCount; ii++)
	534	{
	535	if (m_menus[ii] == menu)
	536	break;
	537	}
	538	if (ii >= m_menuCount)
	539	return;
	540	} else
	541	{
	542	if (ii < 0 \|\| ii >= m_menuCount)
	543	return;
	544	menu = m_menus[ii];
	545	}
	546
	547	if (!OnDelete(menu, ii))
	548	return;
	549
	550	menu->SetParent(NULL);
	551
	552	-- m_menuCount;
	553	for (j = ii; j < m_menuCount; j++)
	554	{
	555	m_menus[j] = m_menus[j + 1];
	556	m_titles[j] = m_titles[j + 1];
	557	}
	558	}
	559
	560	// Find the menu menuString, item itemString, and return the item id.
	561	// Returns -1 if none found.
	562	int wxMenuBar::FindMenuItem (const wxString& menuString, const wxString& itemString) const
	563	{
	564	char buf1[200];
	565	char buf2[200];
	566	wxStripMenuCodes ((char )(const char )menuString, buf1);
	567	int i;
	568	for (i = 0; i < m_menuCount; i++)
	569	{
	570	wxStripMenuCodes ((char )(const char )m_titles[i], buf2);
	571	if (strcmp (buf1, buf2) == 0)
	572	return m_menus[i]->FindItem (itemString);
	573	}
	574	return -1;
	575	}
	576
	577	wxMenuItem wxMenuBar::FindItemForId (int Id, wxMenu * itemMenu) const
	578	{
	579	if (itemMenu)
	580	*itemMenu = NULL;
	581
	582	wxMenuItem *item = NULL;
	583	int i;
	584	for (i = 0; i < m_menuCount; i++)
	585	if ((item = m_menus[i]->FindItemForId (Id, itemMenu)))
	586	return item;
	587	return NULL;
	588	}
	589
	590	void wxMenuBar::SetHelpString (int Id, const wxString& helpString)
	591	{
	592	int i;
	593	for (i = 0; i < m_menuCount; i++)
	594	{
	595	if (m_menus[i]->FindItemForId (Id))
	596	{
	597	m_menus[i]->SetHelpString (Id, helpString);
	598	return;
	599	}
	600	}
	601	}
	602
	603	wxString wxMenuBar::GetHelpString (int Id) const
	604	{
	605	int i;
	606	for (i = 0; i < m_menuCount; i++)
	607	{
	608	if (m_menus[i]->FindItemForId (Id))
	609	return wxString(m_menus[i]->GetHelpString (Id));
	610	}
	611	return wxString("");
	612	}
	613
	614