*
* \author John Levon
* \author Asger Alstrup
- * \author Lars Gullik Bjønnes
+ * \author Lars Gullik Bjønnes
* \author Jean-Marc Lasgouttes
- * \author André Pönitz
+ * \author André Pönitz
* \author Dekel Tsur
* \author Martin Vermeer
*
#include "Format.h"
#include "FuncRequest.h"
#include "FuncStatus.h"
+#include "IndicesList.h"
#include "KeyMap.h"
#include "Lexer.h"
#include "LyXAction.h"
#include "LyX.h" // for lastfiles
#include "LyXFunc.h"
+#include "LyXRC.h"
#include "Paragraph.h"
#include "ParIterator.h"
#include "Session.h"
#include "TextClass.h"
#include "TocBackend.h"
#include "Toolbars.h"
+#include "WordLangTuple.h"
#include "insets/Inset.h"
#include "insets/InsetCitation.h"
Submenu,
///
Separator,
+ /** This type of item explains why something is unavailable. If this
+ 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
+ something alike at this position, but the list is still empty.
+ If this item is in a submenu, the submenu will not always be
+ enabled. */
+ Info,
/** This is the list of last opened file,
typically for the File menu. */
Lastfiles,
Toolbars,
/** Available branches in document */
Branches,
+ /** Available indices in document */
+ Indices,
+ /** Context menu for indices in document */
+ IndicesContext,
+ /** Available index lists in document */
+ IndicesLists,
+ /** Context menu for available indices lists in document */
+ IndicesListsContext,
/** Available citation styles for a given citation */
CiteStyles,
/** Available graphics groups */
- GraphicsGroups
+ GraphicsGroups,
+ /// Words suggested by the spellchecker.
+ SpellingSuggestions
};
explicit MenuItem(Kind kind) : kind_(kind), optional_(false) {}
bool optional = false)
: kind_(kind), label_(label), submenuname_(submenu), optional_(optional)
{
- LASSERT(kind == Submenu, /**/);
+ LASSERT(kind == Submenu || kind == Help || kind == Info, /**/);
}
MenuItem(Kind kind,
QString const & label,
FuncRequest const & func,
- bool optional = false)
+ bool optional = false,
+ FuncRequest::Origin origin = FuncRequest::MENU)
: kind_(kind), label_(label), func_(func), optional_(optional)
{
- func_.origin = FuncRequest::MENU;
+ func_.origin = origin;
}
// boost::shared_ptr<MenuDefinition> needs this apprently...
void expandFormats(MenuItem::Kind kind, Buffer const * buf);
void expandFloatListInsert(Buffer const * buf);
void expandFloatInsert(Buffer const * buf);
- void expandFlexInsert(Buffer const * buf, std::string s);
+ void expandFlexInsert(Buffer const * buf, InsetLayout::InsetLyXType type);
void expandToc2(Toc const & toc_list, size_t from, size_t to, int depth);
void expandToc(Buffer const * buf);
void expandPasteRecent(Buffer const * buf);
void expandToolbars();
void expandBranches(Buffer const * buf);
+ void expandIndices(Buffer const * buf, bool listof = false);
+ void expandIndicesContext(Buffer const * buf, bool listof = false);
void expandCiteStyles(BufferView const *);
void expandGraphicsGroups(BufferView const *);
+ void expandSpellingSuggestions(BufferView const *);
///
ItemList items_;
///
}
case MenuItem::Submenu: {
+ bool enabled = false;
if (i.hasSubmenu()) {
- bool enabled = false;
for (const_iterator cit = i.submenu().begin();
- cit != i.submenu().end(); ++cit) {
+ 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::Submenu
+ || cit->kind() == MenuItem::Help)
&& cit->status().enabled()) {
enabled = true;
break;
}
}
- if (enabled || !i.optional()) {
- items_.push_back(i);
- items_.back().status().setEnabled(enabled);
- }
}
- else
+ if (enabled || !i.optional()) {
items_.push_back(i);
+ items_.back().status().setEnabled(enabled);
+ }
break;
}
md_endmenu,
md_exportformats,
md_importformats,
+ md_indices,
+ md_indicescontext,
+ md_indiceslists,
+ md_indiceslistscontext,
md_lastfiles,
md_optitem,
md_optsubmenu,
md_floatinsert,
md_pasterecent,
md_toolbars,
- md_graphicsgroups
+ md_graphicsgroups,
+ md_spellingsuggestions
};
LexerKeyword menutags[] = {
{ "floatlistinsert", md_floatlistinsert },
{ "graphicsgroups", md_graphicsgroups },
{ "importformats", md_importformats },
+ { "indices", md_indices },
+ { "indicescontext", md_indicescontext },
+ { "indiceslists", md_indiceslists },
+ { "indiceslistscontext", md_indiceslistscontext },
{ "item", md_item },
{ "lastfiles", md_lastfiles },
{ "optitem", md_optitem },
{ "optsubmenu", md_optsubmenu },
{ "pasterecent", md_pasterecent },
{ "separator", md_separator },
+ { "spellingsuggestions", md_spellingsuggestions },
{ "submenu", md_submenu },
{ "toc", md_toc },
{ "toolbars", md_toolbars },
lex.next(true);
string const command = lex.getString();
FuncRequest func = lyxaction.lookupFunc(command);
- add(MenuItem(MenuItem::Command, toqstr(name), func, optional));
+ FuncRequest::Origin origin = FuncRequest::MENU;
+ if (name_.startsWith("context-toc-"))
+ origin = FuncRequest::TOC;
+ add(MenuItem(MenuItem::Command, toqstr(name), func, optional, origin));
optional = false;
break;
}
add(MenuItem(MenuItem::GraphicsGroups));
break;
+ case md_spellingsuggestions:
+ add(MenuItem(MenuItem::SpellingSuggestions));
+ break;
+
+ case md_indices:
+ add(MenuItem(MenuItem::Indices));
+ break;
+
+ case md_indicescontext:
+ add(MenuItem(MenuItem::IndicesContext));
+ break;
+
+ case md_indiceslists:
+ add(MenuItem(MenuItem::IndicesLists));
+ break;
+
+ case md_indiceslistscontext:
+ add(MenuItem(MenuItem::IndicesListsContext));
+ break;
+
case md_optsubmenu:
optional = true;
// fallback to md_submenu
}
}
+
+void MenuDefinition::expandSpellingSuggestions(BufferView const * bv)
+{
+ if (!bv)
+ return;
+ WordLangTuple wl;
+ docstring_list suggestions;
+ pos_type from = bv->cursor().pos();
+ pos_type to = from;
+ Paragraph const & par = bv->cursor().paragraph();
+ if (!par.spellCheck(from, to, wl, suggestions))
+ return;
+ LYXERR(Debug::GUI, "Misspelled Word! Suggested Words = ");
+ size_t i = 0;
+ MenuItem item(MenuItem::Submenu, qt_("More Spelling Suggestions"));
+ item.setSubmenu(MenuDefinition(qt_("More Spelling Suggestions")));
+ for (; i != suggestions.size(); ++i) {
+ docstring const & suggestion = suggestions[i];
+ LYXERR(Debug::GUI, suggestion);
+ MenuItem w(MenuItem::Command, toqstr(suggestion),
+ FuncRequest(LFUN_WORD_REPLACE, suggestion));
+ if (i < 10)
+ add(w);
+ else
+ item.submenu().add(w);
+ }
+ if (i >= 10)
+ add(item);
+ if (i > 0)
+ add(MenuItem(MenuItem::Separator));
+ docstring arg = wl.word() + " " + from_ascii(wl.lang_code());
+ if (!wl.lang_variety().empty())
+ arg += from_ascii("-") + from_ascii(wl.lang_variety());
+ add(MenuItem(MenuItem::Command, qt_("Add to personal dictionary|c"),
+ FuncRequest(LFUN_SPELLING_ADD, arg)));
+ add(MenuItem(MenuItem::Command, qt_("Ignore all|I"),
+ FuncRequest(LFUN_SPELLING_IGNORE, arg)));
+
+}
+
+
void MenuDefinition::expandLastfiles()
{
LastFilesSection::LastFiles const & lf = theSession().lastFiles().lastFiles();
LastFilesSection::LastFiles::const_iterator lfit = lf.begin();
- int ii = 1;
+ unsigned int ii = 1;
- for (; lfit != lf.end() && ii < 10; ++lfit, ++ii) {
+ for (; lfit != lf.end() && ii <= lyxrc.num_lastfiles; ++lfit, ++ii) {
string const file = lfit->absFilename();
- QString const label = QString("%1. %2|%3").arg(ii)
- .arg(toqstr(makeDisplayPath(file, 30))).arg(ii);
+ QString label;
+ if (ii < 10)
+ label = QString("%1. %2|%3").arg(ii)
+ .arg(toqstr(makeDisplayPath(file, 30))).arg(ii);
+ else
+ label = QString("%1. %2").arg(ii)
+ .arg(toqstr(makeDisplayPath(file, 30)));
add(MenuItem(MenuItem::Command, label, FuncRequest(LFUN_FILE_OPEN, file)));
}
}
void MenuDefinition::expandDocuments()
{
+ MenuItem item(MenuItem::Submenu, qt_("Invisible"));
+ item.setSubmenu(MenuDefinition(qt_("Invisible")));
+
Buffer * first = theBufferList().first();
if (first) {
Buffer * b = first;
- int ii = 1;
+ int vis = 1;
+ int invis = 1;
// We cannot use a for loop as the buffer list cycles.
do {
QString label = toqstr(b->fileName().displayName(20));
- if (b->isUnnamed() && label.endsWith(".internal")) {
- // This is an internal Buffer (eg. for clipboard operations)
- b = theBufferList().next(b);
- continue;
- }
if (!b->isClean())
label += "*";
+ bool const shown = guiApp->currentView()
+ ? guiApp->currentView()->workArea(*b) : false;
+ int ii = shown ? vis : invis;
if (ii < 10)
label = QString::number(ii) + ". " + label + '|' + QString::number(ii);
- add(MenuItem(MenuItem::Command, label,
- FuncRequest(LFUN_BUFFER_SWITCH, b->absFileName())));
-
+ if (shown) {
+ add(MenuItem(MenuItem::Command, label,
+ FuncRequest(LFUN_BUFFER_SWITCH, b->absFileName())));
+ ++vis;
+ } else {
+ item.submenu().add(MenuItem(MenuItem::Command, label,
+ FuncRequest(LFUN_BUFFER_SWITCH, b->absFileName())));
+ ++invis;
+ }
b = theBufferList().next(b);
- ++ii;
} while (b != first);
- } else {
- add(MenuItem(MenuItem::Command, qt_("No Documents Open!"),
- FuncRequest(LFUN_NOACTION)));
- }
+ if (!item.submenu().empty())
+ add(item);
+ } else
+ add(MenuItem(MenuItem::Info, qt_("<No Documents Open>")));
}
{
lyx::BookmarksSection const & bm = theSession().bookmarks();
+ bool empty = true;
for (size_t i = 1; i <= bm.size(); ++i) {
if (bm.isValid(i)) {
string const file = bm.bookmark(i).filename.absFilename();
.arg(toqstr(makeDisplayPath(file, 20))).arg(i);
add(MenuItem(MenuItem::Command, label,
FuncRequest(LFUN_BOOKMARK_GOTO, convert<docstring>(i))));
+ empty = false;
}
}
+ if (empty)
+ add(MenuItem(MenuItem::Info, qt_("<No Bookmarks Saved Yet>")));
}
void MenuDefinition::expandFormats(MenuItem::Kind kind, Buffer const * buf)
{
- if (!buf && kind != MenuItem::ImportFormats) {
- add(MenuItem(MenuItem::Command,
- qt_("No Document Open!"),
- FuncRequest(LFUN_NOACTION)));
+ if (!buf && kind != MenuItem::ImportFormats)
return;
- }
typedef vector<Format const *> Formats;
Formats formats;
}
sort(formats.begin(), formats.end(), &compareFormat);
+ bool const view_update = (kind == MenuItem::ViewFormats
+ || kind == MenuItem::UpdateFormats);
+
+ QString smenue;
+ if (view_update)
+ smenue = (kind == MenuItem::ViewFormats ?
+ qt_("View (Other Formats)|F")
+ : qt_("Update (Other Formats)|p"));
+ 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) {
label += "...";
break;
case MenuItem::ViewFormats:
- case MenuItem::ExportFormats:
case MenuItem::UpdateFormats:
+ if ((*fit)->name() == buf->getDefaultOutputFormat()) {
+ docstring lbl = (kind == MenuItem::ViewFormats ?
+ bformat(_("View [%1$s]|V"), qstring_to_ucs4(label))
+ : bformat(_("Update [%1$s]|U"), qstring_to_ucs4(label)));
+ MenuItem w(MenuItem::Command, toqstr(lbl),
+ FuncRequest(action, (*fit)->name()));
+ add(w);
+ continue;
+ }
+ case MenuItem::ExportFormats:
if (!(*fit)->documentFormat())
continue;
break;
if (!shortcut.isEmpty())
label += '|' + shortcut;
- if (buf)
- addWithStatusCheck(MenuItem(MenuItem::Command, label,
- FuncRequest(action, (*fit)->name())));
- else
- add(MenuItem(MenuItem::Command, label,
- FuncRequest(action, (*fit)->name())));
+ if (view_update) {
+ if (buf)
+ item.submenu().addWithStatusCheck(MenuItem(MenuItem::Command, label,
+ FuncRequest(action, (*fit)->name())));
+ else
+ item.submenu().add(MenuItem(MenuItem::Command, label,
+ FuncRequest(action, (*fit)->name())));
+ } else {
+ if (buf)
+ addWithStatusCheck(MenuItem(MenuItem::Command, label,
+ FuncRequest(action, (*fit)->name())));
+ else
+ add(MenuItem(MenuItem::Command, label,
+ FuncRequest(action, (*fit)->name())));
+ }
}
+ if (view_update)
+ add(item);
}
void MenuDefinition::expandFloatListInsert(Buffer const * buf)
{
- if (!buf) {
- add(MenuItem(MenuItem::Command, qt_("No Document Open!"),
- FuncRequest(LFUN_NOACTION)));
+ if (!buf)
return;
- }
FloatList const & floats = buf->params().documentClass().floats();
FloatList::const_iterator cit = floats.begin();
void MenuDefinition::expandFloatInsert(Buffer const * buf)
{
- if (!buf) {
- add(MenuItem(MenuItem::Command, qt_("No Document Open!"),
- FuncRequest(LFUN_NOACTION)));
+ if (!buf)
return;
- }
FloatList const & floats = buf->params().documentClass().floats();
FloatList::const_iterator cit = floats.begin();
}
-void MenuDefinition::expandFlexInsert(Buffer const * buf, string s)
+void MenuDefinition::expandFlexInsert(
+ Buffer const * buf, InsetLayout::InsetLyXType type)
{
- if (!buf) {
- add(MenuItem(MenuItem::Command, qt_("No Document Open!"),
- FuncRequest(LFUN_NOACTION)));
+ if (!buf)
return;
- }
+
TextClass::InsetLayouts const & insetLayouts =
buf->params().documentClass().insetLayouts();
TextClass::InsetLayouts::const_iterator cit = insetLayouts.begin();
TextClass::InsetLayouts::const_iterator end = insetLayouts.end();
for (; cit != end; ++cit) {
- docstring const label = cit->first;
- if (cit->second.lyxtype() == s)
+ if (cit->second.lyxtype() == type) {
+ docstring const label = cit->first;
addWithStatusCheck(MenuItem(MenuItem::Command,
toqstr(translateIfPossible(label)),
- FuncRequest(LFUN_FLEX_INSERT, label)));
+ FuncRequest(LFUN_FLEX_INSERT, Lexer::quoteString(label))));
+ }
}
+ // FIXME This is a little clunky.
+ if (items_.empty() && type == InsetLayout::CUSTOM)
+ add(MenuItem(MenuItem::Help, qt_("No Custom Insets Defined!")));
}
// OK, so we avoid this unnecessary overhead (JMarc)
if (!buf) {
- add(MenuItem(MenuItem::Command, qt_("No Document Open!"),
- FuncRequest(LFUN_NOACTION)));
+ add(MenuItem(MenuItem::Info, qt_("<No Document Open>")));
return;
}
// Handle normal TOC
cit = toc_list.find("tableofcontents");
- if (cit == end) {
- addWithStatusCheck(MenuItem(MenuItem::Command,
- qt_("No Table of contents"),
- FuncRequest()));
- } else
- expandToc2(cit->second, 0, cit->second.size(), 0);
+ if (cit == end)
+ LYXERR(Debug::GUI, "No table of contents.");
+ else {
+ if (cit->second.size() > 0 )
+ expandToc2(cit->second, 0, cit->second.size(), 0);
+ else
+ add(MenuItem(MenuItem::Info, qt_("<Empty Table of Contents>")));
+ }
}
void MenuDefinition::expandBranches(Buffer const * buf)
{
- if (!buf) {
- add(MenuItem(MenuItem::Command,
- qt_("No Document Open!"),
- FuncRequest(LFUN_NOACTION)));
+ if (!buf)
return;
- }
- BufferParams const & params = buf->masterBuffer()->params();
- if (params.branchlist().empty()) {
- add(MenuItem(MenuItem::Command,
- qt_("No Branch in Document!"),
- FuncRequest(LFUN_NOACTION)));
+ 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 = params.branchlist().begin();
- BranchList::const_iterator end = params.branchlist().end();
+ BranchList::const_iterator cit = master_params.branchlist().begin();
+ BranchList::const_iterator end = master_params.branchlist().end();
for (int ii = 1; cit != end; ++cit, ++ii) {
docstring label = cit->branch();
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();
+
+ 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);
+ }
+ child_branches.addWithStatusCheck(MenuItem(MenuItem::Command,
+ toqstr(label),
+ FuncRequest(LFUN_BRANCH_INSERT,
+ ccit->branch())));
+ }
+
+ if (!child_branches.empty()) {
+ MenuItem item(MenuItem::Submenu, qt_("Child Document"));
+ item.setSubmenu(child_branches);
+ add(item);
+ }
}
-void MenuDefinition::expandCiteStyles(BufferView const * bv)
+void MenuDefinition::expandIndices(Buffer const * buf, bool listof)
{
- if (!bv) {
- add(MenuItem(MenuItem::Command,
- qt_("No Document Open!"),
- FuncRequest(LFUN_NOACTION)));
+ if (!buf)
+ return;
+
+ BufferParams const & params = buf->masterBuffer()->params();
+ if (!params.use_indices) {
+ if (listof)
+ addWithStatusCheck(MenuItem(MenuItem::Command,
+ qt_("Index List|I"),
+ FuncRequest(LFUN_INDEX_PRINT,
+ from_ascii("idx"))));
+ else
+ addWithStatusCheck(MenuItem(MenuItem::Command,
+ qt_("Index Entry|d"),
+ FuncRequest(LFUN_INDEX_INSERT,
+ from_ascii("idx"))));
return;
}
+ if (params.indiceslist().empty())
+ return;
+
+ IndicesList::const_iterator cit = params.indiceslist().begin();
+ IndicesList::const_iterator end = params.indiceslist().end();
+
+ for (int ii = 1; cit != end; ++cit, ++ii) {
+ if (listof)
+ addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(cit->index()),
+ FuncRequest(LFUN_INDEX_PRINT,
+ cit->shortcut())));
+ else {
+ docstring label = _("Index Entry");
+ label += " (" + cit->index() + ")";
+ addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(label),
+ FuncRequest(LFUN_INDEX_INSERT,
+ cit->shortcut())));
+ }
+ }
+}
+
+
+void MenuDefinition::expandIndicesContext(Buffer const * buf, bool listof)
+{
+ if (!buf)
+ return;
+
+ BufferParams const & params = buf->masterBuffer()->params();
+ if (!params.use_indices || params.indiceslist().empty())
+ return;
+
+ IndicesList::const_iterator cit = params.indiceslist().begin();
+ IndicesList::const_iterator end = params.indiceslist().end();
+
+ for (int ii = 1; cit != end; ++cit, ++ii) {
+ if (listof) {
+ InsetCommandParams p(INDEX_PRINT_CODE);
+ p["type"] = cit->shortcut();
+ string const data = InsetCommand::params2string("index_print", p);
+ addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(cit->index()),
+ FuncRequest(LFUN_INSET_MODIFY, data)));
+ } else {
+ docstring label = _("Index Entry");
+ label += " (" + cit->index() + ")";
+ addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(label),
+ FuncRequest(LFUN_INSET_MODIFY,
+ from_ascii("changetype ") + cit->shortcut())));
+ }
+ }
+}
+
+
+void MenuDefinition::expandCiteStyles(BufferView const * bv)
+{
+ if (!bv)
+ return;
+
Inset const * inset = bv->cursor().nextInset();
if (!inset || inset->lyxCode() != CITE_CODE) {
add(MenuItem(MenuItem::Command,
CiteStyle cst = citeStyleList[ii - 1];
cs.style = cst;
addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(label),
- FuncRequest(LFUN_NEXT_INSET_MODIFY,
+ FuncRequest(LFUN_INSET_MODIFY,
"changetype " + from_utf8(citationStyleToString(cs)))));
}
}
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(view, QIcon(), label(*m),
/// 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
+ ViewFormats, ExportFormats, UpdateFormats, Branches, Indices
*/
void expand(MenuDefinition const & frommenu, MenuDefinition & tomenu,
BufferView const *) const;
/// Mac special menu.
/** This defines a menu whose entries list the FuncRequests
that will be removed by expand() in other menus. This is
- used by the Qt/Mac code
+ used by the Qt/Mac code.
+
+ NOTE: Qt does not remove the menu items when clearing a QMenuBar,
+ such that the items will keep accessing the FuncRequests in
+ the MenuDefinition. While Menus::Impl might be recreated,
+ we keep mac_special_menu_ in memory by making it static.
*/
- MenuDefinition specialmenu_;
+ static MenuDefinition mac_special_menu_;
///
MenuList menulist_;
NameMap name_map_;
};
+
+MenuDefinition Menus::Impl::mac_special_menu_;
+
+
/*
Here is what the Qt documentation says about how a menubar is chosen:
const size_t num_entries = sizeof(entries) / sizeof(entries[0]);
// the special menu for Menus. Fill it up only once.
- if (specialmenu_.size() == 0) {
+ if (mac_special_menu_.size() == 0) {
for (size_t i = 0 ; i < num_entries ; ++i) {
FuncRequest const func(entries[i].action,
from_utf8(entries[i].arg));
- specialmenu_.add(MenuItem(MenuItem::Command,
+ mac_special_menu_.add(MenuItem(MenuItem::Command,
entries[i].label, func));
}
}
// add the entries to a QMenu that will eventually be empty
// and therefore invisible.
QMenu * qMenu = qmb->addMenu("special");
- MenuDefinition::const_iterator cit = specialmenu_.begin();
- MenuDefinition::const_iterator end = specialmenu_.end();
+ 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(view, QIcon(), cit->label(),
cit->func(), QString(), qMenu);
break;
case MenuItem::CharStyles:
- tomenu.expandFlexInsert(buf, "charstyle");
+ tomenu.expandFlexInsert(buf, InsetLayout::CHARSTYLE);
break;
case MenuItem::Custom:
- tomenu.expandFlexInsert(buf, "custom");
+ tomenu.expandFlexInsert(buf, InsetLayout::CUSTOM);
break;
case MenuItem::Elements:
- tomenu.expandFlexInsert(buf, "element");
+ tomenu.expandFlexInsert(buf, InsetLayout::ELEMENT);
break;
case MenuItem::FloatListInsert:
tomenu.expandBranches(buf);
break;
+ case MenuItem::Indices:
+ tomenu.expandIndices(buf);
+ break;
+
+ case MenuItem::IndicesContext:
+ tomenu.expandIndicesContext(buf);
+ break;
+
+ case MenuItem::IndicesLists:
+ tomenu.expandIndices(buf, true);
+ break;
+
+ case MenuItem::IndicesListsContext:
+ tomenu.expandIndicesContext(buf, true);
+ break;
+
case MenuItem::CiteStyles:
tomenu.expandCiteStyles(bv);
break;
tomenu.expandGraphicsGroups(bv);
break;
+ case MenuItem::SpellingSuggestions:
+ tomenu.expandSpellingSuggestions(bv);
+ break;
+
case MenuItem::Submenu: {
MenuItem item(*cit);
item.setSubmenu(MenuDefinition(cit->submenuname()));
}
break;
+ case MenuItem::Info:
+ case MenuItem::Help:
case MenuItem::Separator:
tomenu.addWithStatusCheck(*cit);
break;
case MenuItem::Command:
- if (!specialmenu_.hasFunc(cit->func()))
+ if (!mac_special_menu_.hasFunc(cit->func()))
tomenu.addWithStatusCheck(*cit);
}
}
{
if (initial) {
#ifdef Q_WS_MACX
- // setup special mac specific menu item
+ // 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);
#endif
} else {
MenuDefinition menu;
BufferView * bv = 0;
if (view)
- bv = view->view();
+ bv = view->currentBufferView();
d->expand(d->menubar_, menu, bv);
MenuDefinition::const_iterator m = menu.begin();
if (qmenu->d->name.isEmpty())
return;
- // Here, We make sure that theLyXFunc points to the correct LyXView.
- theLyXFunc().setLyXView(qmenu->d->view);
-
if (!d->hasMenu(qmenu->d->name)) {
- qmenu->addAction(qt_("No action defined!"));
+ qmenu->addAction(qt_("No Action Defined!"));
LYXERR(Debug::GUI, "\tWARNING: non existing menu: "
<< qmenu->d->name);
return;
MenuDefinition const & fromLyxMenu = d->getMenu(qmenu->d->name);
BufferView * bv = 0;
if (qmenu->d->view)
- bv = qmenu->d->view->view();
+ bv = qmenu->d->view->currentBufferView();
d->expand(fromLyxMenu, *qmenu->d->top_level_menu, bv);
qmenu->d->populate(*qmenu, *qmenu->d->top_level_menu);
}
} // namespace frontend
} // namespace lyx
-#include "Menus_moc.cpp"
+#include "moc_Menus.cpp"