#include "IndicesList.h"
#include "KeyMap.h"
#include "Language.h"
+#include "Layout.h"
#include "Lexer.h"
#include "LyXAction.h"
#include "LyX.h"
/// Words suggested by the spellchecker.
SpellingSuggestions,
/** Used Languages */
- LanguageSelector
+ LanguageSelector,
+ /** This is the list of arguments available
+ for insertion into the current layout. */
+ Arguments,
+ /** This is the list of arguments available
+ in the InsetArgument context menu. */
+ SwitchArguments,
+ /** This is the list of captions available
+ in the current layout. */
+ Captions,
+ /** This is the list of captions available
+ in the InsetCaption context menu. */
+ SwitchCaptions
};
explicit MenuItem(Kind kind) : kind_(kind), optional_(false) {}
: kind_(kind), label_(label), submenuname_(submenu),
tooltip_(tooltip), optional_(optional)
{
- LASSERT(kind == Submenu || kind == Help || kind == Info, /**/);
+ LATTEST(kind == Submenu || kind == Help || kind == Info);
}
MenuItem(Kind kind,
// Get the keys bound to this action, but keep only the
// first one later
KeyMap::Bindings bindings = theTopLevelKeymap().findBindings(func_);
- if (bindings.size())
+ if (!bindings.empty())
return toqstr(bindings.begin()->print(KeySequence::ForGui));
LYXERR(Debug::KBMAP, "No binding for "
void expandGraphicsGroups(BufferView const *);
void expandSpellingSuggestions(BufferView const *);
void expandLanguageSelector(Buffer const * buf);
+ void expandArguments(BufferView const *, bool switcharg = false);
+ void expandCaptions(Buffer const * buf, bool switchcap = false);
///
ItemList items_;
///
md_toolbars,
md_graphicsgroups,
md_spellingsuggestions,
- md_languageselector
+ md_languageselector,
+ md_arguments,
+ md_switcharguments,
+ md_captions,
+ md_switchcaptions
};
LexerKeyword menutags[] = {
+ { "arguments", md_arguments },
{ "bookmarks", md_bookmarks },
{ "branches", md_branches },
+ { "captions", md_captions },
{ "charstyles", md_charstyles },
{ "citestyles", md_citestyles },
{ "custom", md_custom },
{ "separator", md_separator },
{ "spellingsuggestions", md_spellingsuggestions },
{ "submenu", md_submenu },
+ { "switcharguments", md_switcharguments },
+ { "switchcaptions", md_switchcaptions },
{ "toc", md_toc },
{ "toolbars", md_toolbars },
{ "updateformats", md_updateformats },
lex.pushTable(menutags);
lex.setContext("MenuDefinition::read: ");
- bool quit = false;
- bool optional = false;
-
- while (lex.isOK() && !quit) {
- switch (lex.lex()) {
+ int md_type = 0;
+ while (lex.isOK() && md_type != md_endmenu) {
+ switch (md_type = lex.lex()) {
case md_optitem:
- optional = true;
- // fallback to md_item
case md_item: {
lex.next(true);
docstring const name = translateIfPossible(lex.getDocString());
FuncRequest::Origin origin = FuncRequest::MENU;
if (name_.startsWith("context-toc-"))
origin = FuncRequest::TOC;
+ bool const optional = (md_type == md_optitem);
add(MenuItem(MenuItem::Command, toqstr(name), func, QString(), optional, origin));
- optional = false;
break;
}
add(MenuItem(MenuItem::IndicesListsContext));
break;
+ case md_arguments:
+ add(MenuItem(MenuItem::Arguments));
+ break;
+
+ case md_switcharguments:
+ add(MenuItem(MenuItem::SwitchArguments));
+ break;
+
+ case md_captions:
+ add(MenuItem(MenuItem::Captions));
+ break;
+
+ case md_switchcaptions:
+ add(MenuItem(MenuItem::SwitchCaptions));
+ break;
+
case md_optsubmenu:
- optional = true;
- // fallback to md_submenu
case md_submenu: {
lex.next(true);
docstring const mlabel = translateIfPossible(lex.getDocString());
lex.next(true);
docstring const mname = lex.getDocString();
+ bool const optional = (md_type == md_optsubmenu);
add(MenuItem(MenuItem::Submenu,
toqstr(mlabel), toqstr(mname), QString(), optional));
- optional = false;
break;
}
case md_endmenu:
- quit = true;
break;
default:
}
}
MenuItem w(MenuItem::Command, label,
- FuncRequest(LFUN_LANGUAGE, (*cit)->lang()));
+ FuncRequest(LFUN_LANGUAGE, (*cit)->lang() + " set"));
item.submenu().addWithStatusCheck(w);
}
item.submenu().add(MenuItem(MenuItem::Separator));
action = LFUN_BUFFER_EXPORT;
break;
default:
- LASSERT(false, /* */);
+ LATTEST(false);
return;
}
+ sort(formats.begin(), formats.end(), Format::formatSorter);
bool const view_update = (kind == MenuItem::ViewFormats
|| kind == MenuItem::UpdateFormats);
continue;
break;
default:
- LASSERT(false, /* */);
+ // we already asserted earlier in this case
+ // LATTEST(false);
continue;
}
if (!shortcut.empty())
if (cit == end)
LYXERR(Debug::GUI, "No table of contents.");
else {
- if (cit->second.size() > 0 )
+ if (!cit->second.empty())
expandToc2(cit->second, 0, cit->second.size(), 0);
else
add(MenuItem(MenuItem::Info, qt_("<Empty Table of Contents>")));
}
}
+
+void MenuDefinition::expandArguments(BufferView const * bv, bool switcharg)
+{
+ if (!bv)
+ return;
+
+ if (!bv->cursor().inTexted())
+ return;
+
+ Inset const * inset = &bv->cursor().inset();
+ Layout::LaTeXArgMap args = bv->cursor().paragraph().layout().args();
+ if (inset && args.empty())
+ args = inset->getLayout().args();
+ if (args.empty() || (switcharg && args.size() == 1))
+ return;
+ Layout::LaTeXArgMap::const_iterator lait = args.begin();
+ Layout::LaTeXArgMap::const_iterator const laend = args.end();
+ for (; lait != laend; ++lait) {
+ Layout::latexarg arg = (*lait).second;
+ docstring str = arg.menustring.empty()? arg.labelstring : arg.menustring;
+ QString item = toqstr(translateIfPossible(str));
+ if (switcharg)
+ add(MenuItem(MenuItem::Command, item,
+ FuncRequest(LFUN_INSET_MODIFY,
+ from_ascii("changetype ")
+ + from_ascii((*lait).first))));
+ else
+ add(MenuItem(MenuItem::Command, item,
+ FuncRequest(LFUN_ARGUMENT_INSERT,
+ from_ascii((*lait).first))));
+ }
+}
+
+
+void MenuDefinition::expandCaptions(Buffer const * buf, bool switchcap)
+{
+ if (!buf)
+ return;
+
+ vector<docstring> caps;
+ DocumentClass const & dc = buf->params().documentClass();
+ TextClass::InsetLayouts::const_iterator lit = dc.insetLayouts().begin();
+ TextClass::InsetLayouts::const_iterator len = dc.insetLayouts().end();
+ for (; lit != len; ++lit) {
+ if (prefixIs(lit->first, from_ascii("Caption:")))
+ caps.push_back(lit->first);
+ }
+
+ if (caps.empty() || (switchcap && caps.size() == 1))
+ return;
+ if (caps.size() == 1) {
+ docstring dummy;
+ docstring const type = split(*caps.begin(), dummy, ':');
+ add(MenuItem(MenuItem::Command, qt_("Caption"),
+ FuncRequest(LFUN_CAPTION_INSERT, translateIfPossible(type))));
+ return;
+ }
+
+ MenuDefinition captions;
+
+ vector<docstring>::const_iterator cit = caps.begin();
+ vector<docstring>::const_iterator end = caps.end();
+
+ for (int ii = 1; cit != end; ++cit, ++ii) {
+ docstring dummy;
+ docstring const type = split(*cit, dummy, ':');
+ docstring const trtype = translateIfPossible(type);
+ docstring const cmitem = bformat(_("Caption (%1$s)"), trtype);
+ // make menu item optional, otherwise we would also see
+ // forbidden caption types
+ if (switchcap)
+ addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(cmitem),
+ FuncRequest(LFUN_INSET_MODIFY,
+ from_ascii("changetype ")
+ + type), QString(), true));
+ else
+ captions.addWithStatusCheck(MenuItem(MenuItem::Command,
+ toqstr(trtype),
+ FuncRequest(LFUN_CAPTION_INSERT,
+ type), QString(), true));
+ }
+ if (!captions.empty()) {
+ MenuItem item(MenuItem::Submenu, qt_("Caption"));
+ item.setSubmenu(captions);
+ add(item);
+ }
+}
+
} // namespace anon
void Menu::Impl::populate(QMenu & qMenu, MenuDefinition const & menu)
{
LYXERR(Debug::GUI, "populating menu " << menu.name());
- if (menu.size() == 0) {
+ if (menu.empty()) {
LYXERR(Debug::GUI, "\tERROR: empty menu " << menu.name());
return;
}
subMenu->setEnabled(m->status().enabled());
} else {
// we have a MenuItem::Command
- qMenu.addAction(new Action(view, QIcon(), label(*m),
+ qMenu.addAction(new Action(QIcon(), label(*m),
m->func(), m->tooltip(), &qMenu));
}
}
/// Expands some special entries of the menu
/** The entries with the following kind are expanded to a
sequence of Command MenuItems: Lastfiles, Documents,
- ViewFormats, ExportFormats, UpdateFormats, Branches, Indices
+ ViewFormats, ExportFormats, UpdateFormats, Branches,
+ Indices, Arguments, SwitchArguments, Captions, SwitchCaptions
*/
void expand(MenuDefinition const & frommenu, MenuDefinition & tomenu,
BufferView const *) const;
/// Initialize specific MACOS X menubar
- void macxMenuBarInit(GuiView * view, QMenuBar * qmb);
+ void macxMenuBarInit(QMenuBar * qmb);
/// Mac special menu.
/** This defines a menu whose entries list the FuncRequests
that this menubar will be used also when one of LyX' dialogs has
focus. (JMarc)
*/
-void Menus::Impl::macxMenuBarInit(GuiView * view, QMenuBar * qmb)
+void Menus::Impl::macxMenuBarInit(QMenuBar * qmb)
{
/* Since Qt 4.2, the qt/mac menu code has special code for
specifying the role of a menu entry. However, it does not
QAction::MenuRole role;
};
- MacMenuEntry entries[] = {
+ static MacMenuEntry entries[] = {
{LFUN_DIALOG_SHOW, "aboutlyx", "About LyX",
QAction::AboutRole},
{LFUN_DIALOG_SHOW, "prefs", "Preferences",
{LFUN_LYX_QUIT, "", "Quit LyX", QAction::QuitRole}
};
const size_t num_entries = sizeof(entries) / sizeof(entries[0]);
- const bool first_call = mac_special_menu_.size() == 0;
+ const bool first_call = mac_special_menu_.empty();
// the special menu for Menus. Fill it up only once.
if (first_call) {
for (size_t i = 0 ; cit != end ; ++cit, ++i) {
#if defined(QT_MAC_USE_COCOA) && (QT_MAC_USE_COCOA > 0)
if (first_call || entries[i].role != QAction::ApplicationSpecificRole) {
- Action * action = new Action(view, QIcon(), cit->label(),
+ Action * action = new Action(QIcon(), cit->label(),
cit->func(), QString(), qMenu);
action->setMenuRole(entries[i].role);
qMenu->addAction(action);
}
#else
- Action * action = new Action(view, QIcon(), cit->label(),
+ Action * action = new Action(QIcon(), cit->label(),
cit->func(), QString(), qMenu);
action->setMenuRole(entries[i].role);
qMenu->addAction(action);
tomenu.expandLanguageSelector(buf);
break;
+ case MenuItem::Arguments:
+ tomenu.expandArguments(bv, false);
+ break;
+
+ case MenuItem::SwitchArguments:
+ tomenu.expandArguments(bv, true);
+ break;
+
+ case MenuItem::Captions:
+ tomenu.expandCaptions(buf, false);
+ break;
+
+ case MenuItem::SwitchCaptions:
+ tomenu.expandCaptions(buf, true);
+ break;
+
case MenuItem::Submenu: {
MenuItem item(*cit);
item.setSubmenu(MenuDefinition(cit->submenuname()));
{
const_iterator cit = find_if(menulist_.begin(), menulist_.end(),
MenuNamesEqual(name));
- if (cit == menulist_.end())
+ if (cit == menulist_.end()) {
LYXERR0("No submenu named " << name);
- LASSERT(cit != menulist_.end(), /**/);
+ LASSERT(false, { static const MenuDefinition m; return m; });
+ }
return (*cit);
}
{
iterator it = find_if(menulist_.begin(), menulist_.end(),
MenuNamesEqual(name));
- if (it == menulist_.end())
+ if (it == menulist_.end()) {
LYXERR0("No submenu named " << name);
- LASSERT(it != menulist_.end(), /**/);
+ LASSERT(false, { static MenuDefinition m; return m; });
+ }
return (*it);
}
// create duplicate items in the application menu. It seems
// that Qt does not remove them when the QMenubar is cleared.
LYXERR(Debug::GUI, "Creating Mac OS X special menu bar");
- d->macxMenuBarInit(view, qmb);
+ d->macxMenuBarInit(qmb);
#endif
} else {
// Clear all menubar contents before filling it.
LYXERR(Debug::GUI, "populating menu bar" << d->menubar_.name());
- if (d->menubar_.size() == 0) {
+ if (d->menubar_.empty()) {
LYXERR(Debug::GUI, "\tERROR: empty menu bar"
<< d->menubar_.name());
return;
MenuDefinition cat_menu = d->getMenu(toqstr(menu_name));
//FIXME: 50 is a wild guess. We should take into account here
//the expansion of menu items, disabled optional items etc.
- bool const in_sub_menu = fromLyxMenu.size() > 0
+ bool const in_sub_menu = !fromLyxMenu.empty()
&& fromLyxMenu.size() + cat_menu.size() > 50 ;
if (in_sub_menu)
fromLyxMenu.catSub(menu_name);
projects / lyx.git / blobdiff