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

diff --git a/src/MenuBackend.C b/src/MenuBackend.C
index 18d39b90b8..2488f26df2 100644
--- a/src/MenuBackend.C
+++ b/src/MenuBackend.C
@@ -1,39 +1,45 @@
 /* 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 <memory>
-#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 LastFiles * lastfiles; 
 extern BufferList bufferlist;
 
 using std::endl;
 using std::vector;
+using std::max;
 using std::pair;
 using std::find_if;
 using std::sort;
@@ -42,8 +48,8 @@ using std::sort;
 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) {
@@ -51,29 +57,59 @@ MenuItem::MenuItem(Kind kind, string const & label,
 	case Documents:
 	case Lastfiles:
 	case Toc:
-	case References:
 	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);
@@ -88,14 +124,16 @@ Menu & Menu::read(LyXLex & lex)
 		md_documents,
 		md_endmenu,
 		md_exportformats,
+		md_importformats,
 		md_lastfiles,
 		md_optitem,
-		md_references,
 		md_separator,
 		md_submenu,
 		md_toc,
 		md_updateformats,
 		md_viewformats,
+		md_floatlistinsert,
+		md_floatinsert,
 		md_last
 	};
 
@@ -103,10 +141,12 @@ Menu & Menu::read(LyXLex & lex)
 		{ "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 }, 
-		{ "references", md_references },
+		{ "optitem", md_optitem },
 		{ "separator", md_separator },
 		{ "submenu", md_submenu },
 		{ "toc", md_toc },
@@ -121,17 +161,17 @@ Menu & Menu::read(LyXLex & lex)
 	bool quit = false;
 	bool optional = false;
 
-	while (lex.IsOK() && !quit) {
+	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 const 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;
@@ -153,10 +193,6 @@ Menu & Menu::read(LyXLex & lex)
 			add(MenuItem(MenuItem::Toc));
 			break;
 
-		case md_references:
-			add(MenuItem(MenuItem::References));
-			break;
-
 		case md_viewformats:
 			add(MenuItem(MenuItem::ViewFormats));
 			break;
@@ -169,11 +205,23 @@ Menu & Menu::read(LyXLex & lex)
 			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;
 		}
@@ -183,7 +231,7 @@ Menu & Menu::read(LyXLex & lex)
 			break;
 
 		default:
-			lex.printError("menubar::read: "
+			lex.printError("Menu::read: "
 				       "Unknown menu tag: `$$Token'");
 			break;
 		}
@@ -192,11 +240,6 @@ Menu & Menu::read(LyXLex & lex)
 	return *this;
 }
 
-struct compare_formatpair {
-	bool operator()(FormatPair const & a, FormatPair const & b) {
-		return a.format->prettyname < b.format->prettyname; 
-	}
-};
 
 void Menu::checkShortcuts() const
 {
@@ -212,7 +255,7 @@ void Menu::checkShortcuts() const
 			       << "\" does not contain shortcut `"
 			       << shortcut << '\'' << endl;
 		for (const_iterator it2 = begin(); it2 != it1 ; ++it2) {
-			if (!compare_no_case(it2->shortcut(), shortcut)) {
+			if (!compare_ascii_no_case(it2->shortcut(), shortcut)) {
 				lyxerr << "Menu warning: menu entries "
 				       << '"' << it1->fulllabel()
 				       << "\" and \"" << it2->fulllabel()
@@ -223,95 +266,308 @@ void Menu::checkShortcuts() const
 	}
 }
 
-void Menu::expand(Menu & tomenu, Buffer * buf) const
+
+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)
 {
-	for (const_iterator cit = begin();
-	     cit != end() ; ++cit) {
-		switch ((*cit).kind()) {
-		case MenuItem::Lastfiles: {
-			int ii = 1;
-			for (LastFiles::const_iterator lfit = lastfiles->begin();
-			     lfit != lastfiles->end() && ii < 10;
-			     ++lfit, ++ii) {
-				string label = tostr(ii) + ". "
-					+ MakeDisplayPath((*lfit), 30)
-					+ '|' + tostr(ii);
-				int action = lyxaction.
-					getPseudoAction(LFUN_FILE_OPEN,
-							(*lfit));
-				tomenu.add(MenuItem(MenuItem::Command,
-						    label, action));
-			}
-		}
+	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::Documents: {
-			vector<string> names = bufferlist.getFileNames();
-			
-			if (names.empty()) {
-				tomenu.add(MenuItem(MenuItem::Command,
-						    _("No Documents Open!"),
-						    LFUN_NOACTION));
-				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;
 
-			for (vector<string>::const_iterator docit = names.begin();
-			     docit != names.end() ; ++docit) {
-				int action =
-					lyxaction.getPseudoAction(LFUN_SWITCHBUFFER, *docit);
-				string label = MakeDisplayPath(*docit, 30);
+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;
 		}
-		break;
+	}
+}
+
+
+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: {
-			vector<FormatPair> names;
-			kb_action action;
-			if ((*cit).kind() == MenuItem::ViewFormats) {
-				names = Exporter::GetViewableFormats(buf);
-				action = LFUN_PREVIEW;
-			} else if ((*cit).kind() == MenuItem::UpdateFormats) {
-				names = Exporter::GetViewableFormats(buf);
-				action = LFUN_UPDATE;
-			} else {
-				names = Exporter::GetExportableFormats(buf);
-				action = LFUN_EXPORT;
-			}
-			sort(names.begin(), names.end(), compare_formatpair());
-
-			for (vector<FormatPair>::const_iterator fit = names.begin();
-			     fit != names.end() ; ++fit) {
-				string fmt = (*fit).format->name;
-				string label = (*fit).format->prettyname;
-				bool same_before = 
-					fit != names.begin() &&
-					(*fit).format == (*(fit-1)).format;
-				bool same_after = 
-					fit+1 != names.end() &&
-					(*fit).format == (*(fit+1)).format;
-				if ((*fit).from &&
-				    (same_before || same_after)) {
-					fmt += ":" + (*fit).from->name;
-					string head;
-					split((*fit).command, head, ' ');
-					label += _(" (using ") + head + ")";
-					if (!(*fit).format->shortcut.empty() &&
-					    !same_before)
-						label += "|" + (*fit).format->shortcut;
-				} else if (!(*fit).format->shortcut.empty())
-					label += "|" + (*fit).format->shortcut;
-				int action2 = lyxaction.getPseudoAction(action, fmt);
-				tomenu.add(MenuItem(MenuItem::Command,
-						    label, action2));
-			}
+		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);
 		}
@@ -319,7 +575,15 @@ void Menu::expand(Menu & tomenu, Buffer * buf) const
 
 	// Check whether the shortcuts are unique
 	if (lyxerr.debugging(Debug::GUI))
-		checkShortcuts();
+		tomenu.checkShortcuts();
+}
+
+
+bool Menu::hasSubmenu(string const & name) const
+{
+	return find_if(begin(), end(),
+		       lyx::compare_memfun(&MenuItem::submenuname,
+					   name)) != end();
 }
 
 
@@ -339,38 +603,32 @@ 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))
 		lex.printTable(lyxerr);
 
 	bool quit = false;
-	bool menubar = false;
 
-	while (lex.IsOK() && !quit) {
+	while (lex.isOK() && !quit) {
 		switch (lex.lex()) {
-		case md_menubar: 
-			menubar = true;
-			// fallback to md_menu
+		case md_menubar:
+			menubar_.read(lex);
+			break;
 		case md_menu: {
-			lex.next();
-			string name = lex.GetString();
+			lex.next(true);
+			string const name = lex.getString();
 			if (hasMenu(name)) {
-				if (getMenu(name).menubar() == menubar) {
-					getMenu(name).read(lex);
-				} else {
-					lex.printError("Cannot append to menu `$$Token' unless it is of the same type");
-					return;
-				}
-			} else {				
-				Menu menu(name, menubar);
+				getMenu(name).read(lex);
+			} else {
+				Menu menu(name);
 				menu.read(lex);
 				add(menu);
 			}
-			menubar = false;
 			break;
 		}
 		case md_endmenuset:
@@ -390,13 +648,13 @@ 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::Command, _("Open...|O"), "file-open"))
 		.add(MenuItem(MenuItem::Submenu, _("Import|I"), "import"))
 		.add(MenuItem(MenuItem::Command, _("Quit|Q"), "lyx-quit"))
 		.add(MenuItem(MenuItem::Separator))
@@ -410,7 +668,7 @@ void MenuBackend::defaults()
 		.add(MenuItem(MenuItem::Command,
 			      _("LinuxDoc...|L"), "buffer-import linuxdoc"));
 	add(import);
- 
+
 	Menu edit("edit");
 	edit
 		.add(MenuItem(MenuItem::Command, _("Cut"), "cut"))
@@ -423,25 +681,11 @@ void MenuBackend::defaults()
 	documents.add(MenuItem(MenuItem::Documents));
 	add(documents);
 
-	Menu main("main", true);
-	main
-		.add(MenuItem(MenuItem::Submenu, _("File|F"), "file"))
+	menubar_.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;
-	}
+
 }
 
 
@@ -454,23 +698,32 @@ void MenuBackend::add(Menu const & menu)
 bool MenuBackend::hasMenu(string const & name) const
 {
 	return find_if(begin(), end(),
-		       compare_memfun(&Menu::name, name)) != end();
+		       lyx::compare_memfun(&Menu::name, name)) != end();
 }
 
 
 Menu const & MenuBackend::getMenu(string const & name) const
 {
 	const_iterator cit = find_if(begin(), end(),
-				     compare_memfun(&Menu::name, name));
-	Assert(cit != 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(),
-					compare_memfun(&Menu::name, name));
-	Assert(it != menulist_.end());
+	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_;
+}