#include "LyXRC.h"
#include "lyxfind.h"
#include "Paragraph.h"
+#include "ParagraphParameters.h"
#include "ParIterator.h"
#include "Session.h"
#include "SpellChecker.h"
#include "TextClass.h"
+#include "Text.h"
#include "TocBackend.h"
#include "Toolbars.h"
#include "WordLangTuple.h"
for insertion into the current layout. */
Arguments,
/** This is the list of arguments available
- for in the InsetArgument context menu. */
- SwitchArguments
+ 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,
+ /** Commands to separate environments. */
+ EnvironmentSeparators
};
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,
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 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 *);
///
ItemList items_;
///
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_spellingsuggestions,
md_languageselector,
md_arguments,
- md_switcharguments
+ md_switcharguments,
+ md_captions,
+ md_switchcaptions,
+ md_env_separators
};
LexerKeyword menutags[] = {
{ "arguments", md_arguments },
{ "bookmarks", md_bookmarks },
{ "branches", md_branches },
+ { "captions", md_captions },
{ "charstyles", md_charstyles },
{ "citestyles", md_citestyles },
{ "custom", md_custom },
{ "documents", md_documents },
{ "elements", md_elements },
{ "end", md_endmenu },
+ { "environmentseparators", md_env_separators },
{ "exportformats", md_exportformats },
{ "floatinsert", md_floatinsert },
{ "floatlistinsert", md_floatlistinsert },
{ "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::SwitchArguments));
break;
+ case md_captions:
+ add(MenuItem(MenuItem::Captions));
+ break;
+
+ case md_switchcaptions:
+ add(MenuItem(MenuItem::SwitchCaptions));
+ break;
+
+ case md_env_separators:
+ add(MenuItem(MenuItem::EnvironmentSeparators));
+ 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:
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);
}
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())
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, (*fit)->name())));
} else {
if (buf)
addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(label),
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)),
}
}
// FIXME This is a little clunky.
- if (items_.empty() && type == InsetLayout::CUSTOM)
+ if (items_.empty() && type == InsetLayout::CUSTOM && !buf->isReadonly())
add(MenuItem(MenuItem::Help, qt_("No Custom Insets Defined!")));
}
-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)")));
}
}
void MenuDefinition::expandBranches(Buffer const * buf)
{
- if (!buf)
+ if (!buf || buf->isReadonly())
return;
BufferParams const & master_params = buf->masterBuffer()->params();
vector<docstring> const keys = getVectorFromString(key);
vector<CitationStyle> const citeStyleList = buf->params().citeStyles();
+ static const size_t max_length = 40;
vector<docstring> citeStrings =
buf->masterBibInfo().getCiteStrings(keys, citeStyleList, bv->buffer(),
- false, before, after, from_utf8("dialog"));
+ before, after, from_utf8("dialog"), max_length);
vector<docstring>::const_iterator cit = citeStrings.begin();
vector<docstring>::const_iterator end = citeStrings.end();
if (!bv)
return;
+ if (!bv->cursor().inTexted())
+ return;
+
Inset const * inset = &bv->cursor().inset();
- Layout::LaTeXArgMap args;
- if (inset && bv->cursor().paragraph().layout().latexargs().empty())
- args = inset->getLayout().latexargs();
- else
- args = bv->cursor().paragraph().layout().latexargs();
+ 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;
- QString item = toqstr(translateIfPossible(arg.labelstring));
- if (!arg.shortcut.empty())
- item += "|" + toqstr(arg.shortcut);
+ 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 ")
- + convert<docstring>((*lait).first))));
+ + from_ascii((*lait).first))));
else
add(MenuItem(MenuItem::Command, item,
FuncRequest(LFUN_ARGUMENT_INSERT,
- convert<docstring>((*lait).first))));
+ 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);
+ }
+}
+
+
+void MenuDefinition::expandEnvironmentSeparators(BufferView const * bv)
+{
+ if (!bv)
+ return;
+ Text const * text = bv->cursor().text();
+ // no paragraphs and no separators exist in math
+ if (!text)
+ return;
+
+ pit_type pit = bv->cursor().selBegin().pit();
+ Paragraph const & par = text->getPar(pit);
+ docstring const curlayout = par.layout().name();
+ docstring outerlayout;
+ depth_type current_depth = par.params().depth();
+ // check if we have an environment in our nesting hierarchy
+ Paragraph cpar = par;
+ while (true) {
+ if (pit == 0 || cpar.params().depth() == 0)
+ break;
+ --pit;
+ cpar = text->getPar(pit);
+ if (cpar.params().depth() < current_depth
+ && cpar.layout().isEnvironment()) {
+ outerlayout = cpar.layout().name();
+ current_depth = cpar.params().depth();
+ }
+ }
+ if (par.layout().isEnvironment()) {
+ docstring const label =
+ bformat(_("Start New Environment (%1$s)"),
+ translateIfPossible(curlayout));
+ add(MenuItem(MenuItem::Command, toqstr(label),
+ FuncRequest(LFUN_ENVIRONMENT_SPLIT)));
+ }
+ if (!outerlayout.empty()) {
+ docstring const label =
+ bformat(_("Start New Parent Environment (%1$s)"),
+ translateIfPossible(outerlayout));
+ add(MenuItem(MenuItem::Command, toqstr(label),
+ FuncRequest(LFUN_ENVIRONMENT_SPLIT,
+ from_ascii("outer"))));
}
}
else if (m->kind() == MenuItem::Submenu) {
QMenu * subMenu = qMenu.addMenu(label(*m));
populate(*subMenu, m->submenu());
- subMenu->setEnabled(m->status().enabled());
+ subMenu->setEnabled(!subMenu->isEmpty());
} 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));
}
}
}
-#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
/** The entries with the following kind are expanded to a
sequence of Command MenuItems: Lastfiles, Documents,
ViewFormats, ExportFormats, UpdateFormats, Branches,
- Indices, Arguments, SwitchArguments
+ Indices, Arguments, SwitchArguments, Captions, SwitchCaptions,
+ EnvironmentSeparators
*/
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",
QAction::PreferencesRole},
- /* {LFUN_RECONFIGURE, "", "Reconfigure",
- QAction::ApplicationSpecificRole}, */
+#if !(defined(QT_MAC_USE_COCOA) || (QT_VERSION >= 0x050000))
+ /* This doesn't work with Cocoa. */
+ {LFUN_RECONFIGURE, "", "Reconfigure",
+ QAction::ApplicationSpecificRole},
+#endif
{LFUN_LYX_QUIT, "", "Quit LyX", QAction::QuitRole}
};
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) {
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) {
-#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(),
- 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);
-#endif
}
}
tomenu.expandArguments(bv, true);
break;
+ case MenuItem::Captions:
+ tomenu.expandCaptions(buf, false);
+ break;
+
+ case MenuItem::SwitchCaptions:
+ tomenu.expandCaptions(buf, true);
+ break;
+
+ case MenuItem::EnvironmentSeparators:
+ tomenu.expandEnvironmentSeparators(bv);
+ 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);
}
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(view, qmb);
+ 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_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);
+#endif
+
qmb->addMenu(menu);
d->name_map_[view][name] = menu;
projects / lyx.git / blobdiff