#include "insets/Inset.h"
#include "insets/InsetCitation.h"
#include "insets/InsetGraphics.h"
+#include "insets/InsetQuotes.h"
#include "support/lassert.h"
#include "support/convert.h"
#include <QProxyStyle>
#endif
-#include "support/shared_ptr.h"
-
#include <algorithm>
+#include <memory>
#include <vector>
using namespace std;
in the InsetCaption context menu. */
SwitchCaptions,
/** Commands to separate environments. */
- EnvironmentSeparators
+ EnvironmentSeparators,
+ /** This is the list of quotation marks available */
+ SwitchQuotes
};
explicit MenuItem(Kind kind) : kind_(kind), optional_(false) {}
QString const & submenu = QString(),
QString const & tooltip = QString(),
bool optional = false)
- : kind_(kind), label_(label), submenuname_(submenu),
- tooltip_(tooltip), optional_(optional)
+ : kind_(kind), label_(label), func_(make_shared<FuncRequest>()),
+ submenuname_(submenu), tooltip_(tooltip), optional_(optional)
{
LATTEST(kind == Submenu || kind == Help || kind == Info);
}
QString const & tooltip = QString(),
bool optional = false,
FuncRequest::Origin origin = FuncRequest::MENU)
- : kind_(kind), label_(label), func_(func),
+ : kind_(kind), label_(label), func_(make_shared<FuncRequest>(func)),
tooltip_(tooltip), optional_(optional)
{
- func_.setOrigin(origin);
+ func_->setOrigin(origin);
}
- // shared_ptr<MenuDefinition> needs this apprently...
- ~MenuItem() {}
-
/// The label of a given menuitem
QString label() const
{
/// The kind of entry
Kind kind() const { return kind_; }
/// the action (if relevant)
- FuncRequest const & func() const { return func_; }
+ shared_ptr<FuncRequest const> func() const { return func_; }
/// the tooltip
QString const & tooltip() const { return tooltip_; }
/// returns true if the entry should be omitted when disabled
return QString();
// Get the keys bound to this action, but keep only the
// first one later
- KeyMap::Bindings bindings = theTopLevelKeymap().findBindings(func_);
+ KeyMap::Bindings bindings = theTopLevelKeymap().findBindings(*func_);
if (!bindings.empty())
return toqstr(bindings.begin()->print(KeySequence::ForGui));
LYXERR(Debug::KBMAP, "No binding for "
- << lyxaction.getActionName(func_.action())
- << '(' << func_.argument() << ')');
+ << lyxaction.getActionName(func_->action())
+ << '(' << func_->argument() << ')');
return QString();
}
///
QString label_;
///
- FuncRequest func_;
+ shared_ptr<FuncRequest> func_;// non-null
///
QString submenuname_;
///
///
size_t size() const { return items_.size(); }
///
- MenuItem const & operator[](size_t) const;
- ///
const_iterator begin() const { return items_.begin(); }
///
const_iterator end() const { return items_.end(); }
void expandFloatListInsert(Buffer const * buf);
void expandFloatInsert(Buffer const * buf);
void expandFlexInsert(Buffer const * buf, InsetLayout::InsetLyXType type);
- void expandToc2(Toc const & toc_list, size_t from, size_t to, int depth);
+ 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 expandToolbars();
void expandArguments(BufferView const *, bool switcharg = false);
void expandCaptions(Buffer const * buf, bool switchcap = false);
void expandEnvironmentSeparators(BufferView const *);
+ void expandQuotes(BufferView const *);
///
ItemList items_;
///
switch (i.kind()) {
case MenuItem::Command: {
- FuncStatus status = lyx::getStatus(i.func());
+ FuncStatus status = lyx::getStatus(*i.func());
if (status.unknown() || (!status.enabled() && i.optional()))
break;
items_.push_back(i);
cit != i.submenu().end(); ++cit) {
// Only these kind of items affect the status of the submenu
if ((cit->kind() == MenuItem::Command
- || cit->kind() == MenuItem::Submenu
- || cit->kind() == MenuItem::Help)) {
+ || cit->kind() == MenuItem::Submenu
+ || cit->kind() == MenuItem::Help)
+ && cit->status().enabled()) {
enabled = true;
break;
}
md_switcharguments,
md_captions,
md_switchcaptions,
- md_env_separators
+ md_env_separators,
+ md_switchquotes
};
LexerKeyword menutags[] = {
{ "submenu", md_submenu },
{ "switcharguments", md_switcharguments },
{ "switchcaptions", md_switchcaptions },
+ { "switchquotes", md_switchquotes },
{ "toc", md_toc },
{ "toolbars", md_toolbars },
{ "updateformats", md_updateformats },
add(MenuItem(MenuItem::EnvironmentSeparators));
break;
+ case md_switchquotes:
+ add(MenuItem(MenuItem::SwitchQuotes));
+ break;
+
case md_optsubmenu:
case md_submenu: {
lex.next(true);
}
-MenuItem const & MenuDefinition::operator[](size_type i) const
-{
- return items_[i];
-}
-
-
bool MenuDefinition::hasFunc(FuncRequest const & func) const
{
for (const_iterator it = begin(), et = end(); it != et; ++it)
- if (it->func() == func)
+ if (*it->func() == func)
return true;
return false;
}
const_iterator m = begin();
const_iterator m_end = end();
for (; m != m_end; ++m) {
- if (m->kind() == MenuItem::Command && m->func() == func) {
+ if (m->kind() == MenuItem::Command && *m->func() == func) {
names.push_back(qstring_to_ucs4(m->label()));
return true;
}
QString limitStringLength(docstring const & str)
{
size_t const max_item_length = 45;
-
- if (str.size() > max_item_length)
- return toqstr(str.substr(0, max_item_length - 3) + "...");
-
- return toqstr(str);
+ docstring ret = str.substr(0, max_item_length + 1);
+ support::truncateWithEllipsis(ret, max_item_length);
+ return toqstr(ret);
}
if (!buf && kind != MenuItem::ImportFormats)
return;
- typedef vector<Format const *> Formats;
- Formats formats;
+ FormatList formats;
FuncCode action = LFUN_NOACTION;
switch (kind) {
LATTEST(false);
return;
}
- sort(formats.begin(), formats.end(), Format::formatSorter);
bool const view_update = (kind == MenuItem::ViewFormats
|| kind == MenuItem::UpdateFormats);
MenuItem item(MenuItem::Submenu, smenue);
item.setSubmenu(MenuDefinition(smenue));
- Formats::const_iterator fit = formats.begin();
- Formats::const_iterator end = formats.end();
- for (; fit != end ; ++fit) {
- if ((*fit)->dummy())
+ for (Format const * f : formats) {
+ if (f->dummy())
continue;
- docstring lab = from_utf8((*fit)->prettyname());
- docstring const scut = from_utf8((*fit)->shortcut());
+ docstring lab = f->prettyname();
+ docstring const scut = from_utf8(f->shortcut());
docstring const tmplab = lab;
if (!scut.empty())
break;
case MenuItem::ViewFormats:
case MenuItem::UpdateFormats:
- if ((*fit)->name() == buf->params().getDefaultOutputFormat()) {
+ if (f->name() == buf->params().getDefaultOutputFormat()) {
docstring lbl = (kind == MenuItem::ViewFormats
? bformat(_("View [%1$s]|V"), label)
: bformat(_("Update [%1$s]|U"), label));
}
// fall through
case MenuItem::ExportFormats:
- if (!(*fit)->inExportMenu())
+ if (!f->inExportMenu())
continue;
break;
default:
label += '|' + shortcut;
if (view_update) {
- if (buf)
- item.submenu().addWithStatusCheck(MenuItem(MenuItem::Command,
- toqstr(label), FuncRequest(action, (*fit)->name())));
- else
- item.submenu().add(MenuItem(MenuItem::Command, toqstr(label),
- FuncRequest(action, (*fit)->name())));
+ // note that at this point, we know that buf is not null
+ LATTEST(buf);
+ item.submenu().addWithStatusCheck(MenuItem(MenuItem::Command,
+ toqstr(label), FuncRequest(action, f->name())));
} else {
if (buf)
addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(label),
- FuncRequest(action, (*fit)->name())));
+ FuncRequest(action, f->name())));
else
add(MenuItem(MenuItem::Command, toqstr(label),
- FuncRequest(action, (*fit)->name())));
+ FuncRequest(action, f->name())));
}
}
if (view_update)
TextClass::InsetLayouts::const_iterator end = insetLayouts.end();
for (; cit != end; ++cit) {
if (cit->second.lyxtype() == type) {
+ if (!cit->second.obsoleted_by().empty())
+ continue;
docstring label = cit->first;
// we remove the "Flex:" prefix, if it is present
- if (prefixIs(label, from_utf8("Flex:")))
+ if (prefixIs(label, from_ascii("Flex:")))
label = label.substr(5);
addWithStatusCheck(MenuItem(MenuItem::Command,
toqstr(translateIfPossible(label)),
}
-size_t const max_number_of_items = 25;
+// Threshold before we stop displaying sub-items alongside items
+// (for display purposes). Ideally this should fit on a screen.
+size_t const max_number_of_items = 30;
+// Size limit for the menu. This is for performance purposes,
+// because qt already displays a scrollable menu when necessary.
+// Ideally this should be the menu size from which scrollable
+// menus become unpractical.
+size_t const menu_size_limit = 80;
void MenuDefinition::expandToc2(Toc const & toc_list,
- size_t from, size_t to, int depth)
+ size_t from, size_t to, int depth,
+ string toc_type)
{
int shortcut_count = 0;
if (to - from <= max_number_of_items) {
for (size_t i = from; i < to; ++i) {
QString label(4 * max(0, toc_list[i].depth() - depth), ' ');
- label += limitStringLength(toc_list[i].str());
+ label += limitStringLength(toc_list[i].asString());
if (toc_list[i].depth() == depth) {
label += '|';
if (shortcut_count < 9) {
}
add(MenuItem(MenuItem::Command, label,
FuncRequest(toc_list[i].action())));
+ // separator after the menu heading
+ if (toc_list[i].depth() < depth)
+ add(MenuItem(MenuItem::Separator));
}
} else {
size_t pos = from;
+ size_t size = 1;
while (pos < to) {
size_t new_pos = pos + 1;
while (new_pos < to && toc_list[new_pos].depth() > depth)
++new_pos;
QString label(4 * max(0, toc_list[pos].depth() - depth), ' ');
- label += limitStringLength(toc_list[pos].str());
+ label += limitStringLength(toc_list[pos].asString());
if (toc_list[pos].depth() == depth) {
label += '|';
if (shortcut_count < 9) {
label += QString::number(++shortcut_count);
}
}
+ if (size >= menu_size_limit) {
+ FuncRequest f(LFUN_DIALOG_SHOW, "toc " + toc_type);
+ add(MenuItem(MenuItem::Command, "...", f));
+ break;
+ }
if (new_pos == pos + 1) {
add(MenuItem(MenuItem::Command,
label, FuncRequest(toc_list[pos].action())));
} else {
MenuDefinition sub;
- sub.expandToc2(toc_list, pos, new_pos, depth + 1);
+ sub.expandToc2(toc_list, pos, new_pos, depth + 1, toc_type);
MenuItem item(MenuItem::Submenu, label);
item.setSubmenu(sub);
add(item);
}
+ ++size;
pos = new_pos;
}
}
// 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) {
- add(MenuItem(MenuItem::Info, qt_("<No Document Open>")));
+ add(MenuItem(MenuItem::Info, qt_("(No Document Open)")));
return;
}
-
// Add an entry for the master doc if this is a child doc
Buffer const * const master = buf->masterBuffer();
if (buf != master) {
}
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) {
- // Handle this later
- if (cit->first == "tableofcontents")
+ // Handle table of contents later
+ if (cit->first == "tableofcontents" || cit->second->empty())
continue;
-
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())));
- }
- }
-
+ // "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()));
item.setSubmenu(submenu);
- if (floatlist.typeExist(cit->first) || cit->first == "child") {
- // Those two types deserve to be in the main menu.
- item.setSubmenu(submenu);
+ // deserves to be in the main menu?
+ if (floatlist.typeExist(cit->first) || cit->first == "child")
add(item);
- } else
+ else
other_lists.add(item);
}
if (!other_lists.empty()) {
item.setSubmenu(other_lists);
add(item);
}
-
// Handle normal TOC
+ add(MenuItem(MenuItem::Separator));
cit = toc_list.find("tableofcontents");
if (cit == end)
LYXERR(Debug::GUI, "No table of contents.");
else {
- if (!cit->second.empty())
- expandToc2(cit->second, 0, cit->second.size(), 0);
+ if (!cit->second->empty())
+ expandToc2(*cit->second, 0, cit->second->size(), 0,
+ "tableofcontents");
else
- add(MenuItem(MenuItem::Info, qt_("<Empty Table of Contents>")));
+ add(MenuItem(MenuItem::Info, qt_("(Empty Table of Contents)")));
}
}
return;
}
- 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] == '*';
+ bool const force = isUpperCase(cmd[0]);
+ bool const star = cmd[n] == '*';
vector<docstring> const keys = getVectorFromString(key);
vector<CitationStyle> const citeStyleList = buf->params().citeStyles();
- static const size_t max_length = 40;
+ CiteItem ci;
+ ci.textBefore = citinset->getParam("before");
+ ci.textAfter = citinset->getParam("after");
+ ci.context = CiteItem::Dialog;
+ ci.max_size = 40;
vector<docstring> citeStrings =
- buf->masterBibInfo().getCiteStrings(keys, citeStyleList, bv->buffer(),
- before, after, from_utf8("dialog"), max_length);
+ buf->masterBibInfo().getCiteStrings(keys, citeStyleList, bv->buffer(), ci);
vector<docstring>::const_iterator cit = citeStrings.begin();
vector<docstring>::const_iterator end = citeStrings.end();
docstring label = *cit;
CitationStyle cs = citeStyleList[ii - 1];
cs.forceUpperCase &= force;
- cs.fullAuthorList &= full;
+ cs.hasStarredVersion &= star;
addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(label),
FuncRequest(LFUN_INSET_MODIFY,
"changetype " + from_utf8(citationStyleToString(cs)))));
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);
+ vector< pair<docstring, FuncRequest> > caps;
+ for (pair<docstring, InsetLayout> const & il : dc.insetLayouts()) {
+ docstring instype;
+ docstring const type = split(il.first, instype, ':');
+ if (instype == "Caption") {
+ // skip forbidden caption types
+ FuncRequest const cmd = switchcap
+ ? FuncRequest(LFUN_INSET_MODIFY, from_ascii("changetype ") + type)
+ : FuncRequest(LFUN_CAPTION_INSERT, type);
+ if (getStatus(cmd).enabled())
+ caps.push_back(make_pair(type, cmd));
+ }
}
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))));
+ add(MenuItem(MenuItem::Command, qt_("Caption"), caps.front().second));
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, ':');
+ for (pair<docstring, FuncRequest> const & cap : caps) {
+ docstring const type = cap.first;
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));
+ add(MenuItem(MenuItem::Command, toqstr(cmitem), cap.second));
else
- captions.addWithStatusCheck(MenuItem(MenuItem::Command,
- toqstr(trtype),
- FuncRequest(LFUN_CAPTION_INSERT,
- type), QString(), true));
+ captions.add(MenuItem(MenuItem::Command, toqstr(trtype), cap.second));
}
if (!captions.empty()) {
MenuItem item(MenuItem::Submenu, qt_("Caption"));
}
+void MenuDefinition::expandQuotes(BufferView const * bv)
+{
+ if (!bv)
+ return;
+
+ if (!bv->cursor().inTexted())
+ return;
+
+ Inset const * inset = bv->cursor().nextInset();
+ if (!inset || inset->lyxCode() != QUOTE_CODE) {
+ add(MenuItem(MenuItem::Command,
+ qt_("No Quote in Scope!"),
+ FuncRequest(LFUN_NOACTION)));
+ return;
+ }
+ InsetQuotes const * qinset =
+ static_cast<InsetQuotes const *>(inset);
+
+ 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();
+
+ MenuDefinition aqs;
+
+ BufferParams const & bp = bv->buffer().masterBuffer()->params();
+
+ // The global setting
+ InsetQuotesParams::QuoteStyle globalqs = bp.quotes_style;
+ char const globalqsc = quoteparams.getStyleChar(globalqs);
+
+ // The current language's default
+ InsetQuotesParams::QuoteStyle langdefqs =
+ bp.getQuoteStyle(bv->cursor().current_font.language()->quoteStyle());
+ char const langqs = quoteparams.getStyleChar(langdefqs);
+
+ bool main_global_qs = false;
+ bool main_langdef_qs = false;
+ bool main_dynamic_qs = false;
+ docstring const subcmd = from_ascii("changetype ");
+ docstring const wildcards = from_ascii("..");
+ // Add the items
+ // First the top level menu (all glyphs of the current style) ...
+ // Begin with dynamic (if they are current style),
+ if (qtype[0] == 'x') {
+ FuncRequest cmd = FuncRequest(LFUN_INSET_MODIFY, subcmd + from_ascii("xld"));
+ docstring desc = bformat(_("%1$s (dynamic)"),
+ quoteparams.getShortGuiLabel(globalqsc + from_ascii("ld")));
+ add(MenuItem(MenuItem::Command, toqstr(desc), cmd));
+ cmd = FuncRequest(LFUN_INSET_MODIFY, subcmd + from_ascii("xls"));
+ desc = bformat(_("%1$s (dynamic)"),
+ quoteparams.getShortGuiLabel(globalqsc + from_ascii("ls")));
+ add(MenuItem(MenuItem::Command, toqstr(desc), cmd));
+ cmd = FuncRequest(LFUN_INSET_MODIFY, subcmd + from_ascii("xrd"));
+ desc = bformat(_("%1$s (dynamic)"),
+ quoteparams.getShortGuiLabel(globalqsc + from_ascii("rd")));
+ add(MenuItem(MenuItem::Command, toqstr(desc), cmd));
+ cmd = FuncRequest(LFUN_INSET_MODIFY, subcmd + from_ascii("xrs"));
+ desc = bformat(_("%1$s (dynamic)"),
+ quoteparams.getShortGuiLabel(globalqsc + from_ascii("rs")));
+ add(MenuItem(MenuItem::Command, toqstr(desc), cmd));
+ main_dynamic_qs = true;
+ }
+ // now traverse through the static styles ...
+ for (; qq != end; ++qq) {
+ 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::Command, toqstr(desc), cmd));
+ main_global_qs = globaldef;
+ main_langdef_qs = langdef;
+ }
+ else if (!langdef && !globaldef && suffixIs(style, from_ascii("ld"))) {
+ docstring const desc =
+ quoteparams.getGuiLabel(quoteparams.getQuoteStyle(to_ascii(style)));
+ FuncRequest cmd = FuncRequest(LFUN_INSET_MODIFY, subcmd + style[0] + "..");
+ aqs.add(MenuItem(MenuItem::Command, toqstr(desc), cmd));
+ }
+ }
+
+ 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') {
+ FuncRequest cmd = FuncRequest(LFUN_INSET_MODIFY, subcmd + 'x' + wildcards);
+ 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 variant = main_dynamic_qs ? _("dynamic[[Quotes]]") : _("static[[Quotes]]");
+ FuncRequest cmd = FuncRequest(LFUN_INSET_MODIFY, subcmd + globalqsc + wildcards);
+ 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)
+ ? 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));
+
+ // ... and a subitem with the rest
+ MenuItem item(MenuItem::Submenu, qt_("Change Style|y"));
+ item.setSubmenu(aqs);
+ add(item);
+}
+
+
void MenuDefinition::expandEnvironmentSeparators(BufferView const * bv)
{
if (!bv)
{
/// populates the menu or one of its submenu
/// This is used as a recursive function
- void populate(QMenu & qMenu, MenuDefinition const & 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 const & menu)
+void Menu::Impl::populate(QMenu * qMenu, MenuDefinition const & menu)
{
LYXERR(Debug::GUI, "populating menu " << menu.name());
if (menu.empty()) {
return;
}
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();
- else if (m->kind() == MenuItem::Submenu) {
- QMenu * subMenu = qMenu.addMenu(label(*m));
- populate(*subMenu, m->submenu());
- subMenu->setEnabled(m->status().enabled());
- } else {
- // we have a MenuItem::Command
- qMenu.addAction(new Action(QIcon(), label(*m),
- m->func(), m->tooltip(), &qMenu));
+ for (MenuItem const & m : menu)
+ switch (m.kind()) {
+ case MenuItem::Separator:
+ qMenu->addSeparator();
+ break;
+ case MenuItem::Submenu: {
+ QMenu * subMenu = qMenu->addMenu(label(m));
+ populate(subMenu, m.submenu());
+ subMenu->setEnabled(!subMenu->isEmpty());
+ break;
+ }
+ case MenuItem::Command:
+ default:
+ // FIXME: A previous comment assured that MenuItem::Command was the
+ // only possible case in practice, but this is wrong. It would be
+ // good to document which cases are actually treated here.
+ qMenu->addAction(new Action(m.func(), QIcon(), label(m),
+ m.tooltip(), qMenu));
+ break;
}
- }
}
-#if defined(Q_WS_WIN) && (QT_VERSION >= 0x040600)
+#if (defined(Q_OS_WIN) || defined(Q_CYGWIN_WIN)) && (QT_VERSION >= 0x040600)
class AlwaysMnemonicStyle : public QProxyStyle {
public:
int styleHint(StyleHint hint, const QStyleOption *opt = 0, const QWidget *widget = 0,
Menu::Menu(GuiView * gv, QString const & name, bool top_level, bool keyboard)
: QMenu(gv), d(new Menu::Impl)
{
-#if defined(Q_WS_WIN) && (QT_VERSION >= 0x040600)
+#if (defined(Q_OS_WIN) || defined(Q_CYGWIN_WIN)) && (QT_VERSION >= 0x040600)
if (keyboard)
setStyle(new AlwaysMnemonicStyle);
#else
QAction::MenuRole role;
};
- static MacMenuEntry entries[] = {
+ static const MacMenuEntry entries[] = {
{LFUN_DIALOG_SHOW, "aboutlyx", "About LyX",
QAction::AboutRole},
{LFUN_DIALOG_SHOW, "prefs", "Preferences",
const size_t num_entries = sizeof(entries) / sizeof(entries[0]);
const bool first_call = mac_special_menu_.empty();
+ LYXERR(Debug::GUI, "Creating Mac OS X special menu bar");
// the special menu for Menus. Fill it up only once.
if (first_call) {
for (size_t i = 0 ; i < num_entries ; ++i) {
// add the entries to a QMenu that will eventually be empty
// and therefore invisible.
QMenu * qMenu = qmb->addMenu("special");
- MenuDefinition::const_iterator cit = mac_special_menu_.begin();
- MenuDefinition::const_iterator end = mac_special_menu_.end();
- for (size_t i = 0 ; cit != end ; ++cit, ++i) {
- Action * action = new Action(QIcon(), cit->label(),
- cit->func(), QString(), qMenu);
+ size_t i = 0;
+ for (MenuItem const & m : mac_special_menu_) {
+ Action * action = new Action(m.func(), QIcon(), m.label(),
+ QString(), qMenu);
action->setMenuRole(entries[i].role);
qMenu->addAction(action);
+ ++i;
}
}
tomenu.expandEnvironmentSeparators(bv);
break;
+ case MenuItem::SwitchQuotes:
+ tomenu.expandQuotes(bv);
+ break;
+
case MenuItem::Submenu: {
MenuItem item(*cit);
item.setSubmenu(MenuDefinition(cit->submenuname()));
break;
case MenuItem::Command:
- if (!mac_special_menu_.hasFunc(cit->func()))
+ if (!mac_special_menu_.hasFunc(*cit->func()))
tomenu.addWithStatusCheck(*cit);
}
}
Menus::~Menus()
{
- delete d;
+ delete d;
}
void Menus::fillMenuBar(QMenuBar * qmb, GuiView * view, bool initial)
{
if (initial) {
-#ifdef Q_WS_MACX
+#ifdef Q_OS_MAC
// setup special mac specific menu items, but only do this
// the first time a QMenuBar is created. Otherwise Qt will
// 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(qmb);
#endif
} else {
// Clear all menubar contents before filling it.
qmb->clear();
+#if (QT_VERSION >= 0x050000 && defined(Q_OS_MAC))
+ d->macxMenuBarInit(qmb);
+#endif
}
LYXERR(Debug::GUI, "populating menu bar" << d->menubar_.name());
Menu * menu = new Menu(view, m->submenuname(), true);
menu->setTitle(label(*m));
-#if defined(Q_WS_MACX) && (defined(QT_MAC_USE_COCOA) || (QT_VERSION >= 0x050000))
+#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);
if (qmenu->d->view)
bv = qmenu->d->view->currentBufferView();
d->expand(fromLyxMenu, *qmenu->d->top_level_menu, bv);
- qmenu->d->populate(*qmenu, *qmenu->d->top_level_menu);
+ qmenu->d->populate(qmenu, *qmenu->d->top_level_menu);
}