X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FMenuBackend.C;h=2488f26df2faf54190cd61341318c8f9db8bb000;hb=dcdbeb3b3475d803c0c66e463dca64db0103c10d;hp=d7dd0f618731f1d1b0071246f4429114a44b846e;hpb=b8072fd6f77ebd592ecd514dadc04839516b8a8b;p=features.git

diff --git a/src/MenuBackend.C b/src/MenuBackend.C
index d7dd0f6187..2488f26df2 100644
--- a/src/MenuBackend.C
+++ b/src/MenuBackend.C
@@ -1,60 +1,115 @@
 /* This file is part of
- * ====================================================== 
- * 
+ * ======================================================
+ *
  *           LyX, The Document Processor
  *
  *           Copyright 1995 Matthias Ettrich
- *           Copyright 1995-2000 The LyX Team.
+ *           Copyright 1995-2001 The LyX Team.
  *
  *
  * ====================================================== */
 
+#include <config.h>
+
 #ifdef __GNUG__
 #pragma implementation
 #endif
 
-#include <config.h>
-#include "support/LAssert.h"
+#include <algorithm>
 #include "MenuBackend.h"
 #include "lyxlex.h"
 #include "LyXAction.h"
 #include "debug.h"
+#include "gettext.h"
+#include "lastfiles.h"
+#include "lyx_main.h" // for lastfiles
+#include "bufferlist.h"
+#include "buffer.h"
+#include "converter.h"
+#include "exporter.h"
+#include "importer.h"
+#include "FloatList.h"
+#include "toc.h"
+#include "support/LAssert.h"
+#include "support/filetools.h"
+#include "support/lyxfunctional.h"
+#include "support/lstrings.h"
 
-extern LyXAction lyxaction;
+extern BufferList bufferlist;
 
 using std::endl;
+using std::vector;
+using std::max;
+using std::pair;
+using std::find_if;
+using std::sort;
 
 // This is the global menu definition
 MenuBackend menubackend;
 
 
-MenuItem::MenuItem(Kind kind, string const & label, 
-		   string const & command, bool optional) 
+MenuItem::MenuItem(Kind kind, string const & label,
+		   string const & command, bool optional)
 	: kind_(kind), label_(label), optional_(optional)
 {
-	switch(kind) {
+	switch (kind) {
 	case Separator:
 	case Documents:
 	case Lastfiles:
+	case Toc:
+	case ViewFormats:
+	case UpdateFormats:
+	case ExportFormats:
+	case ImportFormats:
+	case FloatListInsert:
+	case FloatInsert:
 		break;
 	case Command:
 		action_ = lyxaction.LookupFunc(command);
 
 		if (action_ == LFUN_UNKNOWN_ACTION) {
 			lyxerr << "MenuItem(): LyX command `"
-			       << command << "' does not exist." << endl; 
+			       << command << "' does not exist." << endl;
 		}
 		if (optional_)
-			lyxerr[Debug::GUI] << "Optional item " 
-					   << command << endl; 
+			lyxerr[Debug::GUI] << "Optional item "
+					   << command << endl;
 		break;
 	case Submenu:
-		submenu_ = command;
+		submenuname_ = command;
 		break;
 	}
 }
 
 
+MenuItem::MenuItem(Kind kind, string const & label, int action, bool optional)
+	: kind_(kind), label_(label), action_(action), submenuname_(),
+	  optional_(optional)
+{}
+
+
+MenuItem::~MenuItem()
+{}
+
+
+void MenuItem::submenu(Menu * menu)
+{
+	submenu_.reset(menu);
+}
+
+
+string const MenuItem::label() const
+{
+	return token(label_, '|', 0);
+}
+
+
+string const MenuItem::shortcut() const
+{
+	return token(label_, '|', 1);
+}
+
+
 Menu & Menu::add(MenuItem const & i)
 {
 	items_.push_back(i);
@@ -62,27 +117,41 @@ Menu & Menu::add(MenuItem const & i)
 }
 
 
-void Menu::read(LyXLex & lex)
+Menu & Menu::read(LyXLex & lex)
 {
 	enum Menutags {
 		md_item = 1,
 		md_documents,
 		md_endmenu,
+		md_exportformats,
+		md_importformats,
 		md_lastfiles,
 		md_optitem,
-		md_submenu,
 		md_separator,
+		md_submenu,
+		md_toc,
+		md_updateformats,
+		md_viewformats,
+		md_floatlistinsert,
+		md_floatinsert,
 		md_last
 	};
 
-	struct keyword_item menutags[md_last-1] = {
+	struct keyword_item menutags[md_last - 1] = {
 		{ "documents", md_documents },
 		{ "end", md_endmenu },
+		{ "exportformats", md_exportformats },
+		{ "floatinsert", md_floatinsert },
+		{ "floatlistinsert", md_floatlistinsert },
+		{ "importformats", md_importformats },
 		{ "item", md_item },
 		{ "lastfiles", md_lastfiles },
-		{ "optitem", md_optitem }, 
+		{ "optitem", md_optitem },
 		{ "separator", md_separator },
-		{ "submenu", md_submenu }
+		{ "submenu", md_submenu },
+		{ "toc", md_toc },
+		{ "updateformats", md_updateformats },
+		{ "viewformats", md_viewformats }
 	};
 
 	lex.pushTable(menutags, md_last - 1);
@@ -92,48 +161,429 @@ void Menu::read(LyXLex & lex)
 	bool quit = false;
 	bool optional = false;
 
-	while (lex.IsOK() && !quit) {
-		switch(lex.lex()) {
+	while (lex.isOK() && !quit) {
+		switch (lex.lex()) {
 		case md_optitem:
 			optional = true;
 			// fallback to md_item
 		case md_item: {
-			lex.next();
-			string name = lex.GetString();
-			lex.next();
-			string command = lex.GetString();
-			add(MenuItem(MenuItem::Command, name, 
+			lex.next(true);
+			string const name = _(lex.getString());
+			lex.next(true);
+			string const command = lex.getString();
+			add(MenuItem(MenuItem::Command, name,
 				     command, optional));
 			optional = false;
 			break;
 		}
+
 		case md_separator:
 			add(MenuItem(MenuItem::Separator));
 			break;
+
 		case md_lastfiles:
 			add(MenuItem(MenuItem::Lastfiles));
 			break;
+
 		case md_documents:
 			add(MenuItem(MenuItem::Documents));
 			break;
+
+		case md_toc:
+			add(MenuItem(MenuItem::Toc));
+			break;
+
+		case md_viewformats:
+			add(MenuItem(MenuItem::ViewFormats));
+			break;
+
+		case md_updateformats:
+			add(MenuItem(MenuItem::UpdateFormats));
+			break;
+
+		case md_exportformats:
+			add(MenuItem(MenuItem::ExportFormats));
+			break;
+
+		case md_importformats:
+			add(MenuItem(MenuItem::ImportFormats));
+			break;
+
+		case md_floatlistinsert:
+			add(MenuItem(MenuItem::FloatListInsert));
+			break;
+
+		case md_floatinsert:
+			add(MenuItem(MenuItem::FloatInsert));
+			break;
+
 		case md_submenu: {
-			lex.next();
-			string mlabel = lex.GetString();
-			lex.next();
-			string mname = lex.GetString();
+			lex.next(true);
+			string const mlabel = _(lex.getString());
+			lex.next(true);
+			string const mname = lex.getString();
 			add(MenuItem(MenuItem::Submenu, mlabel, mname));
 			break;
 		}
+
 		case md_endmenu:
 			quit = true;
 			break;
+
 		default:
-			lex.printError("menubar::read: "
+			lex.printError("Menu::read: "
 				       "Unknown menu tag: `$$Token'");
 			break;
 		}
 	}
 	lex.popTable();
+	return *this;
+}
+
+
+void Menu::checkShortcuts() const
+{
+	// This is a quadratic algorithm, but we do not care because
+	// it is used for debugging only.
+	for (const_iterator it1 = begin(); it1 != end(); ++it1) {
+		string shortcut = it1->shortcut();
+		if (shortcut.empty())
+			continue;
+		if (!contains(it1->label(), shortcut))
+			lyxerr << "Menu warning: menu entry \""
+			       << it1->label()
+			       << "\" does not contain shortcut `"
+			       << shortcut << '\'' << endl;
+		for (const_iterator it2 = begin(); it2 != it1 ; ++it2) {
+			if (!compare_ascii_no_case(it2->shortcut(), shortcut)) {
+				lyxerr << "Menu warning: menu entries "
+				       << '"' << it1->fulllabel()
+				       << "\" and \"" << it2->fulllabel()
+				       << "\" share the same shortcut."
+				       << endl;
+			}
+		}
+	}
+}
+
+
+namespace {
+
+class compare_format {
+public:
+	bool operator()(Format const * p1, Format const * p2) {
+		return *p1 < *p2;
+	}
+};
+
+string const limit_string_length(string const & str)
+{
+	string::size_type const max_item_length = 45;
+
+	if (str.size() > max_item_length)
+		return str.substr(0, max_item_length - 3) + "...";
+	else
+		return str;
+}
+
+
+void expandLastfiles(Menu & tomenu)
+{
+	int ii = 1;
+	LastFiles::const_iterator lfit = lastfiles->begin();
+	LastFiles::const_iterator end = lastfiles->end();
+
+	for (; lfit != end && ii < 10; ++lfit, ++ii) {
+		string const label = tostr(ii) + ". "
+			+ MakeDisplayPath((*lfit), 30)
+			+ '|' + tostr(ii);
+		int const action = lyxaction.
+			getPseudoAction(LFUN_FILE_OPEN,
+					(*lfit));
+		tomenu.add(MenuItem(MenuItem::Command,
+				    label, action));
+	}
+}
+
+void expandDocuments(Menu & tomenu)
+{
+	typedef vector<string> Strings;
+	Strings const names = bufferlist.getFileNames();
+
+	if (names.empty()) {
+		tomenu.add(MenuItem(MenuItem::Command, _("No Documents Open!"),
+				    LFUN_NOACTION));
+		return;
+	}
+
+	int ii = 1;
+	Strings::const_iterator docit = names.begin();
+	Strings::const_iterator end = names.end();
+	for (; docit != end; ++docit, ++ii) {
+		int const action =
+			lyxaction.getPseudoAction(LFUN_SWITCHBUFFER, *docit);
+		string label = MakeDisplayPath(*docit, 30);
+		if (ii < 10)
+			label = tostr(ii) + ". " + label + '|' + tostr(ii);
+		tomenu.add(MenuItem(MenuItem::Command, label, action));
+	}
+}
+
+
+void expandFormats(MenuItem::Kind kind, Menu & tomenu, Buffer const * buf)
+{
+	if (!buf && kind != MenuItem::ImportFormats) {
+		tomenu.add(MenuItem(MenuItem::Command,
+				    _("No Documents Open!"), LFUN_NOACTION));
+		return;
+	}
+
+	typedef vector<Format const *> Formats;
+	Formats formats;
+	kb_action action;
+
+	switch (kind) {
+	case MenuItem::ImportFormats:
+		formats = Importer::GetImportableFormats();
+		action = LFUN_IMPORT;
+		break;
+	case MenuItem::ViewFormats:
+		formats = Exporter::GetExportableFormats(buf, true);
+		action = LFUN_PREVIEW;
+		break;
+	case MenuItem::UpdateFormats:
+		formats = Exporter::GetExportableFormats(buf, true);
+		action = LFUN_UPDATE;
+		break;
+	default:
+		formats = Exporter::GetExportableFormats(buf, false);
+		action = LFUN_EXPORT;
+	}
+	sort(formats.begin(), formats.end(), compare_format());
+
+	Formats::const_iterator fit = formats.begin();
+	Formats::const_iterator end = formats.end();
+	for (; fit != end ; ++fit) {
+		if ((*fit)->dummy())
+			continue;
+		string label = (*fit)->prettyname();
+		// we need to hide the default graphic export formats
+		// from the external menu, because we need them only
+		// for the internal lyx-view and external latex run
+		if (label == "EPS" || label == "XPM" || label == "PNG")
+			continue;
+
+		if (kind == MenuItem::ImportFormats) {
+			if ((*fit)->name() == "text")
+				label = _("ASCII text as lines");
+			else if ((*fit)->name() == "textparagraph")
+				label = _("ASCII text as paragraphs");
+			label += "...";
+		}
+		if (!(*fit)->shortcut().empty())
+			label += '|' + (*fit)->shortcut();
+		int const action2 = lyxaction.
+			getPseudoAction(action,	(*fit)->name());
+		tomenu.add(MenuItem(MenuItem::Command, label, action2));
+	}
+}
+
+
+void expandFloatListInsert(Menu & tomenu, Buffer const * buf)
+{
+	if (!buf) {
+		tomenu.add(MenuItem(MenuItem::Command,
+				    _("No Documents Open!"), LFUN_NOACTION));
+		return;
+	}
+
+	FloatList const & floats = buf->params.getLyXTextClass().floats();
+	FloatList::const_iterator cit = floats.begin();
+	FloatList::const_iterator end = floats.end();
+	for (; cit != end; ++cit) {
+		int const action =  lyxaction
+			.getPseudoAction(LFUN_FLOAT_LIST, cit->second.type());
+		tomenu.add(MenuItem(MenuItem::Command,
+				    _(cit->second.listName()),
+				    action));
+	}
+}
+
+
+void expandFloatInsert(Menu & tomenu, Buffer const * buf)
+{
+	if (!buf) {
+		tomenu.add(MenuItem(MenuItem::Command,
+				    _("No Documents Open!"), LFUN_NOACTION));
+		return;
+	}
+
+	FloatList const & floats = buf->params.getLyXTextClass().floats();
+	FloatList::const_iterator cit = floats.begin();
+	FloatList::const_iterator end = floats.end();
+	for (; cit != end; ++cit) {
+		// normal float
+		int const action =
+			lyxaction.getPseudoAction(LFUN_INSET_FLOAT,
+						  cit->second.type());
+		string const label = _(cit->second.name());
+		tomenu.add(MenuItem(MenuItem::Command, label, action));
+	}
+}
+
+
+Menu::size_type const max_number_of_items = 25;
+
+void expandToc2(Menu & tomenu, toc::Toc const & toc_list,
+		toc::Toc::size_type from, toc::Toc::size_type to, int depth)
+{
+	int shortcut_count = 0;
+	if (to - from <= max_number_of_items) {
+		for (toc::Toc::size_type i = from; i < to; ++i) {
+			int const action = toc_list[i].action();
+			string label(4 * max(0, toc_list[i].depth - depth),' ');
+			label += limit_string_length(toc_list[i].str);
+			if (toc_list[i].depth == depth
+			    && ++shortcut_count <= 9) {
+				label += '|' + tostr(shortcut_count);
+			}
+			tomenu.add(MenuItem(MenuItem::Command, label, action));
+		}
+	} else {
+		toc::Toc::size_type pos = from;
+		while (pos < to) {
+			toc::Toc::size_type new_pos = pos + 1;
+			while (new_pos < to &&
+			       toc_list[new_pos].depth > depth)
+				++new_pos;
+
+			int const action = toc_list[pos].action();
+			string label(4 * max(0, toc_list[pos].depth - depth), ' ');
+			label += limit_string_length(toc_list[pos].str);
+			if (toc_list[pos].depth == depth &&
+			    ++shortcut_count <= 9)
+				label += '|' + tostr(shortcut_count);
+
+			if (new_pos == pos + 1) {
+				tomenu.add(MenuItem(MenuItem::Command,
+						    label, action));
+			} else {
+				MenuItem item(MenuItem::Submenu, label);
+				item.submenu(new Menu);
+				expandToc2(*item.submenu(),
+					   toc_list, pos, new_pos, depth + 1);
+				tomenu.add(item);
+			}
+			pos = new_pos;
+		}
+	}
+}
+
+
+void expandToc(Menu & tomenu, Buffer const * buf)
+{
+	if (!buf) {
+		tomenu.add(MenuItem(MenuItem::Command,
+				    _("No Documents Open!"), LFUN_NOACTION));
+		return;
+	}
+
+	toc::TocList toc_list = toc::getTocList(buf);
+	toc::TocList::const_iterator cit = toc_list.begin();
+	toc::TocList::const_iterator end = toc_list.end();
+	for (; cit != end; ++cit) {
+		// Handle this later
+		if (cit->first == "TOC")
+			continue;
+
+		// All the rest is for floats
+		Menu * menu = new Menu;
+		toc::Toc::const_iterator ccit = cit->second.begin();
+		toc::Toc::const_iterator eend = cit->second.end();
+		for (; ccit != eend; ++ccit) {
+			string const label = limit_string_length(ccit->str);
+			menu->add(MenuItem(MenuItem::Command,
+					   label, ccit->action()));
+		}
+		string const & floatName = cit->first;
+		// Is the _(...) really needed here? (Lgb)
+		MenuItem item(MenuItem::Submenu, _(floatName));
+		item.submenu(menu);
+		tomenu.add(item);
+	}
+
+	// Handle normal TOC
+	cit = toc_list.find("TOC");
+	if (cit == end) {
+		tomenu.add(MenuItem(MenuItem::Command,
+				    _("No Table of contents")));
+	} else {
+		expandToc2(tomenu, cit->second, 0, cit->second.size(), 0);
+	}
+}
+
+
+} // namespace anon
+
+
+void MenuBackend::expand(Menu const & frommenu, Menu & tomenu,
+			 Buffer const * buf) const
+{
+	for (Menu::const_iterator cit = frommenu.begin();
+	     cit != frommenu.end() ; ++cit) {
+		switch (cit->kind()) {
+		case MenuItem::Lastfiles:
+			expandLastfiles(tomenu);
+			break;
+
+		case MenuItem::Documents:
+			expandDocuments(tomenu);
+			break;
+
+		case MenuItem::ImportFormats:
+		case MenuItem::ViewFormats:
+		case MenuItem::UpdateFormats:
+		case MenuItem::ExportFormats:
+			expandFormats(cit->kind(), tomenu, buf);
+			break;
+
+		case MenuItem::FloatListInsert:
+			expandFloatListInsert(tomenu, buf);
+			break;
+
+		case MenuItem::FloatInsert:
+			expandFloatInsert(tomenu, buf);
+			break;
+
+		case MenuItem::Toc:
+			expandToc(tomenu, buf);
+			break;
+
+		case MenuItem::Submenu: {
+			MenuItem item(*cit);
+			item.submenu(new Menu(cit->submenuname()));
+			expand(getMenu(cit->submenuname()),
+			       *item.submenu(), buf);
+			tomenu.add(item);
+		}
+		break;
+
+		default:
+			tomenu.add(*cit);
+		}
+	}
+
+	// Check whether the shortcuts are unique
+	if (lyxerr.debugging(Debug::GUI))
+		tomenu.checkShortcuts();
+}
+
+
+bool Menu::hasSubmenu(string const & name) const
+{
+	return find_if(begin(), end(),
+		       lyx::compare_memfun(&MenuItem::submenuname,
+					   name)) != end();
 }
 
 
@@ -153,9 +603,10 @@ void MenuBackend::read(LyXLex & lex)
 	};
 
 	//consistency check
-	if (compare_no_case(lex.GetString(), "menuset"))
+	if (compare_ascii_no_case(lex.getString(), "menuset")) {
 		lyxerr << "Menubackend::read: ERROR wrong token:`"
-		       << lex.GetString() << '\'' << endl;
+		       << lex.getString() << '\'' << endl;
+	}
 
 	lex.pushTable(menutags, md_last - 1);
 	if (lyxerr.debugging(Debug::PARSER))
@@ -163,22 +614,21 @@ void MenuBackend::read(LyXLex & lex)
 
 	bool quit = false;
 
-	while (lex.IsOK() && !quit) {
-		switch(lex.lex()) {
-		case md_menu: {
-			lex.next();
-			string name = lex.GetString();
-			Menu menu(name, false);
-			menu.read(lex);
-			add(menu);
+	while (lex.isOK() && !quit) {
+		switch (lex.lex()) {
+		case md_menubar:
+			menubar_.read(lex);
 			break;
-		}
-		case md_menubar: {
-			lex.next();
-			string name = lex.GetString();
-			Menu menubar(name, true);
-			menubar.read(lex);
-			add(menubar);
+		case md_menu: {
+			lex.next(true);
+			string const name = lex.getString();
+			if (hasMenu(name)) {
+				getMenu(name).read(lex);
+			} else {
+				Menu menu(name);
+				menu.read(lex);
+				add(menu);
+			}
 			break;
 		}
 		case md_endmenuset:
@@ -198,15 +648,15 @@ void MenuBackend::defaults()
 {
 	menulist_.clear();
 
-	lyxerr[Debug::GUI] << "MenuBackend::defaults: using default values" 
+	lyxerr[Debug::GUI] << "MenuBackend::defaults: using default values"
 			   << endl;
 
 	Menu file("file");
 	file
-		.add(MenuItem(MenuItem::Command, "New...|N", "buffer-new"))
-		.add(MenuItem(MenuItem::Command, "Open...|O", "buffer-open"))
-		.add(MenuItem(MenuItem::Submenu, "Import|I", "import"))
-		.add(MenuItem(MenuItem::Command, "Quit|Q", "lyx-quit"))
+		.add(MenuItem(MenuItem::Command, _("New...|N"), "buffer-new"))
+		.add(MenuItem(MenuItem::Command, _("Open...|O"), "file-open"))
+		.add(MenuItem(MenuItem::Submenu, _("Import|I"), "import"))
+		.add(MenuItem(MenuItem::Command, _("Quit|Q"), "lyx-quit"))
 		.add(MenuItem(MenuItem::Separator))
 		.add(MenuItem(MenuItem::Lastfiles));
 	add(file);
@@ -214,42 +664,28 @@ void MenuBackend::defaults()
 	Menu import("import");
 	import
 		.add(MenuItem(MenuItem::Command,
-			      "LaTeX...|L", "buffer-import latex"))
+			      _("LaTeX...|L"), "buffer-import latex"))
 		.add(MenuItem(MenuItem::Command,
-			      "LinuxDoc...|L", "buffer-import linuxdoc"));
+			      _("LinuxDoc...|L"), "buffer-import linuxdoc"));
 	add(import);
- 
+
 	Menu edit("edit");
 	edit
-		.add(MenuItem(MenuItem::Command, "Cut", "cut"))
-		.add(MenuItem(MenuItem::Command, "Copy", "copy"))
-		.add(MenuItem(MenuItem::Command, "Paste", "paste"))
-		.add(MenuItem(MenuItem::Command, "Emphasize", "font-emph"));
+		.add(MenuItem(MenuItem::Command, _("Cut"), "cut"))
+		.add(MenuItem(MenuItem::Command, _("Copy"), "copy"))
+		.add(MenuItem(MenuItem::Command, _("Paste"), "paste"))
+		.add(MenuItem(MenuItem::Command, _("Emphasize"), "font-emph"));
 	add(edit);
 
 	Menu documents("documents");
 	documents.add(MenuItem(MenuItem::Documents));
 	add(documents);
 
-	Menu main("main", true);
-	main
-		.add(MenuItem(MenuItem::Submenu, "File|F", "file"))
-		.add(MenuItem(MenuItem::Submenu, "Edit|E", "edit"))
-		.add(MenuItem(MenuItem::Submenu, 
-			      "Documents|D", "documents"));
-	add(main);
-
-	Menu main_nobuffer("main_nobuffer", true);
-	main_nobuffer.add(MenuItem(MenuItem::Submenu, "File|F", "file"));
-	add(main_nobuffer);
-
-	if (lyxerr.debugging(Debug::GUI)) {
-		for(const_iterator cit = begin();
-		    cit != end() ; ++cit)
-			lyxerr << "Menu name: " << cit->name() 
-			       << ", Menubar: " << cit->menubar() 
-			       << endl;
-	}
+	menubar_.add(MenuItem(MenuItem::Submenu, _("File|F"), "file"))
+		.add(MenuItem(MenuItem::Submenu, _("Edit|E"), "edit"))
+		.add(MenuItem(MenuItem::Submenu,
+			      _("Documents|D"), "documents"));
+
 }
 
 
@@ -261,20 +697,33 @@ void MenuBackend::add(Menu const & menu)
 
 bool MenuBackend::hasMenu(string const & name) const
 {
-	for (const_iterator cit = begin(); cit != end(); ++cit) {
-		if ((*cit).name() == name)
-			return true;
-	}
-	return false;
+	return find_if(begin(), end(),
+		       lyx::compare_memfun(&Menu::name, name)) != end();
 }
 
 
 Menu const & MenuBackend::getMenu(string const & name) const
 {
-	for (const_iterator cit = begin(); cit != end(); ++cit) {
-		if ((*cit).name() == name)
-			return (*cit);
-	}
-	Assert(false); // we actually require the name to exist.
-	return menulist_.front();
+	const_iterator cit = find_if(begin(), end(),
+				     lyx::compare_memfun(&Menu::name, name));
+	if (cit == end())
+		lyxerr << "No submenu named " << name << endl;
+	lyx::Assert(cit != end());
+	return (*cit);
+}
+
+
+Menu & MenuBackend::getMenu(string const & name)
+{
+	MenuList::iterator it =
+		find_if(menulist_.begin(), menulist_.end(),
+			lyx::compare_memfun(&Menu::name, name));
+	lyx::Assert(it != menulist_.end());
+	return (*it);
+}
+
+
+Menu const & MenuBackend::getMenubar() const
+{
+	return menubar_;
 }