#include "insets/Inset.h"
#include "insets/InsetCitation.h"
#include "insets/InsetGraphics.h"
+#include "insets/InsetInfo.h"
#include "insets/InsetQuotes.h"
#include "support/lassert.h"
/** This is a list of exportable formats
typically for the File->Export menu. */
ExportFormats,
+ /** This exports the document default format
+ typically for the File->Export menu. */
+ ExportFormat,
/** This is a list of importable formats
typically for the File->Import menu. */
ImportFormats,
IndicesListsContext,
/** Available citation styles for a given citation */
CiteStyles,
+ /** Available arguments for a given info inset */
+ InfoArguments,
/** Available graphics groups */
GraphicsGroups,
/// Words suggested by the spellchecker.
SwitchCaptions,
/** Commands to separate environments. */
EnvironmentSeparators,
+ /** Commands to separate environments (context menu version). */
+ EnvironmentSeparatorsContext,
/** This is the list of quotation marks available */
SwitchQuotes
};
void expandFloatListInsert(Buffer const * buf);
void expandFloatInsert(Buffer const * buf);
void expandFlexInsert(Buffer const * buf, InsetLayout::InsetLyXType type);
+ void expandTocSubmenu(std::string const & type, Toc const & toc_list);
void expandToc2(Toc const & toc_list, size_t from, size_t to, int depth, string toc_type);
void expandToc(Buffer const * buf);
void expandPasteRecent(Buffer const * buf);
void expandIndices(Buffer const * buf, bool listof = false);
void expandIndicesContext(Buffer const * buf, bool listof = false);
void expandCiteStyles(BufferView const *);
+ void expandInfoArguments(BufferView const *);
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);
- void expandEnvironmentSeparators(BufferView const *);
+ void expandEnvironmentSeparators(BufferView const *, bool contextmenu = false);
void expandQuotes(BufferView const *);
///
ItemList items_;
md_custom,
md_elements,
md_endmenu,
+ md_exportformat,
md_exportformats,
md_importformats,
md_indices,
md_indicescontext,
md_indiceslists,
md_indiceslistscontext,
+ md_infoarguments,
md_lastfiles,
md_optitem,
md_optsubmenu,
md_captions,
md_switchcaptions,
md_env_separators,
+ md_env_separatorscontext,
md_switchquotes
};
{ "elements", md_elements },
{ "end", md_endmenu },
{ "environmentseparators", md_env_separators },
+ { "environmentseparatorscontext", md_env_separatorscontext },
+ { "exportformat", md_exportformat },
{ "exportformats", md_exportformats },
{ "floatinsert", md_floatinsert },
{ "floatlistinsert", md_floatlistinsert },
{ "indicescontext", md_indicescontext },
{ "indiceslists", md_indiceslists },
{ "indiceslistscontext", md_indiceslistscontext },
+ { "infoarguments", md_infoarguments },
{ "item", md_item },
{ "languageselector", md_languageselector },
{ "lastfiles", md_lastfiles },
add(MenuItem(MenuItem::ExportFormats));
break;
+ case md_exportformat:
+ add(MenuItem(MenuItem::ExportFormat));
+ break;
+
case md_importformats:
add(MenuItem(MenuItem::ImportFormats));
break;
add(MenuItem(MenuItem::CiteStyles));
break;
+ case md_infoarguments:
+ add(MenuItem(MenuItem::InfoArguments));
+ break;
+
+
case md_graphicsgroups:
add(MenuItem(MenuItem::GraphicsGroups));
break;
add(MenuItem(MenuItem::EnvironmentSeparators));
break;
+ case md_env_separatorscontext:
+ add(MenuItem(MenuItem::EnvironmentSeparatorsContext));
+ break;
+
case md_switchquotes:
add(MenuItem(MenuItem::SwitchQuotes));
break;
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)));
+ FuncRequest(LFUN_GRAPHICS_SET_GROUP)));
for (; it != end; ++it) {
addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(*it) + '|',
- FuncRequest(LFUN_SET_GRAPHICS_GROUP, *it)));
+ FuncRequest(LFUN_GRAPHICS_SET_GROUP, *it)));
}
}
if (languages_buffer.size() < 2)
return;
- std::set<Language const *, sortLanguageByName> languages;
+ std::set<Language const *, sortLanguageByName> langs;
std::set<Language const *>::const_iterator const beg =
languages_buffer.begin();
for (std::set<Language const *>::const_iterator cit = beg;
cit != languages_buffer.end(); ++cit) {
- languages.insert(*cit);
+ langs.insert(*cit);
}
MenuItem item(MenuItem::Submenu, qt_("Language|L"));
QStringList accelerators;
if (morelangs.contains('|'))
accelerators.append(morelangs.section('|', -1));
- std::set<Language const *, sortLanguageByName>::const_iterator const begin = languages.begin();
+ std::set<Language const *, sortLanguageByName>::const_iterator const begin = langs.begin();
for (std::set<Language const *, sortLanguageByName>::const_iterator cit = begin;
- cit != languages.end(); ++cit) {
+ cit != langs.end(); ++cit) {
QString label = qt_((*cit)->display());
// try to add an accelerator
bool success = false;
QString label = toqstr(b.fileName().displayName(20));
if (!b.isClean())
label += "*";
+ if (b.notifiesExternalModification())
+ label += QChar(0x26a0);
if (i < 10)
label = QString::number(i) + ". " + label + '|' + QString::number(i);
add(MenuItem(MenuItem::Command, label,
QString label = toqstr(b->fileName().displayName(20));
if (!b->isClean())
label += "*";
+ if (b->notifiesExternalModification())
+ label += QChar(0x26a0);
if (i < 10)
label = QString::number(i) + ". " + label + '|' + QString::number(i);
item.submenu().add(MenuItem(MenuItem::Command, label,
add(MenuItem(MenuItem::Command, toqstr(lbl), FuncRequest(action)));
continue;
}
- // fall through
+ break;
case MenuItem::ExportFormats:
if (!f->inExportMenu())
continue;
if (cit->second.lyxtype() == type) {
if (!cit->second.obsoleted_by().empty())
continue;
- docstring label = cit->first;
+ docstring name = cit->first;
// we remove the "Flex:" prefix, if it is present
- if (prefixIs(label, from_ascii("Flex:")))
- label = label.substr(5);
+ if (prefixIs(name, from_ascii("Flex:")))
+ name = name.substr(5);
+ docstring const label = (cit->second.menustring().empty()) ?
+ name
+ : cit->second.menustring();
addWithStatusCheck(MenuItem(MenuItem::Command,
toqstr(translateIfPossible(label)),
- FuncRequest(LFUN_FLEX_INSERT, Lexer::quoteString(label))));
+ FuncRequest(LFUN_FLEX_INSERT, Lexer::quoteString(name))));
}
}
// FIXME This is a little clunky.
- if (items_.empty() && type == InsetLayout::CUSTOM && !buf->isReadonly())
+ if (items_.empty() && type == InsetLayout::CUSTOM && !buf->hasReadonlyFlag())
add(MenuItem(MenuItem::Help, qt_("No Custom Insets Defined!")));
}
}
MenuDefinition other_lists;
- FloatList const & floatlist = buf->params().documentClass().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) {
+ // In the navigation menu, only add tocs from this document
+ TocBackend const & backend = buf->tocBackend();
+ TocList const & toc_list = backend.tocs();
+ for (pair<string, shared_ptr<Toc>> const & toc : toc_list) {
// Handle table of contents later
- if (cit->first == "tableofcontents" || cit->second->empty())
+ if (toc.first == "tableofcontents" || toc.second->empty())
continue;
MenuDefinition submenu;
- // "Open outliner..." entry
- FuncRequest f(LFUN_DIALOG_SHOW, "toc " + cit->first);
- submenu.add(MenuItem(MenuItem::Command, qt_("Open Outliner..."), f));
- submenu.add(MenuItem(MenuItem::Separator));
- // add entries
- submenu.expandToc2(*cit->second, 0, cit->second->size(), 0, cit->first);
- MenuItem item(MenuItem::Submenu, guiName(cit->first, buf->params()));
+ submenu.expandTocSubmenu(toc.first, *toc.second);
+ docstring const toc_name = backend.outlinerName(toc.first);
+ MenuItem item(MenuItem::Submenu, toqstr(toc_name));
item.setSubmenu(submenu);
// deserves to be in the main menu?
- if (floatlist.typeExist(cit->first) || cit->first == "child")
+ if (!TocBackend::isOther(toc.first))
add(item);
else
other_lists.add(item);
}
// Handle normal TOC
add(MenuItem(MenuItem::Separator));
- cit = toc_list.find("tableofcontents");
- if (cit == end)
+ TocList::const_iterator cit = toc_list.find("tableofcontents");
+ if (cit == toc_list.end())
LYXERR(Debug::GUI, "No table of contents.");
else {
if (!cit->second->empty())
}
+void MenuDefinition::expandTocSubmenu(std::string const & type, Toc const & toc)
+{
+ // "Open outliner..." entry
+ FuncRequest f(LFUN_DIALOG_SHOW, "toc " + type);
+ add(MenuItem(MenuItem::Command, qt_("Open Outliner..."), f));
+ add(MenuItem(MenuItem::Separator));
+ // add entries
+ expandToc2(toc, 0, toc.size(), 0, type);
+}
+
+
void MenuDefinition::expandPasteRecent(Buffer const * buf)
{
docstring_list const sel = cap::availableSelections(buf);
void MenuDefinition::expandBranches(Buffer const * buf)
{
- if (!buf || buf->isReadonly())
+ if (!buf || buf->hasReadonlyFlag())
return;
- BufferParams const & master_params = buf->masterBuffer()->params();
- BufferParams const & params = buf->params();
- if (params.branchlist().empty() && master_params.branchlist().empty() ) {
- add(MenuItem(MenuItem::Help, qt_("No Branches Set for Document!")));
- return;
- }
-
- BranchList::const_iterator cit = master_params.branchlist().begin();
- BranchList::const_iterator end = master_params.branchlist().end();
+ BranchList const & child_list = buf->params().branchlist();
+ set<docstring> brset;
+ int ii = 1;
+ for (auto const & b : child_list) {
+ docstring const & bname = b.branch();
+ // NUM. Branch Name + "|", which triggers an empty shortcut in
+ // case that character should be in the branch name.
+ docstring label = convert<docstring>(ii) + ". " + bname + char_type('|');
+ // Add NUM as a keyboard shortcut if it's a single digit
+ if (ii < 10)
+ label += convert<docstring>(ii);
- for (int ii = 1; cit != end; ++cit, ++ii) {
- docstring label = cit->branch();
- if (ii < 10) {
- label = convert<docstring>(ii) + ". " + label
- + char_type('|') + convert<docstring>(ii);
- }
addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(label),
- FuncRequest(LFUN_BRANCH_INSERT,
- cit->branch())));
+ FuncRequest(LFUN_BRANCH_INSERT, bname)));
+
+ brset.insert(bname);
+ ++ii;
}
- if (buf == buf->masterBuffer())
- return;
+ set<Buffer const *> bufset;
+ Buffer const * nextbuf = buf->parent();
+ MenuDefinition master_branches;
+ ii = 1;
+ while (nextbuf) {
+ // recursive includes are a bad idea, but let's not crash
+ // if we find one.
+ if (bufset.count(nextbuf))
+ break;
- MenuDefinition child_branches;
+ for (auto const & b : nextbuf->params().branchlist()) {
+ docstring const & bname = b.branch();
+ // do not add it if we've already seen it
+ if (brset.count(bname))
+ continue;
- BranchList::const_iterator ccit = params.branchlist().begin();
- BranchList::const_iterator cend = params.branchlist().end();
+ docstring label = convert<docstring>(ii) + ". " + bname + char_type('|');
+ if (ii < 10)
+ label += convert<docstring>(ii);
- for (int ii = 1; ccit != cend; ++ccit, ++ii) {
- docstring label = ccit->branch();
- if (ii < 10) {
- label = convert<docstring>(ii) + ". " + label
- + char_type('|') + convert<docstring>(ii);
- } else
- label += char_type('|');
- child_branches.addWithStatusCheck(MenuItem(MenuItem::Command,
- toqstr(label),
- FuncRequest(LFUN_BRANCH_INSERT,
- ccit->branch())));
+ master_branches.addWithStatusCheck(MenuItem(MenuItem::Command,
+ toqstr(label), FuncRequest(LFUN_BRANCH_INSERT, bname)));
+
+ bufset.insert(nextbuf);
+ brset.insert(bname);
+ ++ii;
+ }
+
+ nextbuf = nextbuf->parent();
}
- if (!child_branches.empty()) {
- MenuItem item(MenuItem::Submenu, qt_("Child Document"));
- item.setSubmenu(child_branches);
+ if (!master_branches.empty()) {
+ MenuItem item(MenuItem::Submenu, qt_("Master Documents"));
+ item.setSubmenu(master_branches);
add(item);
}
}
static_cast<InsetCitation const *>(inset);
Buffer const * buf = &bv->buffer();
- BufferParams const & bp = buf->params();
+ BufferParams const & bp = buf->masterParams();
string const cmd = citinset->params().getCmdName();
docstring const & key = citinset->getParam("key");
vector<docstring> const keys = getVectorFromString(key);
- vector<CitationStyle> const citeStyleList = buf->params().citeStyles();
+ vector<CitationStyle> const citeStyleList = bp.citeStyles();
+
+ CitationStyle cs = citinset->getCitationStyle(bp, cmd, citeStyleList);
+ bool const qualified = cs.hasQualifiedList
+ && (keys.size() > 1
+ || !citinset->getParam("pretextlist").empty()
+ || !citinset->getParam("posttextlist").empty());
+ std::map<docstring, docstring> pres =
+ citinset->getQualifiedLists(citinset->getParam("pretextlist"));
+ std::map<docstring, docstring> posts =
+ citinset->getQualifiedLists(citinset->getParam("posttextlist"));
+
CiteItem ci;
ci.textBefore = citinset->getParam("before");
ci.textAfter = citinset->getParam("after");
ci.Starred = star;
ci.context = CiteItem::Dialog;
ci.max_size = 40;
- vector<docstring> citeStrings =
+ ci.isQualified = qualified;
+ ci.pretexts = pres;
+ ci.posttexts = posts;
+ BiblioInfo::CiteStringMap citeStrings =
buf->masterBibInfo().getCiteStrings(keys, citeStyleList, bv->buffer(), ci);
- vector<docstring>::const_iterator cit = citeStrings.begin();
- vector<docstring>::const_iterator end = citeStrings.end();
+ BiblioInfo::CiteStringMap::const_iterator cit = citeStrings.begin();
+ BiblioInfo::CiteStringMap::const_iterator end = citeStrings.end();
for (int ii = 1; cit != end; ++cit, ++ii) {
- docstring label = *cit;
- CitationStyle cs = citeStyleList[ii - 1];
- cs.forceUpperCase &= force;
- cs.hasStarredVersion &= star;
+ docstring label = cit->second;
+ CitationStyle ccs = citeStyleList[ii - 1];
+ ccs.forceUpperCase &= force;
+ ccs.hasStarredVersion &= star;
addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(label),
FuncRequest(LFUN_INSET_MODIFY,
- "changetype " + from_utf8(citationStyleToString(cs)))));
+ "changetype " + from_utf8(citationStyleToString(ccs)))));
}
- // Extra features of the citation styles
- CitationStyle cs = citinset->getCitationStyle(bp, cmd, citeStyleList);
-
if (cs.hasStarredVersion) {
docstring starred = _("All authors|h");
// Check if we have a custom string/tooltip for the starred version
if (amps > 0) {
if (amps > 1)
starred = subst(starred, from_ascii("&&"), from_ascii("<:amp:>"));
- size_t n = starred.find('&');
+ size_t nn = starred.find('&');
char_type accel = char_type();
- if (n != docstring::npos && n < starred.size() - 1)
- accel = starred[n + 1];
+ if (nn != docstring::npos && nn < starred.size() - 1)
+ accel = starred[nn + 1];
starred = subst(starred, from_ascii("&"), from_ascii(""));
if (amps > 1)
starred = subst(starred, from_ascii("<:amp:>"), from_ascii("&&"));
}
+void MenuDefinition::expandInfoArguments(BufferView const * bv)
+{
+ if (!bv)
+ return;
+
+ Inset const * inset = bv->cursor().nextInset();
+ if (!inset || inset->lyxCode() != INFO_CODE) {
+ add(MenuItem(MenuItem::Command,
+ qt_("No Text Field in Scope!"),
+ FuncRequest(LFUN_NOACTION)));
+ return;
+ }
+ InsetInfo const * iinset = static_cast<InsetInfo const *>(inset);
+
+ string const type = iinset->params().infoType();
+ vector<pair<string,docstring>> const args =
+ iinset->params().getArguments(&bv->buffer(), type);
+
+ // Don't generate a menu for big lists (such as lfuns and rcs)
+ if (args.size() > 15)
+ return;
+
+ for (auto const & p : args) {
+ if (p.first == "invalid")
+ // non-selectable
+ continue;
+ if (p.first == "custom") {
+ add(MenuItem(MenuItem::Command, qt_("Custom..."),
+ FuncRequest(LFUN_INSET_SETTINGS, "info")));
+ continue;
+ }
+ docstring label = p.second;
+ addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(label),
+ FuncRequest(LFUN_INSET_MODIFY, type + " " + p.first)));
+ }
+}
+
+
+
void MenuDefinition::expandArguments(BufferView const * bv, bool switcharg)
{
if (!bv)
for (pair<docstring, InsetLayout> const & il : dc.insetLayouts()) {
docstring instype;
docstring const type = split(il.first, instype, ':');
- if (instype == "Caption") {
+ if (instype == from_ascii("Caption")) {
// skip forbidden caption types
FuncRequest const cmd = switchcap
? FuncRequest(LFUN_INSET_MODIFY, from_ascii("changetype ") + type)
{
if (!bv)
return;
-
+
if (!bv->cursor().inTexted())
return;
map<string, docstring> styles = quoteparams.getTypes();
string const qtype = qinset->getType();
-
+
map<string, docstring>::const_iterator qq = styles.begin();
map<string, docstring>::const_iterator end = styles.end();
docstring const style = from_ascii(qq->first);
bool langdef = (style[0] == langqs);
bool globaldef = (style[0] == globalqsc);
-
+
if (prefixIs(style, qtype[0])) {
FuncRequest cmd = FuncRequest(LFUN_INSET_MODIFY, subcmd + style);
docstring const desc = quoteparams.getShortGuiLabel(style);
add(MenuItem(MenuItem::Separator));
- bool have_section = false;
bool display_static = false;
// ... then potentially items to reset to the defaults and to dynamic style ...
if (!main_dynamic_qs && globalqsc != 'x') {
docstring const desc = bformat(_("Use dynamic quotes (%1$s)|d"),
quoteparams.getGuiLabel(globalqs));
add(MenuItem(MenuItem::Command, toqstr(desc), cmd));
- have_section = true;
display_static = true;
}
if (!main_global_qs && langdefqs != globalqs) {
docstring const desc = bformat(_("Reset to document default (%1$s, %2$s)|o"),
quoteparams.getGuiLabel(globalqs), variant);
add(MenuItem(MenuItem::Command, toqstr(desc), cmd));
- have_section = true;
}
if (!main_langdef_qs) {
FuncRequest cmd = FuncRequest(LFUN_INSET_MODIFY, subcmd + globalqsc + wildcards);
- docstring const desc = (main_dynamic_qs || display_static)
+ docstring const desc = (main_dynamic_qs || display_static)
? bformat(_("Reset to language default (%1$s, %2$s)|l"),
quoteparams.getGuiLabel(langdefqs), _("static[[Quotes]]"))
: bformat(_("Reset to language default (%1$s)|l"),
quoteparams.getGuiLabel(langdefqs));
add(MenuItem(MenuItem::Command, toqstr(desc), cmd));
- have_section = true;
}
- if (have_section)
- add(MenuItem(MenuItem::Separator));
+ add(MenuItem(MenuItem::Separator));
// ... and a subitem with the rest
MenuItem item(MenuItem::Submenu, qt_("Change Style|y"));
}
-void MenuDefinition::expandEnvironmentSeparators(BufferView const * bv)
+void MenuDefinition::expandEnvironmentSeparators(BufferView const * bv,
+ bool contextmenu)
{
if (!bv)
return;
Paragraph const & par = text->getPar(pit);
docstring const curlayout = par.layout().name();
docstring outerlayout;
+ docstring prevlayout;
depth_type current_depth = par.params().depth();
- // check if we have an environment in our nesting hierarchy
+ // check if we have an environment in our scope
Paragraph cpar = par;
while (true) {
- if (pit == 0 || cpar.params().depth() == 0)
+ if (pit == 0)
break;
--pit;
cpar = text->getPar(pit);
+ if (cpar.layout().isEnvironment() && prevlayout.empty()
+ && cpar.params().depth() <= current_depth)
+ prevlayout = cpar.layout().name();
if (cpar.params().depth() < current_depth
&& cpar.layout().isEnvironment()) {
outerlayout = cpar.layout().name();
current_depth = cpar.params().depth();
}
+ if (cpar.params().depth() == 0)
+ break;
}
if (par.layout().isEnvironment()) {
- docstring const label =
- bformat(_("Start New Environment (%1$s)"),
- translateIfPossible(curlayout));
+ docstring label = contextmenu ?
+ bformat(_("Insert Separated %1$s Above"),
+ translateIfPossible(curlayout)) :
+ bformat(_("Separated %1$s Above"),
+ translateIfPossible(curlayout));
add(MenuItem(MenuItem::Command, toqstr(label),
- FuncRequest(LFUN_ENVIRONMENT_SPLIT)));
+ FuncRequest(LFUN_ENVIRONMENT_SPLIT,
+ from_ascii("before"))));
+ label = contextmenu ?
+ bformat(_("Insert Separated %1$s Below"),
+ translateIfPossible(curlayout)):
+ bformat(_("Separated %1$s Below"),
+ translateIfPossible(curlayout));
+ // We use command-alternatives here since this is how the binding is defined
+ // (otherwise, the binding is not displayed in the menu)
+ if (getStatus(FuncRequest(LFUN_ENVIRONMENT_SPLIT)).enabled())
+ add(MenuItem(MenuItem::Command, toqstr(label),
+ FuncRequest(LFUN_COMMAND_ALTERNATIVES,
+ from_ascii("environment-split ; environment-split previous"))));
+ }
+ else if (!prevlayout.empty()) {
+ docstring const label = contextmenu ?
+ bformat(_("Insert Separated %1$s Below"),
+ translateIfPossible(prevlayout)) :
+ bformat(_("Separated %1$s Below"),
+ translateIfPossible(prevlayout));
+ // We use command-alternatives here since this is how the binding is defined
+ // (otherwise, the binding is not displayed in the menu)
+ if (getStatus(FuncRequest(LFUN_ENVIRONMENT_SPLIT)).enabled())
+ add(MenuItem(MenuItem::Command, toqstr(label),
+ FuncRequest(LFUN_COMMAND_ALTERNATIVES,
+ from_ascii("environment-split ; environment-split previous"))));
}
if (!outerlayout.empty()) {
- docstring const label =
- bformat(_("Start New Parent Environment (%1$s)"),
- translateIfPossible(outerlayout));
+ docstring label;
+ if (contextmenu) {
+ label = (outerlayout == curlayout) ?
+ bformat(_("Insert Separated Outer %1$s Below"),
+ translateIfPossible(outerlayout)) :
+ bformat(_("Insert Separated %1$s Below"),
+ translateIfPossible(outerlayout));
+ } else {
+ label = (outerlayout == curlayout) ?
+ bformat(_("Separated Outer %1$s Below"),
+ translateIfPossible(outerlayout)) :
+ bformat(_("Separated %1$s Below"),
+ translateIfPossible(outerlayout));
+ }
add(MenuItem(MenuItem::Command, toqstr(label),
FuncRequest(LFUN_ENVIRONMENT_SPLIT,
from_ascii("outer"))));
}
}
-} // namespace anon
+} // namespace
/////////////////////////////////////////////////////////////////////
tomenu.expandFormats(cit->kind(), buf);
break;
+ case MenuItem::ExportFormat: {
+ if (!buf)
+ break;
+ string const format = buf->params().getDefaultOutputFormat();
+ Format const * f = theFormats().getFormat(format);
+ docstring const name = f ? f->prettyname() : from_utf8(format);
+ docstring const label = bformat(_("Export [%1$s]|E"), name);
+ MenuItem item(MenuItem::Command, toqstr(label),
+ FuncRequest(LFUN_BUFFER_EXPORT));
+ tomenu.addWithStatusCheck(item);
+ break;
+ }
+
case MenuItem::CharStyles:
tomenu.expandFlexInsert(buf, InsetLayout::CHARSTYLE);
break;
tomenu.expandCiteStyles(bv);
break;
+ case MenuItem::InfoArguments:
+ tomenu.expandInfoArguments(bv);
+ break;
+
+
case MenuItem::Toc:
tomenu.expandToc(buf);
break;
tomenu.expandEnvironmentSeparators(bv);
break;
+ case MenuItem::EnvironmentSeparatorsContext:
+ tomenu.expandEnvironmentSeparators(bv, true);
+ break;
+
case MenuItem::SwitchQuotes:
tomenu.expandQuotes(bv);
break;
bool Menus::searchMenu(FuncRequest const & func,
- docstring_list & names) const
+ docstring_list & names, BufferView const * bv) const
{
MenuDefinition menu;
- d->expand(d->menubar_, menu, 0);
+ d->expand(d->menubar_, menu, bv);
return menu.searchMenu(func, names);
}
continue;
}
- Menu * menu = new Menu(view, m->submenuname(), true);
- menu->setTitle(label(*m));
+ Menu * menuptr = new Menu(view, m->submenuname(), true);
+ menuptr->setTitle(label(*m));
#if defined(Q_OS_MAC) && (defined(QT_MAC_USE_COCOA) || (QT_VERSION >= 0x050000))
// On Mac OS with QT/cocoa, the menu is not displayed if there is no action
// so we create a temporary one here
- QAction * action = new QAction(menu);
- menu->addAction(action);
+ QAction * action = new QAction(menuptr);
+ menuptr->addAction(action);
#endif
- qmb->addMenu(menu);
+ qmb->addMenu(menuptr);
- d->name_map_[view][name] = menu;
+ d->name_map_[view][name] = menuptr;
}
}
projects / lyx.git / blobdiff