#include "IndicesList.h"
#include "KeyMap.h"
#include "Language.h"
+#include "Layout.h"
#include "Lexer.h"
#include "LyXAction.h"
#include "LyX.h"
menuitem is in a submenu, the submenu is enabled to make sure the
user sees the information. */
Help,
- /** This type of item merely shows that there might be a list or
+ /** This type of item merely shows that there might be a list or
something alike at this position, but the list is still empty.
- If this item is in a submenu, the submenu will not always be
+ If this item is in a submenu, the submenu will not always be
enabled. */
Info,
/** This is the list of last opened file,
/// 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
+ for in the InsetArgument context menu. */
+ SwitchArguments
};
explicit MenuItem(Kind kind) : kind_(kind), optional_(false) {}
~MenuItem() {}
/// The label of a given menuitem
- QString label() const
- {
+ QString label() const
+ {
int const index = label_.lastIndexOf('|');
return index == -1 ? label_ : label_.left(index);
}
QString shortcut() const
{
int const index = label_.lastIndexOf('|');
- return index == -1 ? QString() : label_.mid(index + 1);
+ return index == -1 ? QString() : label_.mid(index + 1);
}
/// The complete label, with label and shortcut separated by a '|'
QString fulllabel() const { return label_; }
// 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 cat(MenuDefinition const & other);
///
void catSub(docstring const & name);
-
+
// search for func in this menu iteratively, and put menu
// names in a stack.
bool searchMenu(FuncRequest const & func, docstring_list & names)
void expandGraphicsGroups(BufferView const *);
void expandSpellingSuggestions(BufferView const *);
void expandLanguageSelector(Buffer const * buf);
+ void expandArguments(BufferView const *, bool switcharg = false);
///
ItemList items_;
///
md_toolbars,
md_graphicsgroups,
md_spellingsuggestions,
- md_languageselector
+ md_languageselector,
+ md_arguments,
+ md_switcharguments
};
LexerKeyword menutags[] = {
+ { "arguments", md_arguments },
{ "bookmarks", md_bookmarks },
{ "branches", md_branches },
{ "charstyles", md_charstyles },
{ "separator", md_separator },
{ "spellingsuggestions", md_spellingsuggestions },
{ "submenu", md_submenu },
+ { "switcharguments", md_switcharguments },
{ "toc", md_toc },
{ "toolbars", md_toolbars },
{ "updateformats", md_updateformats },
add(MenuItem(MenuItem::IndicesListsContext));
break;
+ case md_arguments:
+ add(MenuItem(MenuItem::Arguments));
+ break;
+
+ case md_switcharguments:
+ add(MenuItem(MenuItem::SwitchArguments));
+ break;
+
case md_optsubmenu:
optional = true;
// fallback to md_submenu
set<string>::const_iterator it = grp.begin();
set<string>::const_iterator end = grp.end();
- add(MenuItem(MenuItem::Command, qt_("No Group"),
+ add(MenuItem(MenuItem::Command, qt_("No Group"),
FuncRequest(LFUN_SET_GRAPHICS_GROUP)));
- for (; it != end; it++) {
+ for (; it != end; ++it) {
addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(*it) + '|',
FuncRequest(LFUN_SET_GRAPHICS_GROUP, *it)));
}
docstring const & suggestion = suggestions[i];
LYXERR(Debug::GUI, suggestion);
MenuItem w(MenuItem::Command, toqstr(suggestion),
- FuncRequest(LFUN_WORD_REPLACE,
+ FuncRequest(LFUN_WORD_REPLACE,
replace2string(suggestion, selection,
- true, true, false, true, false)));
+ true, // case sensitive
+ true, // match word
+ false, // all words
+ true, // forward
+ false))); // find next
if (i < m)
add(w);
else
FuncRequest(LFUN_SPELLING_REMOVE, arg)));
}
break;
+ case SpellChecker::NO_DICTIONARY:
+ LYXERR(Debug::GUI, "No dictionary for language " + from_ascii(wl.lang()->lang()));
+ // FALLTHROUGH
case SpellChecker::WORD_OK:
case SpellChecker::COMPOUND_WORD:
case SpellChecker::ROOT_FOUND:
std::set<Language const *> languages_buffer =
buf->masterBuffer()->getLanguages();
-
+
if (languages_buffer.size() < 2)
return;
}
}
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));
Buffer * b = first;
// We cannot use a for loop as the buffer list cycles.
do {
- bool const shown = guiApp->currentView()
- ? guiApp->currentView()->workArea(*b) : false;
- if (!shown) {
+ if (!(guiApp->currentView()
+ && guiApp->currentView()->workArea(*b))) {
QString label = toqstr(b->fileName().displayName(20));
if (!b->isClean())
label += "*";
++i;
}
b = theBufferList().next(b);
- } while (b != first);
-
+ } while (b != first);
+
if (!item.submenu().empty())
add(item);
}
LASSERT(false, /* */);
return;
}
-
+
bool const view_update = (kind == MenuItem::ViewFormats
|| kind == MenuItem::UpdateFormats);
docstring lab = from_utf8((*fit)->prettyname());
docstring const scut = from_utf8((*fit)->shortcut());
docstring const tmplab = lab;
-
+
if (!scut.empty())
lab += char_type('|') + scut;
docstring const lab_i18n = translateIfPossible(lab);
if (view_update) {
if (buf)
- item.submenu().addWithStatusCheck(MenuItem(MenuItem::Command,
+ item.submenu().addWithStatusCheck(MenuItem(MenuItem::Command,
toqstr(label), FuncRequest(action, (*fit)->name())));
else
item.submenu().add(MenuItem(MenuItem::Command, toqstr(label),
// we remove the "Flex:" prefix, if it is present
if (prefixIs(label, from_utf8("Flex:")))
label = label.substr(5);
- addWithStatusCheck(MenuItem(MenuItem::Command,
+ addWithStatusCheck(MenuItem(MenuItem::Command,
toqstr(translateIfPossible(label)),
FuncRequest(LFUN_FLEX_INSERT, Lexer::quoteString(label))));
}
}
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 == 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>")));
FuncRequest(LFUN_BRANCH_INSERT,
cit->branch())));
}
-
+
if (buf == buf->masterBuffer())
return;
-
+
MenuDefinition child_branches;
-
+
BranchList::const_iterator ccit = params.branchlist().begin();
BranchList::const_iterator cend = params.branchlist().end();
FuncRequest(LFUN_BRANCH_INSERT,
ccit->branch())));
}
-
+
if (!child_branches.empty()) {
MenuItem item(MenuItem::Submenu, qt_("Child Document"));
item.setSubmenu(child_branches);
for (int ii = 1; cit != end; ++cit, ++ii) {
if (listof) {
- docstring const label =
+ docstring const label =
bformat(_("Index: %1$s"), cit->index());
addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(label),
FuncRequest(LFUN_INDEX_PRINT, cit->shortcut())));
} else {
- docstring const label =
+ docstring const label =
bformat(_("Index Entry (%1$s)"), cit->index());
addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(label),
FuncRequest(LFUN_INDEX_INSERT, cit->shortcut())));
addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(cit->index()),
FuncRequest(LFUN_INSET_MODIFY, data)));
} else {
- docstring const label =
+ docstring const label =
bformat(_("Index Entry (%1$s)"), cit->index());
addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(label),
FuncRequest(LFUN_INSET_MODIFY,
}
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]);
+ string const cmd = citinset->params().getCmdName();
- vector<CiteStyle> citeStyleList = citeStyles(buf->params().citeEngine());
- docstring_list citeStrings =
- buf->masterBibInfo().getCiteStrings(key, bv->buffer());
+ docstring const & key = citinset->getParam("key");
+ if (key.empty()) {
+ add(MenuItem(MenuItem::Command,
+ qt_("No citations selected!"),
+ FuncRequest(LFUN_NOACTION)));
+ return;
+ }
- docstring_list::const_iterator cit = citeStrings.begin();
- docstring_list::const_iterator end = citeStrings.end();
+ docstring const & before = citinset->getParam("before");
+ docstring const & after = citinset->getParam("after");
+
+ size_t const n = cmd.size();
+ bool const force = cmd[0] == 'C';
+ bool const full = cmd[n] == '*';
+
+ vector<docstring> const keys = getVectorFromString(key);
+
+ vector<CitationStyle> const citeStyleList = buf->params().citeStyles();
+ vector<docstring> citeStrings =
+ buf->masterBibInfo().getCiteStrings(keys, citeStyleList, bv->buffer(),
+ false, before, after, from_utf8("dialog"));
+
+ vector<docstring>::const_iterator cit = citeStrings.begin();
+ vector<docstring>::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;
+ CitationStyle cs = citeStyleList[ii - 1];
+ cs.forceUpperCase &= force;
+ cs.fullAuthorList &= full;
addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(label),
FuncRequest(LFUN_INSET_MODIFY,
"changetype " + from_utf8(citationStyleToString(cs)))));
}
}
+
+void MenuDefinition::expandArguments(BufferView const * bv, bool switcharg)
+{
+ if (!bv)
+ return;
+
+ Inset const * inset = &bv->cursor().inset();
+ Layout::LaTeXArgMap args;
+ if (inset && bv->cursor().paragraph().layout().latexargs().empty()
+ && bv->cursor().paragraph().layout().itemargs().empty())
+ args = inset->getLayout().latexargs();
+ else {
+ args = bv->cursor().paragraph().layout().latexargs();
+ Layout::LaTeXArgMap itemargs = bv->cursor().paragraph().layout().itemargs();
+ if (!itemargs.empty())
+ args.insert(itemargs.begin(), itemargs.end());
+ }
+ 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))));
+ }
+}
+
} // 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(view, QIcon(), label(*m),
m->func(), m->tooltip(), &qMenu));
}
}
class AlwaysMnemonicStyle : public QProxyStyle {
public:
int styleHint(StyleHint hint, const QStyleOption *opt = 0, const QWidget *widget = 0,
- QStyleHintReturn *returnData = 0) const
+ QStyleHintReturn *returnData = 0) const
{
if (hint == QStyle::SH_UnderlineShortcut)
return 1;
d->name = name;
setTitle(name);
if (d->top_level_menu)
- connect(this, SIGNAL(aboutToShow()), this, SLOT(updateView()));
+ connect(this, SIGNAL(aboutToShow()), this, SLOT(updateView()));
}
/// 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
*/
void expand(MenuDefinition const & frommenu, MenuDefinition & tomenu,
BufferView const *) const;
QAction::AboutRole},
{LFUN_DIALOG_SHOW, "prefs", "Preferences",
QAction::PreferencesRole},
- {LFUN_RECONFIGURE, "", "Reconfigure",
- QAction::ApplicationSpecificRole},
+ /* {LFUN_RECONFIGURE, "", "Reconfigure",
+ QAction::ApplicationSpecificRole}, */
{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) {
tomenu.expandLanguageSelector(buf);
break;
+ case MenuItem::Arguments:
+ tomenu.expandArguments(bv, false);
+ break;
+
+ case MenuItem::SwitchArguments:
+ tomenu.expandArguments(bv, true);
+ break;
+
case MenuItem::Submenu: {
MenuItem item(*cit);
item.setSubmenu(MenuDefinition(cit->submenuname()));
/////////////////////////////////////////////////////////////////////
//
-// Menus
+// Menus
//
/////////////////////////////////////////////////////////////////////
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 / features.git / blobdiff