*
* \author John Levon
* \author Asger Alstrup
- * \author Lars Gullik Bønnes
+ * \author Lars Gullik Bjønnes
* \author Jean-Marc Lasgouttes
* \author André Pönitz
* \author Dekel Tsur
#include "GuiView.h"
#include "qt_helpers.h"
+#include "BiblioInfo.h"
#include "BranchList.h"
#include "Buffer.h"
#include "BufferList.h"
#include "BufferParams.h"
+#include "BufferView.h"
#include "Converter.h"
#include "CutAndPaste.h"
#include "Floating.h"
#include "LyX.h" // for lastfiles
#include "LyXFunc.h"
#include "Paragraph.h"
+#include "ParIterator.h"
#include "Session.h"
#include "TextClass.h"
#include "TocBackend.h"
-#include "ToolbarBackend.h"
+#include "Toolbars.h"
+#include "insets/Inset.h"
+#include "insets/InsetCitation.h"
+#include "insets/InsetGraphics.h"
+
+#include "support/lassert.h"
#include "support/convert.h"
#include "support/debug.h"
+#include "support/docstring_list.h"
#include "support/filetools.h"
#include "support/gettext.h"
#include "support/lstrings.h"
#include <QCursor>
#include <QHash>
+#include <QList>
#include <QMenuBar>
#include <QString>
#include <boost/shared_ptr.hpp>
#include <algorithm>
-#include <ostream>
#include <vector>
using namespace std;
/** toolbars */
Toolbars,
/** Available branches in document */
- Branches
+ Branches,
+ /** Available citation styles for a given citation */
+ CiteStyles,
+ /** Available graphics groups */
+ GraphicsGroups
};
explicit MenuItem(Kind kind) : kind_(kind), optional_(false) {}
bool optional = false)
: kind_(kind), label_(label), submenuname_(submenu), optional_(optional)
{
- BOOST_ASSERT(kind == Submenu);
+ LASSERT(kind == Submenu, /**/);
}
MenuItem(Kind kind,
/// set the description of the submenu
void submenuname(QString const & name) { submenuname_ = name; }
///
- MenuDefinition * submenu() const { return submenu_.get(); }
+ bool hasSubmenu() const { return !submenu_.isEmpty(); }
+ ///
+ MenuDefinition const & submenu() const { return submenu_.at(0); }
+ MenuDefinition & submenu() { return submenu_[0]; }
///
- void setSubmenu(MenuDefinition * menu) { submenu_.reset(menu); }
+ void setSubmenu(MenuDefinition const & menu)
+ {
+ submenu_.clear();
+ submenu_.append(menu);
+ }
private:
///
bool optional_;
///
FuncStatus status_;
- ///
- boost::shared_ptr<MenuDefinition> submenu_;
+ /// contains 0 or 1 item.
+ QList<MenuDefinition> submenu_;
};
///
// search for func in this menu iteratively, and put menu
// names in a stack.
- bool searchMenu(FuncRequest const & func, std::vector<docstring> & names)
+ bool searchMenu(FuncRequest const & func, docstring_list & names)
const;
///
bool hasFunc(FuncRequest const &) const;
void expandPasteRecent();
void expandToolbars();
void expandBranches(Buffer const * buf);
+ void expandCiteStyles(BufferView const *);
+ void expandGraphicsGroups(BufferView const *);
///
ItemList items_;
///
}
case MenuItem::Submenu: {
- if (i.submenu()) {
+ if (i.hasSubmenu()) {
bool enabled = false;
- for (const_iterator cit = i.submenu()->begin();
- cit != i.submenu()->end(); ++cit) {
+ for (const_iterator cit = i.submenu().begin();
+ cit != i.submenu().end(); ++cit) {
if ((cit->kind() == MenuItem::Command
|| cit->kind() == MenuItem::Submenu)
&& cit->status().enabled()) {
}
if (enabled || !i.optional()) {
items_.push_back(i);
- items_.back().status().enabled(enabled);
+ items_.back().status().setEnabled(enabled);
}
}
else
void MenuDefinition::read(Lexer & lex)
{
- enum Menutags {
+ enum {
md_item = 1,
md_branches,
+ md_citestyles,
md_documents,
md_bookmarks,
md_charstyles,
md_floatinsert,
md_pasterecent,
md_toolbars,
- md_last
+ md_graphicsgroups
};
- struct keyword_item menutags[md_last - 1] = {
+ LexerKeyword menutags[] = {
{ "bookmarks", md_bookmarks },
{ "branches", md_branches },
{ "charstyles", md_charstyles },
+ { "citestyles", md_citestyles },
{ "custom", md_custom },
{ "documents", md_documents },
{ "elements", md_elements },
{ "exportformats", md_exportformats },
{ "floatinsert", md_floatinsert },
{ "floatlistinsert", md_floatlistinsert },
+ { "graphicsgroups", md_graphicsgroups },
{ "importformats", md_importformats },
{ "item", md_item },
{ "lastfiles", md_lastfiles },
{ "viewformats", md_viewformats }
};
- lex.pushTable(menutags, md_last - 1);
- if (lyxerr.debugging(Debug::PARSER))
- lex.printTable(lyxerr);
+ lex.pushTable(menutags);
+ lex.setContext("MenuDefinition::read: ");
bool quit = false;
bool optional = false;
add(MenuItem(MenuItem::Branches));
break;
+ case md_citestyles:
+ add(MenuItem(MenuItem::CiteStyles));
+ break;
+
+ case md_graphicsgroups:
+ add(MenuItem(MenuItem::GraphicsGroups));
+ break;
+
case md_optsubmenu:
optional = true;
// fallback to md_submenu
break;
default:
- lex.printError("MenuDefinition::read: "
- "Unknown menu tag: `$$Token'");
+ lex.printError("Unknown menu tag");
break;
}
}
if (shortcut.isEmpty())
continue;
if (!it1->label().contains(shortcut))
- lyxerr << "Menu warning: menu entry \""
- << fromqstr(it1->label())
+ LYXERR0("Menu warning: menu entry \""
+ << it1->label()
<< "\" does not contain shortcut `"
- << fromqstr(shortcut) << "'." << endl;
+ << shortcut << "'.");
for (const_iterator it2 = begin(); it2 != it1 ; ++it2) {
if (!it2->shortcut().compare(shortcut, Qt::CaseInsensitive)) {
- lyxerr << "Menu warning: menu entries "
- << '"' << fromqstr(it1->fulllabel())
- << "\" and \"" << fromqstr(it2->fulllabel())
- << "\" share the same shortcut."
- << endl;
+ LYXERR0("Menu warning: menu entries "
+ << '"' << it1->fulllabel()
+ << "\" and \"" << it2->fulllabel()
+ << "\" share the same shortcut.");
}
}
}
}
-bool MenuDefinition::searchMenu(FuncRequest const & func, vector<docstring> & names) const
+bool MenuDefinition::searchMenu(FuncRequest const & func, docstring_list & names) const
{
const_iterator m = begin();
const_iterator m_end = end();
}
if (m->kind() == MenuItem::Submenu) {
names.push_back(qstring_to_ucs4(m->label()));
- MenuDefinition const & submenu = *m->submenu();
- if (submenu.searchMenu(func, names))
+ if (!m->hasSubmenu()) {
+ LYXERR(Debug::GUI, "Warning: non existing sub menu label="
+ << m->label() << " name=" << m->submenuname());
+ names.pop_back();
+ continue;
+ }
+ if (m->submenu().searchMenu(func, names))
return true;
names.pop_back();
}
}
+void MenuDefinition::expandGraphicsGroups(BufferView const * bv)
+{
+ if (!bv)
+ return;
+ set<string> grp;
+ graphics::getGraphicsGroups(bv->buffer(), grp);
+ if (grp.empty())
+ return;
+
+ set<string>::const_iterator it = grp.begin();
+ set<string>::const_iterator end = grp.end();
+ add(MenuItem(MenuItem::Command, qt_("No Group"),
+ FuncRequest(LFUN_SET_GRAPHICS_GROUP)));
+ for (; it != end; it++) {
+ addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(*it),
+ FuncRequest(LFUN_SET_GRAPHICS_GROUP, *it)));
+ }
+}
+
void MenuDefinition::expandLastfiles()
{
LastFilesSection::LastFiles const & lf = LyX::cref().session().lastFiles().lastFiles();
typedef vector<Format const *> Formats;
Formats formats;
- kb_action action;
+ FuncCode action;
switch (kind) {
case MenuItem::ImportFormats:
for (; fit != end ; ++fit) {
if ((*fit)->dummy())
continue;
- QString label = toqstr((*fit)->prettyname());
- QString const shortcut = toqstr((*fit)->shortcut());
+
+ docstring lab = from_utf8((*fit)->prettyname());
+ docstring scut = from_utf8((*fit)->shortcut());
+ docstring const tmplab = lab;
+
+ if (!scut.empty())
+ lab += char_type('|') + scut;
+ docstring lab_i18n = translateIfPossible(lab);
+ bool const untranslated = (lab == lab_i18n);
+ QString const shortcut = toqstr(split(lab_i18n, lab, '|'));
+ QString label = toqstr(lab);
+ if (untranslated)
+ // this might happen if the shortcut
+ // has been redefined
+ label = toqstr(translateIfPossible(tmplab));
switch (kind) {
case MenuItem::ImportFormats:
- // FIXME: This is a hack, we should rather solve
- // FIXME: bug 2488 instead.
- if ((*fit)->name() == "text")
- label = qt_("Plain Text");
- else if ((*fit)->name() == "textparagraph")
- label = qt_("Plain Text, Join Lines");
label += "...";
break;
case MenuItem::ViewFormats:
continue;
break;
default:
- BOOST_ASSERT(false);
+ LASSERT(false, /**/);
break;
}
- // FIXME: if we had proper support for translating the
- // format names defined in configure.py, there would
- // not be a need to check whether the shortcut is
- // correct. If we add it uncondiitonally, it would
- // create useless warnings on bad shortcuts
- if (!shortcut.isEmpty() && label.contains(shortcut))
+ if (!shortcut.isEmpty())
label += '|' + shortcut;
if (buf)
for (; cit != end; ++cit) {
addWithStatusCheck(MenuItem(MenuItem::Command,
qt_(cit->second.listName()),
- FuncRequest(LFUN_FLOAT_LIST,
+ FuncRequest(LFUN_FLOAT_LIST_INSERT,
cit->second.type())));
}
}
size_t pos = from;
while (pos < to) {
size_t new_pos = pos + 1;
- while (new_pos < to &&
- toc_list[new_pos].depth() > depth)
+ while (new_pos < to && toc_list[new_pos].depth() > depth)
++new_pos;
QString label(4 * max(0, toc_list[pos].depth() - depth), ' ');
add(MenuItem(MenuItem::Command,
label, FuncRequest(toc_list[pos].action())));
} else {
+ MenuDefinition sub;
+ sub.expandToc2(toc_list, pos, new_pos, depth + 1);
MenuItem item(MenuItem::Submenu, label);
- item.setSubmenu(new MenuDefinition);
- item.submenu()->expandToc2(toc_list, pos, new_pos, depth + 1);
+ item.setSubmenu(sub);
add(item);
}
pos = new_pos;
add(MenuItem(MenuItem::Command, qt_("Master Document"), f));
}
+ MenuDefinition other_lists;
+
FloatList const & floatlist = buf->params().documentClass().floats();
TocList const & toc_list = buf->tocBackend().tocs();
TocList::const_iterator cit = toc_list.begin();
if (cit->first == "tableofcontents")
continue;
- // All the rest is for floats
- MenuDefinition * submenu = new MenuDefinition;
- TocIterator ccit = cit->second.begin();
- TocIterator eend = cit->second.end();
- for (; ccit != eend; ++ccit) {
- QString const label = limitStringLength(ccit->str());
- submenu->add(MenuItem(MenuItem::Command, label,
- FuncRequest(ccit->action())));
+ MenuDefinition submenu;
+ if (cit->second.size() >= 30) {
+ FuncRequest f(LFUN_DIALOG_SHOW, "toc " + cit->first);
+ submenu.add(MenuItem(MenuItem::Command, qt_("Open Navigator..."), f));
+ } else {
+ TocIterator ccit = cit->second.begin();
+ TocIterator eend = cit->second.end();
+ for (; ccit != eend; ++ccit) {
+ submenu.add(MenuItem(MenuItem::Command,
+ limitStringLength(ccit->str()),
+ FuncRequest(ccit->action())));
+ }
}
- string const & floatName = floatlist.getType(cit->first).listName();
- QString label;
- if (!floatName.empty())
- label = qt_(floatName);
- // BUG3633: listings is not a proper float so its name
- // is not shown in floatlist.
- else if (cit->first == "equation")
- label = qt_("List of Equations");
- else if (cit->first == "index")
- label = qt_("List of Indexes");
- else if (cit->first == "listing")
- label = qt_("List of Listings");
- else if (cit->first == "marginalnote")
- label = qt_("List of Marginal notes");
- else if (cit->first == "note")
- label = qt_("List of Notes");
- else if (cit->first == "footnote")
- label = qt_("List of Foot notes");
- else if (cit->first == "label")
- label = qt_("Labels and References");
- else if (cit->first == "citation")
- label = qt_("List of Citations");
- // this should not happen now, but if something else like
- // listings is added later, this can avoid an empty menu name.
- else
- label = qt_("Other floats");
- MenuItem item(MenuItem::Submenu, label);
+
+ MenuItem item(MenuItem::Submenu, guiName(cit->first, buf->params()));
item.setSubmenu(submenu);
+ if (floatlist.typeExist(cit->first) || cit->first == "child") {
+ // Those two types deserve to be in the main menu.
+ item.setSubmenu(submenu);
+ add(item);
+ } else
+ other_lists.add(item);
+ }
+ if (!other_lists.empty()) {
+ MenuItem item(MenuItem::Submenu, qt_("Other Lists"));
+ item.setSubmenu(other_lists);
add(item);
}
addWithStatusCheck(MenuItem(MenuItem::Command,
qt_("No Table of contents"),
FuncRequest()));
- } else {
+ } else
expandToc2(cit->second, 0, cit->second.size(), 0);
- }
}
void MenuDefinition::expandPasteRecent()
{
- vector<docstring> const sel = cap::availableSelections();
+ docstring_list const sel = cap::availableSelections();
- vector<docstring>::const_iterator cit = sel.begin();
- vector<docstring>::const_iterator end = sel.end();
+ docstring_list::const_iterator cit = sel.begin();
+ docstring_list::const_iterator end = sel.end();
for (unsigned int index = 0; cit != end; ++cit, ++index) {
add(MenuItem(MenuItem::Command, toqstr(*cit),
void MenuDefinition::expandToolbars()
{
- //
+ MenuDefinition other_lists;
// extracts the toolbars from the backend
- ToolbarBackend::Toolbars::const_iterator cit = toolbarbackend.begin();
- ToolbarBackend::Toolbars::const_iterator end = toolbarbackend.end();
-
+ Toolbars::Infos::const_iterator cit = guiApp->toolbars().begin();
+ Toolbars::Infos::const_iterator end = guiApp->toolbars().end();
for (; cit != end; ++cit) {
- QString label = qt_(cit->gui_name);
- // frontends are not supposed to turn on/off toolbars,
- // if they cannot 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 & ToolbarInfo::AUTO)
- label += qt_(" (auto)");
- add(MenuItem(MenuItem::Command, label,
- FuncRequest(LFUN_TOOLBAR_TOGGLE, cit->name + " allowauto")));
+ MenuItem const item(MenuItem::Command, qt_(cit->gui_name),
+ FuncRequest(LFUN_TOOLBAR_TOGGLE, cit->name));
+ if (guiApp->toolbars().isMainToolbar(cit->name))
+ add(item);
+ else
+ other_lists.add(item);
+ }
+
+ if (!other_lists.empty()) {
+ MenuItem item(MenuItem::Submenu, qt_("Other Toolbars"));
+ item.setSubmenu(other_lists);
+ add(item);
}
}
}
}
+
+void MenuDefinition::expandCiteStyles(BufferView const * bv)
+{
+ if (!bv) {
+ add(MenuItem(MenuItem::Command,
+ qt_("No Document Open!"),
+ FuncRequest(LFUN_NOACTION)));
+ return;
+ }
+
+ Inset const * inset = bv->cursor().nextInset();
+ if (!inset || inset->lyxCode() != CITE_CODE) {
+ add(MenuItem(MenuItem::Command,
+ qt_("No Citation in Scope!"),
+ FuncRequest(LFUN_NOACTION)));
+ return;
+ }
+ InsetCommand const * citinset =
+ static_cast<InsetCommand const *>(inset);
+
+ Buffer const * buf = &bv->buffer();
+ docstring key = citinset->getParam("key");
+ // we can only handle one key currently
+ if (contains(key, ','))
+ key = qstring_to_ucs4(toqstr(key).split(',')[0]);
+
+ vector<CiteStyle> citeStyleList = citeStyles(buf->params().citeEngine());
+ docstring_list citeStrings =
+ buf->masterBibInfo().getCiteStrings(key, bv->buffer());
+
+ docstring_list::const_iterator cit = citeStrings.begin();
+ docstring_list::const_iterator end = citeStrings.end();
+
+ for (int ii = 1; cit != end; ++cit, ++ii) {
+ docstring label = *cit;
+ CitationStyle cs;
+ CiteStyle cst = citeStyleList[ii - 1];
+ cs.style = cst;
+ addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(label),
+ FuncRequest(LFUN_NEXT_INSET_MODIFY,
+ "changetype " + from_utf8(citationStyleToString(cs)))));
+ }
+}
+
} // namespace anon
{
/// populates the menu or one of its submenu
/// This is used as a recursive function
- void populate(QMenu * qMenu, MenuDefinition * menu);
+ void populate(QMenu & qMenu, MenuDefinition const & menu);
/// Only needed for top level menus.
MenuDefinition * top_level_menu;
return label;
}
-void Menu::Impl::populate(QMenu * qMenu, MenuDefinition * menu)
+void Menu::Impl::populate(QMenu & qMenu, MenuDefinition const & menu)
{
- LYXERR(Debug::GUI, "populating menu " << fromqstr(menu->name()));
- if (menu->size() == 0) {
- LYXERR(Debug::GUI, "\tERROR: empty menu " << fromqstr(menu->name()));
+ LYXERR(Debug::GUI, "populating menu " << menu.name());
+ if (menu.size() == 0) {
+ LYXERR(Debug::GUI, "\tERROR: empty menu " << menu.name());
return;
}
- LYXERR(Debug::GUI, " ***** menu entries " << menu->size());
- MenuDefinition::const_iterator m = menu->begin();
- MenuDefinition::const_iterator end = menu->end();
+ LYXERR(Debug::GUI, " ***** menu entries " << menu.size());
+ MenuDefinition::const_iterator m = menu.begin();
+ MenuDefinition::const_iterator end = menu.end();
for (; m != end; ++m) {
if (m->kind() == MenuItem::Separator)
- qMenu->addSeparator();
+ qMenu.addSeparator();
else if (m->kind() == MenuItem::Submenu) {
- QMenu * subMenu = qMenu->addMenu(label(*m));
- populate(subMenu, m->submenu());
+ QMenu * subMenu = qMenu.addMenu(label(*m));
+ populate(*subMenu, m->submenu());
} else {
// we have a MenuItem::Command
- qMenu->addAction(new Action(*view, QIcon(), label(*m), m->func(),
- QString()));
+ qMenu.addAction(new Action(view, QIcon(), label(*m),
+ m->func(), QString(), &qMenu));
}
}
}
/////////////////////////////////////////////////////////////////////
Menu::Menu(GuiView * gv, QString const & name, bool top_level)
-: d(new Menu::Impl)
+: QMenu(gv), d(new Menu::Impl)
{
d->top_level_menu = top_level? new MenuDefinition : 0;
d->view = gv;
void Menu::updateView()
{
- guiApp->menus().updateMenu(d->name);
+ guiApp->menus().updateMenu(this);
}
+
/////////////////////////////////////////////////////////////////////
// Menus::Impl definition and implementation
/////////////////////////////////////////////////////////////////////
ViewFormats, ExportFormats, UpdateFormats, Branches
*/
void expand(MenuDefinition const & frommenu, MenuDefinition & tomenu,
- Buffer const *) const;
+ BufferView const *) const;
/// Initialize specific MACOS X menubar
- void macxMenuBarInit(GuiView * view);
+ void macxMenuBarInit(GuiView * view, QMenuBar * qmb);
/// Mac special menu.
/** This defines a menu whose entries list the FuncRequests
///
MenuDefinition menubar_;
- typedef QHash<QString, Menu *> NameMap;
+ typedef QMap<GuiView *, QHash<QString, Menu*> > NameMap;
/// name to menu for \c menu() method.
NameMap name_map_;
that this menubar will be used also when one of LyX' dialogs has
focus. (JMarc)
*/
-void Menus::Impl::macxMenuBarInit(GuiView * view)
+void Menus::Impl::macxMenuBarInit(GuiView * view, QMenuBar * qmb)
{
- // The Mac menubar initialisation must be done only once!
- static bool done = false;
- if (done)
- return;
- done = true;
-
/* Since Qt 4.2, the qt/mac menu code has special code for
specifying the role of a menu entry. However, it does not
work very well with our scheme of creating menus on demand,
* the hassle, though. (JMarc)
*/
struct MacMenuEntry {
- kb_action action;
+ FuncCode action;
char const * arg;
char const * label;
QAction::MenuRole role;
};
const size_t num_entries = sizeof(entries) / sizeof(entries[0]);
- // the special menu for Menus.
- for (size_t i = 0 ; i < num_entries ; ++i) {
- FuncRequest const func(entries[i].action,
- from_utf8(entries[i].arg));
- specialmenu_.add(MenuItem(MenuItem::Command, entries[i].label, func));
+ // the special menu for Menus. Fill it up only once.
+ if (specialmenu_.size() == 0) {
+ for (size_t i = 0 ; i < num_entries ; ++i) {
+ FuncRequest const func(entries[i].action,
+ from_utf8(entries[i].arg));
+ specialmenu_.add(MenuItem(MenuItem::Command,
+ entries[i].label, func));
+ }
}
-
+
// add the entries to a QMenu that will eventually be empty
// and therefore invisible.
- QMenu * qMenu = view->menuBar()->addMenu("special");
+ QMenu * qMenu = qmb->addMenu("special");
MenuDefinition::const_iterator cit = specialmenu_.begin();
MenuDefinition::const_iterator end = specialmenu_.end();
for (size_t i = 0 ; cit != end ; ++cit, ++i) {
- Action * action = new Action(*view, QIcon(), cit->label(),
- cit->func(), QString());
+ Action * action = new Action(view, QIcon(), cit->label(),
+ cit->func(), QString(), qMenu);
action->setMenuRole(entries[i].role);
qMenu->addAction(action);
}
}
-void Menus::Impl::expand(MenuDefinition const & frommenu, MenuDefinition & tomenu,
- Buffer const * buf) const
+void Menus::Impl::expand(MenuDefinition const & frommenu,
+ MenuDefinition & tomenu, BufferView const * bv) const
{
if (!tomenu.empty())
tomenu.clear();
for (MenuDefinition::const_iterator cit = frommenu.begin();
cit != frommenu.end() ; ++cit) {
+ Buffer const * buf = bv ? &bv->buffer() : 0;
switch (cit->kind()) {
case MenuItem::Lastfiles:
tomenu.expandLastfiles();
tomenu.expandBranches(buf);
break;
+ case MenuItem::CiteStyles:
+ tomenu.expandCiteStyles(bv);
+ break;
+
case MenuItem::Toc:
tomenu.expandToc(buf);
break;
+ case MenuItem::GraphicsGroups:
+ tomenu.expandGraphicsGroups(bv);
+ break;
+
case MenuItem::Submenu: {
MenuItem item(*cit);
- item.setSubmenu(new MenuDefinition(cit->submenuname()));
- expand(getMenu(cit->submenuname()), *item.submenu(), buf);
+ item.setSubmenu(MenuDefinition(cit->submenuname()));
+ expand(getMenu(cit->submenuname()), item.submenu(), bv);
tomenu.addWithStatusCheck(item);
}
break;
const_iterator cit = find_if(menulist_.begin(), menulist_.end(),
MenuNamesEqual(name));
if (cit == menulist_.end())
- lyxerr << "No submenu named " << fromqstr(name) << endl;
- BOOST_ASSERT(cit != menulist_.end());
+ LYXERR0("No submenu named " << name);
+ LASSERT(cit != menulist_.end(), /**/);
return (*cit);
}
iterator it = find_if(menulist_.begin(), menulist_.end(),
MenuNamesEqual(name));
if (it == menulist_.end())
- lyxerr << "No submenu named " << fromqstr(name) << endl;
- BOOST_ASSERT(it != menulist_.end());
+ LYXERR0("No submenu named " << name);
+ LASSERT(it != menulist_.end(), /**/);
return (*it);
}
+
/////////////////////////////////////////////////////////////////////
-// Menus implementation
+//
+// Menus
+//
/////////////////////////////////////////////////////////////////////
-Menus::Menus(): d(new Impl) {}
+Menus::Menus() : d(new Impl) {}
+Menus::~Menus()
+{
+ delete d;
+}
void Menus::read(Lexer & lex)
{
- enum Menutags {
- md_menu = 1,
+ enum {
+ md_menu,
md_menubar,
md_endmenuset,
- md_last
};
- struct keyword_item menutags[md_last - 1] = {
+ LexerKeyword menutags[] = {
{ "end", md_endmenuset },
{ "menu", md_menu },
{ "menubar", md_menubar }
};
- //consistency check
- if (compare_ascii_no_case(lex.getString(), "menuset")) {
- lyxerr << "Menubackend::read: ERROR wrong token:`"
- << lex.getString() << '\'' << endl;
- }
+ // consistency check
+ if (compare_ascii_no_case(lex.getString(), "menuset"))
+ LYXERR0("Menus::read: ERROR wrong token: `" << lex.getString() << '\'');
- lex.pushTable(menutags, md_last - 1);
- if (lyxerr.debugging(Debug::PARSER))
- lex.printTable(lyxerr);
+ lex.pushTable(menutags);
+ lex.setContext("Menus::read");
bool quit = false;
quit = true;
break;
default:
- lex.printError("menubackend::read: "
- "Unknown menu tag: `$$Token'");
+ lex.printError("Unknown menu tag");
break;
}
}
bool Menus::searchMenu(FuncRequest const & func,
- vector<docstring> & names) const
+ docstring_list & names) const
{
- return d->menubar_.searchMenu(func, names);
+ MenuDefinition menu;
+ d->expand(d->menubar_, menu, 0);
+ return menu.searchMenu(func, names);
}
-void Menus::fillMenuBar(GuiView * view)
+void Menus::fillMenuBar(QMenuBar * qmb, GuiView * view, bool initial)
{
- // Clear all menubar contents before filling it.
- view->menuBar()->clear();
-
+ if (initial) {
#ifdef Q_WS_MACX
- // setup special mac specific menu item
- d->macxMenuBarInit(view);
+ // setup special mac specific menu item
+ d->macxMenuBarInit(view, qmb);
#endif
+ } else {
+ // Clear all menubar contents before filling it.
+ qmb->clear();
+ }
- LYXERR(Debug::GUI, "populating menu bar" << fromqstr(d->menubar_.name()));
+ LYXERR(Debug::GUI, "populating menu bar" << d->menubar_.name());
if (d->menubar_.size() == 0) {
LYXERR(Debug::GUI, "\tERROR: empty menu bar"
- << fromqstr(d->menubar_.name()));
+ << d->menubar_.name());
return;
}
- else {
- LYXERR(Debug::GUI, "menu bar entries "
- << d->menubar_.size());
- }
+ LYXERR(Debug::GUI, "menu bar entries " << d->menubar_.size());
MenuDefinition menu;
- d->expand(d->menubar_, menu, view->buffer());
+ BufferView * bv = 0;
+ if (view)
+ bv = view->view();
+ d->expand(d->menubar_, menu, bv);
MenuDefinition::const_iterator m = menu.begin();
MenuDefinition::const_iterator end = menu.end();
for (; m != end; ++m) {
if (m->kind() != MenuItem::Submenu) {
- LYXERR(Debug::GUI, "\tERROR: not a submenu " << fromqstr(m->label()));
+ LYXERR(Debug::GUI, "\tERROR: not a submenu " << m->label());
continue;
}
- LYXERR(Debug::GUI, "menu bar item " << fromqstr(m->label())
- << " is a submenu named " << fromqstr(m->submenuname()));
+ LYXERR(Debug::GUI, "menu bar item " << m->label()
+ << " is a submenu named " << m->submenuname());
QString name = m->submenuname();
if (!d->hasMenu(name)) {
- LYXERR(Debug::GUI, "\tERROR: " << fromqstr(name)
+ LYXERR(Debug::GUI, "\tERROR: " << name
<< " submenu has no menu!");
continue;
}
Menu * menu = new Menu(view, m->submenuname(), true);
menu->setTitle(label(*m));
- view->menuBar()->addMenu(menu);
+ qmb->addMenu(menu);
- d->name_map_[name] = menu;
+ d->name_map_[view][name] = menu;
}
}
-void Menus::updateMenu(QString const & name)
+void Menus::updateMenu(Menu * qmenu)
{
- Menu * qmenu = d->name_map_[name];
- LYXERR(Debug::GUI, "Triggered menu: " << fromqstr(name));
+ LYXERR(Debug::GUI, "Triggered menu: " << qmenu->d->name);
qmenu->clear();
if (qmenu->d->name.isEmpty())
// Here, We make sure that theLyXFunc points to the correct LyXView.
theLyXFunc().setLyXView(qmenu->d->view);
- if (!d->hasMenu(name)) {
+ if (!d->hasMenu(qmenu->d->name)) {
qmenu->addAction(qt_("No action defined!"));
LYXERR(Debug::GUI, "\tWARNING: non existing menu: "
- << fromqstr(qmenu->d->name));
+ << qmenu->d->name);
return;
}
- MenuDefinition const & fromLyxMenu = d->getMenu(name);
- d->expand(fromLyxMenu, *qmenu->d->top_level_menu, qmenu->d->view->buffer());
- qmenu->d->populate(qmenu, qmenu->d->top_level_menu);
+ MenuDefinition const & fromLyxMenu = d->getMenu(qmenu->d->name);
+ BufferView * bv = 0;
+ if (qmenu->d->view)
+ bv = qmenu->d->view->view();
+ d->expand(fromLyxMenu, *qmenu->d->top_level_menu, bv);
+ qmenu->d->populate(*qmenu, *qmenu->d->top_level_menu);
}
Menu * Menus::menu(QString const & name, GuiView & view)
{
- LYXERR(Debug::GUI, "Context menu requested: " << fromqstr(name));
- Menu * menu = d->name_map_.value(name, 0);
+ LYXERR(Debug::GUI, "Context menu requested: " << name);
+ Menu * menu = d->name_map_[&view].value(name, 0);
if (!menu && !name.startsWith("context-")) {
- LYXERR0("resquested context menu not found: " << fromqstr(name));
+ LYXERR0("requested context menu not found: " << name);
return 0;
}
menu = new Menu(&view, name, true);
- d->name_map_[name] = menu;
+ d->name_map_[&view][name] = menu;
return menu;
}