X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FMenuBackend.C;h=5944a2264f9631015bed901e9bc62fdea5a31d53;hb=35204f8f33d7400a5fefeffea533fb4cb4097211;hp=812e1f3fadf22a156b8304f19e3bf3deb0f194f7;hpb=1e5bcef101e1d0735122bde3f271a2c69fc0adb7;p=lyx.git diff --git a/src/MenuBackend.C b/src/MenuBackend.C index 812e1f3fad..5944a2264f 100644 --- a/src/MenuBackend.C +++ b/src/MenuBackend.C @@ -1,94 +1,158 @@ -/* This file is part of - * ====================================================== +/** + * \file MenuBackend.C + * This file is part of LyX, the document processor. + * Licence details can be found in the file COPYING. * - * LyX, The Document Processor + * \author Asger Alstrup + * \author Lars Gullik Bjønnes + * \author Jean-Marc Lasgouttes + * \author André Pönitz + * \author Dekel Tsur + * \author Martin Vermeer * - * Copyright 1995 Matthias Ettrich - * Copyright 1995-2001 The LyX Team. - * - * - * ====================================================== */ + * Full author contact details are available in file CREDITS. + */ #include -#ifdef __GNUG__ -#pragma implementation -#endif - -#include #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 "BranchList.h" +#include "buffer.h" #include "bufferlist.h" -#include "converter.h" +#include "bufferparams.h" +#include "CutAndPaste.h" +#include "debug.h" #include "exporter.h" -#include "importer.h" +#include "Floating.h" #include "FloatList.h" -#include "support/LAssert.h" +#include "format.h" +#include "gettext.h" +#include "importer.h" +#include "kbmap.h" +#include "session.h" +#include "LyXAction.h" +#include "lyx_main.h" // for lastfiles +#include "lyxfunc.h" +#include "lyxlex.h" +#include "paragraph.h" +#include "TocBackend.h" +#include "ToolbarBackend.h" + #include "support/filetools.h" -#include "support/lyxfunctional.h" #include "support/lstrings.h" +#include "support/convert.h" + +#include + +#include + + +namespace lyx { + +using support::compare_no_case; +using support::compare_ascii_no_case; +using support::contains; +using support::makeDisplayPath; +using support::token; +using support::uppercase; -extern LyXAction lyxaction; -extern BufferList bufferlist; +using boost::bind; +using std::auto_ptr; using std::endl; -using std::vector; -using std::pair; +using std::equal_to; using std::find_if; +using std::max; using std::sort; +using std::string; +using std::vector; + + +namespace { + +class MenuNamesEqual : public std::unary_function { +public: + MenuNamesEqual(docstring const & name) + : name_(name) {} + bool operator()(Menu const & menu) const + { + return menu.name() == name_; + } +private: + docstring name_; +}; + +} // namespace anon + // This is the global menu definition MenuBackend menubackend; -MenuItem::MenuItem(Kind kind, string const & label, - string const & command, bool optional) - : kind_(kind), label_(label), optional_(optional) +MenuItem::MenuItem(Kind kind) + : kind_(kind), optional_(false) +{} + + +MenuItem::MenuItem(Kind kind, docstring const & label, + docstring const & submenu, bool optional) + : kind_(kind), label_(label), + submenuname_(submenu), optional_(optional) { - 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); + BOOST_ASSERT(kind == Submenu); +} - if (action_ == LFUN_UNKNOWN_ACTION) { - lyxerr << "MenuItem(): LyX command `" - << command << "' does not exist." << endl; - } - if (optional_) - lyxerr[Debug::GUI] << "Optional item " - << command << endl; - break; - case Submenu: - submenu_ = command; - break; - } + +MenuItem::MenuItem(Kind kind, docstring const & label, + FuncRequest const & func, bool optional) + : kind_(kind), label_(label), func_(func), optional_(optional) +{ + func_.origin = FuncRequest::MENU; } -string const MenuItem::label() const +MenuItem::~MenuItem() +{} + + +void MenuItem::submenu(Menu * menu) +{ + submenu_.reset(menu); +} + + +docstring const MenuItem::label() const { - return token(label_, '|', 0); + return token(label_, char_type('|'), 0); } -string const MenuItem::shortcut() const +docstring const MenuItem::shortcut() const { - return token(label_, '|', 1); + return token(label_, char_type('|'), 1); +} + + +docstring const MenuItem::binding() const +{ + if (kind_ != Command) + return docstring(); + + // Get the keys bound to this action, but keep only the + // first one later + kb_keymap::Bindings bindings = theTopLevelKeymap().findbindings(func_); + + if (bindings.size()) { + return from_utf8(bindings.begin()->print()); + } else { + lyxerr[Debug::KBMAP] + << "No binding for " + << lyxaction.getActionName(func_.action) + << '(' << to_utf8(func_.argument()) << ')' << endl; + return docstring(); + } + } @@ -99,16 +163,69 @@ Menu & Menu::add(MenuItem const & i) } +Menu & Menu::addWithStatusCheck(MenuItem const & i) +{ + switch (i.kind()) { + + case MenuItem::Command: { + FuncStatus status = lyx::getStatus(i.func()); + if (status.unknown() || (!status.enabled() && i.optional())) + break; + items_.push_back(i); + items_.back().status(status); + break; + } + + case MenuItem::Submenu: { + if (i.submenu()) { + bool enabled = false; + for (const_iterator cit = i.submenu()->begin(); + cit != i.submenu()->end(); ++cit) { + if ((cit->kind() == MenuItem::Command + || cit->kind() == MenuItem::Submenu) + && cit->status().enabled()) { + enabled = true; + break; + } + } + if (enabled || !i.optional()) { + items_.push_back(i); + items_.back().status().enabled(enabled); + } + } + else + items_.push_back(i); + break; + } + + case MenuItem::Separator: + if (!items_.empty() + && items_.back().kind() != MenuItem::Separator) + items_.push_back(i); + break; + + default: + items_.push_back(i); + } + + return *this; +} + + Menu & Menu::read(LyXLex & lex) { enum Menutags { md_item = 1, + md_branches, md_documents, + md_bookmarks, + md_charstyles, md_endmenu, md_exportformats, md_importformats, md_lastfiles, md_optitem, + md_optsubmenu, md_separator, md_submenu, md_toc, @@ -116,10 +233,15 @@ Menu & Menu::read(LyXLex & lex) md_viewformats, md_floatlistinsert, md_floatinsert, + md_pasterecent, + md_toolbars, md_last }; struct keyword_item menutags[md_last - 1] = { + { "bookmarks", md_bookmarks }, + { "branches", md_branches }, + { "charstyles", md_charstyles }, { "documents", md_documents }, { "end", md_endmenu }, { "exportformats", md_exportformats }, @@ -129,9 +251,12 @@ Menu & Menu::read(LyXLex & lex) { "item", md_item }, { "lastfiles", md_lastfiles }, { "optitem", md_optitem }, + { "optsubmenu", md_optsubmenu }, + { "pasterecent", md_pasterecent }, { "separator", md_separator }, { "submenu", md_submenu }, { "toc", md_toc }, + { "toolbars", md_toolbars }, { "updateformats", md_updateformats }, { "viewformats", md_viewformats } }; @@ -150,11 +275,11 @@ Menu & Menu::read(LyXLex & lex) // fallback to md_item case md_item: { lex.next(true); - string const name = _(lex.getString()); + docstring const name = _(lex.getString()); lex.next(true); string const command = lex.getString(); - add(MenuItem(MenuItem::Command, name, - command, optional)); + FuncRequest func = lyxaction.lookupFunc(command); + add(MenuItem(MenuItem::Command, name, func, optional)); optional = false; break; } @@ -167,10 +292,18 @@ Menu & Menu::read(LyXLex & lex) add(MenuItem(MenuItem::Lastfiles)); break; + case md_charstyles: + add(MenuItem(MenuItem::CharStyles)); + break; + case md_documents: add(MenuItem(MenuItem::Documents)); break; + case md_bookmarks: + add(MenuItem(MenuItem::Bookmarks)); + break; + case md_toc: add(MenuItem(MenuItem::Toc)); break; @@ -199,12 +332,29 @@ Menu & Menu::read(LyXLex & lex) add(MenuItem(MenuItem::FloatInsert)); break; + case md_pasterecent: + add(MenuItem(MenuItem::PasteRecent)); + break; + + case md_toolbars: + add(MenuItem(MenuItem::Toolbars)); + break; + + case md_branches: + add(MenuItem(MenuItem::Branches)); + break; + + case md_optsubmenu: + optional = true; + // fallback to md_submenu case md_submenu: { lex.next(true); - string const mlabel = _(lex.getString()); + docstring const mlabel = _(lex.getString()); lex.next(true); - string const mname = lex.getString(); - add(MenuItem(MenuItem::Submenu, mlabel, mname)); + docstring const mname = from_utf8(lex.getString()); + add(MenuItem(MenuItem::Submenu, mlabel, mname, + optional)); + optional = false; break; } @@ -223,24 +373,38 @@ Menu & Menu::read(LyXLex & lex) } +MenuItem const & Menu::operator[](size_type i) const +{ + return items_[i]; +} + + +bool Menu::hasFunc(FuncRequest const & func) const +{ + return find_if(begin(), end(), + bind(std::equal_to(), + bind(&MenuItem::func, _1), + func)) != end(); +} + void Menu::checkShortcuts() const { // This is a quadratic algorithm, but we do not care because - // it is used for debugging only. + // menus are short enough for (const_iterator it1 = begin(); it1 != end(); ++it1) { - string shortcut = it1->shortcut(); + docstring shortcut = it1->shortcut(); if (shortcut.empty()) continue; if (!contains(it1->label(), shortcut)) lyxerr << "Menu warning: menu entry \"" - << it1->label() + << to_utf8(it1->label()) << "\" does not contain shortcut `" - << shortcut << '\'' << endl; + << to_utf8(shortcut) << "'." << endl; for (const_iterator it2 = begin(); it2 != it1 ; ++it2) { - if (!compare_ascii_no_case(it2->shortcut(), shortcut)) { + if (!compare_no_case(it2->shortcut(), shortcut)) { lyxerr << "Menu warning: menu entries " - << '"' << it1->fulllabel() - << "\" and \"" << it2->fulllabel() + << '"' << to_utf8(it1->fulllabel()) + << "\" and \"" << to_utf8(it2->fulllabel()) << "\" share the same shortcut." << endl; } @@ -249,6 +413,13 @@ void Menu::checkShortcuts() const } +void MenuBackend::specialMenu(docstring const &name) +{ + if (hasMenu(name)) + specialmenu_ = &getMenu(name); +} + + namespace { class compare_format { @@ -258,45 +429,68 @@ public: } }; +docstring const limit_string_length(docstring const & str) +{ + docstring::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) { + lyx::LastFilesSection::LastFiles const & lf = LyX::cref().session().lastFiles().lastFiles(); + lyx::LastFilesSection::LastFiles::const_iterator lfit = lf.begin(); + 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)); + + for (; lfit != lf.end() && ii < 10; ++lfit, ++ii) { + docstring const label = convert(ii) + ". " + + makeDisplayPath((*lfit), 30) + + char_type('|') + convert(ii); + tomenu.add(MenuItem(MenuItem::Command, label, FuncRequest(LFUN_FILE_OPEN, (*lfit)))); } } + void expandDocuments(Menu & tomenu) { typedef vector Strings; - Strings const names = bufferlist.getFileNames(); + Strings const names = theBufferList().getFileNames(); if (names.empty()) { tomenu.add(MenuItem(MenuItem::Command, _("No Documents Open!"), - LFUN_NOACTION)); + FuncRequest(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); + docstring label = makeDisplayPath(*docit, 20); if (ii < 10) - label = tostr(ii) + ". " + label + '|' + tostr(ii); - tomenu.add(MenuItem(MenuItem::Command, label, action)); + label = convert(ii) + ". " + label + char_type('|') + convert(ii); + tomenu.add(MenuItem(MenuItem::Command, label, FuncRequest(LFUN_BUFFER_SWITCH, *docit))); + } +} + + +void expandBookmarks(Menu & tomenu) +{ + lyx::BookmarksSection const & bm = LyX::cref().session().bookmarks(); + + for (size_t i = 1; i <= bm.size(); ++i) { + if (bm.isValid(i)) { + docstring const label = convert(i) + ". " + + makeDisplayPath(bm.bookmark(i).filename, 20) + + char_type('|') + convert(i); + tomenu.add(MenuItem(MenuItem::Command, label, FuncRequest(LFUN_BOOKMARK_GOTO, + convert(i)))); + } } } @@ -305,30 +499,31 @@ 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)); + _("No Documents Open!"), + FuncRequest(LFUN_NOACTION))); return; - } - + } + typedef vector Formats; Formats formats; kb_action action; - + switch (kind) { case MenuItem::ImportFormats: formats = Importer::GetImportableFormats(); - action = LFUN_IMPORT; + action = LFUN_BUFFER_IMPORT; break; case MenuItem::ViewFormats: - formats = Exporter::GetExportableFormats(buf, true); - action = LFUN_PREVIEW; + formats = Exporter::getExportableFormats(*buf, true); + action = LFUN_BUFFER_VIEW; break; case MenuItem::UpdateFormats: - formats = Exporter::GetExportableFormats(buf, true); - action = LFUN_UPDATE; + formats = Exporter::getExportableFormats(*buf, true); + action = LFUN_BUFFER_UPDATE; break; default: - formats = Exporter::GetExportableFormats(buf, false); - action = LFUN_EXPORT; + formats = Exporter::getExportableFormats(*buf, false); + action = LFUN_BUFFER_EXPORT; } sort(formats.begin(), formats.end(), compare_format()); @@ -337,69 +532,303 @@ void expandFormats(MenuItem::Kind kind, Menu & tomenu, Buffer const * buf) 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; + docstring label = from_utf8((*fit)->prettyname()); - if (kind == MenuItem::ImportFormats) + switch (kind) { + case MenuItem::ImportFormats: if ((*fit)->name() == "text") - label = _("Ascii text as lines"); + label = _("Plain Text as Lines"); else if ((*fit)->name() == "textparagraph") - label = _("Ascii text as paragraphs"); + label = _("Plain Text as Paragraphs"); + label += "..."; + break; + case MenuItem::ViewFormats: + case MenuItem::ExportFormats: + case MenuItem::UpdateFormats: + if (!(*fit)->documentFormat()) + continue; + break; + default: + BOOST_ASSERT(false); + break; + } if (!(*fit)->shortcut().empty()) - label += "|" + (*fit)->shortcut(); - int const action2 = lyxaction. - getPseudoAction(action, (*fit)->name()); - tomenu.add(MenuItem(MenuItem::Command, label, action2)); + label += char_type('|') + from_utf8((*fit)->shortcut()); + + if (buf) + tomenu.addWithStatusCheck(MenuItem(MenuItem::Command, label, + FuncRequest(action, (*fit)->name()))); + else + tomenu.add(MenuItem(MenuItem::Command, label, + FuncRequest(action, (*fit)->name()))); } } -void expandFloatListInsert(Menu & tomenu) + +void expandFloatListInsert(Menu & tomenu, Buffer const * buf) { - FloatList::const_iterator cit = floatList.begin(); - FloatList::const_iterator end = floatList.end(); - for (; cit != end; ++cit) { - int const action = lyxaction - .getPseudoAction(LFUN_FLOAT_LIST, cit->second.type()); + if (!buf) { tomenu.add(MenuItem(MenuItem::Command, + _("No Documents Open!"), + FuncRequest(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) { + tomenu.addWithStatusCheck(MenuItem(MenuItem::Command, _(cit->second.listName()), - action)); + FuncRequest(LFUN_FLOAT_LIST, + cit->second.type()))); } } -void expandFloatInsert(Menu & tomenu) + +void expandFloatInsert(Menu & tomenu, Buffer const * buf) { - FloatList::const_iterator cit = floatList.begin(); - FloatList::const_iterator end = floatList.end(); + if (!buf) { + tomenu.add(MenuItem(MenuItem::Command, + _("No Documents Open!"), + FuncRequest(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)); - - // and the wide version - int const action2 = - lyxaction.getPseudoAction(LFUN_INSET_WIDE_FLOAT, - cit->second.type()); - string const label2 = label + _(" (wide)"); - tomenu.add(MenuItem(MenuItem::Command, label2, action2)); + docstring const label = _(cit->second.name()); + tomenu.addWithStatusCheck(MenuItem(MenuItem::Command, label, + FuncRequest(LFUN_FLOAT_INSERT, + cit->second.type()))); + } +} + + +void expandCharStyleInsert(Menu & tomenu, Buffer const * buf) +{ + if (!buf) { + tomenu.add(MenuItem(MenuItem::Command, + _("No Documents Open!"), + FuncRequest(LFUN_NOACTION))); + return; + } + CharStyles & charstyles = + buf->params().getLyXTextClass().charstyles(); + CharStyles::iterator cit = charstyles.begin(); + CharStyles::iterator end = charstyles.end(); + for (; cit != end; ++cit) { + docstring const label = from_utf8(cit->name); + tomenu.addWithStatusCheck(MenuItem(MenuItem::Command, label, + FuncRequest(LFUN_CHARSTYLE_INSERT, + cit->name))); + } +} + + +Menu::size_type const max_number_of_items = 25; + +void expandToc2(Menu & tomenu, + Toc const & toc_list, + Toc::size_type from, + Toc::size_type to, int depth) +{ + int shortcut_count = 0; + + // check whether depth is smaller than the smallest depth in toc. + int min_depth = 1000; + for (Toc::size_type i = from; i < to; ++i) + min_depth = std::min(min_depth, toc_list[i].depth()); + if (min_depth > depth) + depth = min_depth; + + + if (to - from <= max_number_of_items) { + for (Toc::size_type i = from; i < to; ++i) { + docstring label(4 * max(0, toc_list[i].depth() - depth), char_type(' ')); + label += limit_string_length(toc_list[i].str()); + if (toc_list[i].depth() == depth + && shortcut_count < 9) { + if (label.find(convert(shortcut_count + 1)) != docstring::npos) + label += char_type('|') + convert(++shortcut_count); + } + tomenu.add(MenuItem(MenuItem::Command, label, + FuncRequest(toc_list[i].action()))); + } + } else { + Toc::size_type pos = from; + while (pos < to) { + Toc::size_type new_pos = pos + 1; + while (new_pos < to && + toc_list[new_pos].depth() > depth) + ++new_pos; + + docstring 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) { + if (label.find(convert(shortcut_count + 1)) != docstring::npos) + label += char_type('|') + convert(++shortcut_count); + } + if (new_pos == pos + 1) { + tomenu.add(MenuItem(MenuItem::Command, + label, FuncRequest(toc_list[pos].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) +{ + // To make things very cleanly, we would have to pass buf to + // all MenuItem constructors and to expandToc2. However, we + // know that all the entries in a TOC will be have status_ == + // OK, so we avoid this unnecessary overhead (JMarc) + + if (!buf) { + tomenu.add(MenuItem(MenuItem::Command, + _("No Documents Open!"), + FuncRequest(LFUN_NOACTION))); + return; + } + + // Add an entry for the master doc if this is a child doc + Buffer const * const master = buf->getMasterBuffer(); + if (buf != master) { + ParIterator const pit = par_iterator_begin(master->inset()); + string const arg = convert(pit->id()); + FuncRequest f(LFUN_PARAGRAPH_GOTO, arg); + tomenu.add(MenuItem(MenuItem::Command, _("Master Document"), f)); + } + + FloatList const & floatlist = buf->params().getLyXTextClass().floats(); + TocList const & toc_list = buf->tocBackend().tocs(); + TocList::const_iterator cit = toc_list.begin(); + TocList::const_iterator end = toc_list.end(); + for (; cit != end; ++cit) { + // Handle this later + if (cit->first == "tableofcontents") + continue; + + // All the rest is for floats + auto_ptr menu(new Menu); + TocIterator ccit = cit->second.begin(); + TocIterator eend = cit->second.end(); + for (; ccit != eend; ++ccit) { + docstring const label = limit_string_length(ccit->str()); + menu->add(MenuItem(MenuItem::Command, + label, + FuncRequest(ccit->action()))); + } + string const & floatName = floatlist.getType(cit->first).listName(); + MenuItem item(MenuItem::Submenu, _(floatName)); + item.submenu(menu.release()); + tomenu.add(item); + } + + // Handle normal TOC + cit = toc_list.find("tableofcontents"); + if (cit == end) { + tomenu.addWithStatusCheck(MenuItem(MenuItem::Command, + _("No Table of contents"), + FuncRequest())); + } else { + expandToc2(tomenu, cit->second, 0, cit->second.size(), 0); + } +} + + +void expandPasteRecent(Menu & tomenu, Buffer const * buf) +{ + if (!buf) + return; + + vector const sel = + cap::availableSelections(*buf); + + vector::const_iterator cit = sel.begin(); + vector::const_iterator end = sel.end(); + + for (unsigned int index = 0; cit != end; ++cit, ++index) { + tomenu.add(MenuItem(MenuItem::Command, *cit, + FuncRequest(LFUN_PASTE, convert(index)))); + } +} + + +void expandToolbars(Menu & tomenu) +{ + // + // extracts the toolbars from the backend + ToolbarBackend::Toolbars::const_iterator cit = toolbarbackend.begin(); + ToolbarBackend::Toolbars::const_iterator end = toolbarbackend.end(); + + for (; cit != end; ++cit) { + docstring label = _(cit->gui_name); + // frontends are not supposed to turn on/off toolbars, if they can not + // update ToolbarBackend::flags. That is to say, ToolbarsBackend::flags + // should reflect the true state of toolbars. + // + // menu is displayed as + // on/off review + // and + // review (auto) + // in the case of auto. + if (cit->flags & ToolbarBackend::AUTO) + label += _(" (auto)"); + tomenu.add(MenuItem(MenuItem::Command, label, + FuncRequest(LFUN_TOOLBAR_TOGGLE_STATE, cit->name))); } } + +void expandBranches(Menu & tomenu, Buffer const * buf) +{ + if (!buf) + return; + + BufferParams const & params = buf->getMasterBuffer()->params(); + + BranchList::const_iterator cit = params.branchlist().begin(); + BranchList::const_iterator end = params.branchlist().end(); + + for (int ii = 1; cit != end; ++cit, ++ii) { + docstring label = cit->getBranch(); + if (ii < 10) + label = convert(ii) + ". " + label + char_type('|') + convert(ii); + tomenu.addWithStatusCheck(MenuItem(MenuItem::Command, label, + FuncRequest(LFUN_BRANCH_INSERT, + cit->getBranch()))); + } +} + + } // namespace anon -void Menu::expand(Menu & tomenu, Buffer const * buf) const +void MenuBackend::expand(Menu const & frommenu, Menu & tomenu, + Buffer const * buf) const { - for (const_iterator cit = begin(); - cit != end() ; ++cit) { + if (!tomenu.empty()) + tomenu.clear(); + + for (Menu::const_iterator cit = frommenu.begin(); + cit != frommenu.end() ; ++cit) { switch (cit->kind()) { - case MenuItem::Lastfiles: + case MenuItem::Lastfiles: expandLastfiles(tomenu); break; @@ -407,6 +836,10 @@ void Menu::expand(Menu & tomenu, Buffer const * buf) const expandDocuments(tomenu); break; + case MenuItem::Bookmarks: + expandBookmarks(tomenu); + break; + case MenuItem::ImportFormats: case MenuItem::ViewFormats: case MenuItem::UpdateFormats: @@ -414,29 +847,61 @@ void Menu::expand(Menu & tomenu, Buffer const * buf) const expandFormats(cit->kind(), tomenu, buf); break; + case MenuItem::CharStyles: + expandCharStyleInsert(tomenu, buf); + break; + case MenuItem::FloatListInsert: - expandFloatListInsert(tomenu); + expandFloatListInsert(tomenu, buf); break; case MenuItem::FloatInsert: - expandFloatInsert(tomenu); + expandFloatInsert(tomenu, buf); break; - default: - tomenu.add(*cit); + case MenuItem::PasteRecent: + expandPasteRecent(tomenu, buf); + break; + + case MenuItem::Toolbars: + expandToolbars(tomenu); + break; + + case MenuItem::Branches: + expandBranches(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.addWithStatusCheck(item); } - } + break; - // Check whether the shortcuts are unique - if (lyxerr.debugging(Debug::GUI)) - checkShortcuts(); -} + case MenuItem::Separator: + tomenu.addWithStatusCheck(*cit); + break; + + case MenuItem::Command: + if (!specialmenu_ + || !specialmenu_->hasFunc(cit->func())) + tomenu.addWithStatusCheck(*cit); + } + } + // we do not want the menu to end with a separator + if (!tomenu.empty() + && tomenu.items_.back().kind() == MenuItem::Separator) + tomenu.items_.pop_back(); -bool Menu::hasSubmenu(string const & name) const -{ - return find_if(begin(), end(), - lyx::compare_memfun(&MenuItem::submenu, name)) != end(); + // Check whether the shortcuts are unique + tomenu.checkShortcuts(); } @@ -474,7 +939,7 @@ void MenuBackend::read(LyXLex & lex) break; case md_menu: { lex.next(true); - string const name = lex.getString(); + docstring const name = from_utf8(lex.getString()); if (hasMenu(name)) { getMenu(name).read(lex); } else { @@ -497,79 +962,34 @@ void MenuBackend::read(LyXLex & lex) } -void MenuBackend::defaults() -{ - menulist_.clear(); - - 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"), "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); - - Menu import("import"); - import - .add(MenuItem(MenuItem::Command, - _("LaTeX...|L"), "buffer-import latex")) - .add(MenuItem(MenuItem::Command, - _("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(edit); - - Menu documents("documents"); - documents.add(MenuItem(MenuItem::Documents)); - add(documents); - - menubar_.add(MenuItem(MenuItem::Submenu, _("File|F"), "file")) - .add(MenuItem(MenuItem::Submenu, _("Edit|E"), "edit")) - .add(MenuItem(MenuItem::Submenu, - _("Documents|D"), "documents")); - -} - - void MenuBackend::add(Menu const & menu) { menulist_.push_back(menu); } -bool MenuBackend::hasMenu(string const & name) const +bool MenuBackend::hasMenu(docstring const & name) const { - return find_if(begin(), end(), - lyx::compare_memfun(&Menu::name, name)) != end(); + return find_if(begin(), end(), MenuNamesEqual(name)) != end(); } -Menu const & MenuBackend::getMenu(string const & name) const +Menu const & MenuBackend::getMenu(docstring const & name) const { - const_iterator cit = find_if(begin(), end(), - lyx::compare_memfun(&Menu::name, name)); - lyx::Assert(cit != end()); + const_iterator cit = find_if(begin(), end(), MenuNamesEqual(name)); + if (cit == end()) + lyxerr << "No submenu named " << to_utf8(name) << endl; + BOOST_ASSERT(cit != end()); return (*cit); } -Menu & MenuBackend::getMenu(string const & name) +Menu & MenuBackend::getMenu(docstring const & name) { - MenuList::iterator it = - find_if(menulist_.begin(), menulist_.end(), - lyx::compare_memfun(&Menu::name, name)); - lyx::Assert(it != menulist_.end()); + iterator it = find_if(begin(), end(), MenuNamesEqual(name)); + if (it == end()) + lyxerr << "No submenu named " << to_utf8(name) << endl; + BOOST_ASSERT(it != end()); return (*it); } @@ -578,3 +998,6 @@ Menu const & MenuBackend::getMenubar() const { return menubar_; } + + +} // namespace lyx