*
* \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 "Action.h"
#include "GuiApplication.h"
#include "GuiView.h"
+#include "GuiWorkArea.h"
#include "qt_helpers.h"
#include "BiblioInfo.h"
#include "Format.h"
#include "FuncRequest.h"
#include "FuncStatus.h"
+#include "IndicesList.h"
#include "KeyMap.h"
+#include "Language.h"
+#include "Layout.h"
#include "Lexer.h"
#include "LyXAction.h"
-#include "LyX.h" // for lastfiles
-#include "LyXFunc.h"
+#include "LyX.h"
+#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"
#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 <QList>
#include <QMenuBar>
#include <QString>
-
-#include <boost/shared_ptr.hpp>
+#if QT_VERSION >= 0x040600
+#include <QProxyStyle>
+#endif
#include <algorithm>
+#include <memory>
#include <vector>
using namespace std;
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,
/** This is a list of exportable formats
typically for the File->Export menu. */
ExportFormats,
- /** This is a list of importable formats
+ /** 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,
/** This is the list of elements available
* for insertion into document. */
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,
+ /** Used Languages */
+ LanguageSelector,
+ /** This is the list of arguments available
+ for insertion into the current layout. */
+ Arguments,
+ /** This is the list of arguments available
+ 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,
+ /** This is the list of quotation marks available */
+ SwitchQuotes
};
explicit MenuItem(Kind kind) : kind_(kind), optional_(false) {}
MenuItem(Kind kind,
QString const & label,
QString const & submenu = QString(),
+ QString const & tooltip = QString(),
bool optional = false)
- : kind_(kind), label_(label), submenuname_(submenu), optional_(optional)
+ : kind_(kind), label_(label), func_(make_shared<FuncRequest>()),
+ submenuname_(submenu), tooltip_(tooltip), optional_(optional)
{
- LASSERT(kind == Submenu, /**/);
+ LATTEST(kind == Submenu || kind == Help || kind == Info);
}
MenuItem(Kind kind,
QString const & label,
FuncRequest const & func,
- bool optional = false)
- : kind_(kind), label_(label), func_(func), optional_(optional)
+ QString const & tooltip = QString(),
+ bool optional = false,
+ FuncRequest::Origin origin = FuncRequest::MENU)
+ : kind_(kind), label_(label), func_(make_shared<FuncRequest>(func)),
+ tooltip_(tooltip), optional_(optional)
{
- func_.origin = FuncRequest::MENU;
+ func_->setOrigin(origin);
}
- // boost::shared_ptr<MenuDefinition> needs this apprently...
- ~MenuItem() {}
-
/// The label of a given menuitem
- QString label() const { return label_.split('|')[0]; }
+ QString label() const
+ {
+ int const index = label_.lastIndexOf('|');
+ return index == -1 ? label_ : label_.left(index);
+ }
/// The keyboard shortcut (usually underlined in the entry)
QString shortcut() const
{
- return label_.contains('|') ? label_.split('|')[1] : QString();
+ int const index = label_.lastIndexOf('|');
+ return index == -1 ? QString() : label_.mid(index + 1);
}
/// The complete label, with label and shortcut separated by a '|'
- QString fulllabel() const { return label_;}
+ QString fulllabel() const { return label_; }
/// The kind of entry
Kind kind() const { return kind_; }
/// the action (if relevant)
- FuncRequest const & func() const { return func_; }
- /// returns true if the entry should be ommited when disabled
+ 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
bool optional() const { return optional_; }
/// returns the status of the lfun associated with this entry
FuncStatus const & status() const { return status_; }
return QString();
// Get the keys bound to this action, but keep only the
// first one later
- KeyMap::Bindings bindings = theTopLevelKeymap().findBindings(func_);
- if (bindings.size())
+ 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_;
///
+ QString tooltip_;
+ ///
bool optional_;
///
FuncStatus status_;
///
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 cat(MenuDefinition const & other);
+ ///
+ void catSub(docstring const & name);
+
// search for func in this menu iteratively, and put menu
// names in a stack.
bool searchMenu(FuncRequest const & func, docstring_list & names)
void expandLastfiles();
void expandDocuments();
void expandBookmarks();
- void expandFormats(MenuItem::Kind kind, Buffer const * buf);
+ void expandFormats(MenuItem::Kind const kind, Buffer const * buf);
void expandFloatListInsert(Buffer const * buf);
void expandFloatInsert(Buffer const * buf);
- void expandFlexInsert(Buffer const * buf, std::string s);
- void expandToc2(Toc const & toc_list, size_t from, size_t to, int depth);
+ 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 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 *);
+ 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 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);
}
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_custom,
md_elements,
md_endmenu,
+ md_exportformat,
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,
+ md_languageselector,
+ md_arguments,
+ md_switcharguments,
+ md_captions,
+ md_switchcaptions,
+ md_env_separators,
+ md_switchquotes
};
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 },
+ { "exportformat", md_exportformat },
{ "exportformats", md_exportformats },
{ "floatinsert", md_floatinsert },
{ "floatlistinsert", md_floatlistinsert },
{ "graphicsgroups", md_graphicsgroups },
{ "importformats", md_importformats },
+ { "indices", md_indices },
+ { "indicescontext", md_indicescontext },
+ { "indiceslists", md_indiceslists },
+ { "indiceslistscontext", md_indiceslistscontext },
{ "item", md_item },
+ { "languageselector", md_languageselector },
{ "lastfiles", md_lastfiles },
{ "optitem", md_optitem },
{ "optsubmenu", md_optsubmenu },
{ "pasterecent", md_pasterecent },
{ "separator", md_separator },
+ { "spellingsuggestions", md_spellingsuggestions },
{ "submenu", md_submenu },
+ { "switcharguments", md_switcharguments },
+ { "switchcaptions", md_switchcaptions },
+ { "switchquotes", md_switchquotes },
{ "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());
lex.next(true);
string const command = lex.getString();
FuncRequest func = lyxaction.lookupFunc(command);
- add(MenuItem(MenuItem::Command, toqstr(name), func, optional));
- optional = false;
+ 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));
break;
}
add(MenuItem(MenuItem::ExportFormats));
break;
+ case md_exportformat:
+ add(MenuItem(MenuItem::ExportFormat));
+ break;
+
case md_importformats:
add(MenuItem(MenuItem::ImportFormats));
break;
add(MenuItem(MenuItem::GraphicsGroups));
break;
+ case md_spellingsuggestions:
+ add(MenuItem(MenuItem::SpellingSuggestions));
+ break;
+
+ case md_languageselector:
+ add(MenuItem(MenuItem::LanguageSelector));
+ 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_arguments:
+ add(MenuItem(MenuItem::Arguments));
+ break;
+
+ case md_switcharguments:
+ 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_switchquotes:
+ add(MenuItem(MenuItem::SwitchQuotes));
+ 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), optional));
- optional = false;
+ toqstr(mlabel), toqstr(mname), QString(), optional));
break;
}
case md_endmenu:
- quit = true;
break;
default:
}
-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;
}
+void MenuDefinition::catSub(docstring const & name)
+{
+ add(MenuItem(MenuItem::Submenu,
+ qt_("More...|M"), toqstr(name), QString(), false));
+}
+
+void MenuDefinition::cat(MenuDefinition const & other)
+{
+ const_iterator et = other.end();
+ for (const_iterator it = other.begin(); it != et; ++it)
+ add(*it);
+}
+
+
void MenuDefinition::checkShortcuts() const
{
// This is a quadratic algorithm, but we do not care because
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;
}
}
-bool compareFormat(Format const * p1, Format const * p2)
-{
- return *p1 < *p2;
-}
-
-
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);
}
set<string>::const_iterator it = grp.begin();
set<string>::const_iterator end = grp.end();
- add(MenuItem(MenuItem::Command, qt_("No Group"),
+ add(MenuItem(MenuItem::Command, qt_("No Group"),
FuncRequest(LFUN_SET_GRAPHICS_GROUP)));
- for (; it != end; it++) {
- addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(*it),
+ for (; it != end; ++it) {
+ addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(*it) + '|',
FuncRequest(LFUN_SET_GRAPHICS_GROUP, *it)));
}
}
+
+void MenuDefinition::expandSpellingSuggestions(BufferView const * bv)
+{
+ if (!bv)
+ return;
+ Cursor const & cur = bv->cursor();
+ if (!cur.inTexted())
+ return;
+ WordLangTuple wl;
+ docstring_list suggestions;
+ Paragraph const & par = cur.paragraph();
+ pos_type from = cur.pos();
+ pos_type to = from;
+ SpellChecker::Result res = par.spellCheck(from, to, wl, suggestions, true, true);
+ switch (res) {
+ case SpellChecker::UNKNOWN_WORD:
+ if (lyxrc.spellcheck_continuously) {
+ LYXERR(Debug::GUI, "Misspelled Word! Suggested Words = ");
+ docstring const & selection = cur.selectionAsString(false);
+ if (!cur.selection() || selection == wl.word()) {
+ size_t i = 0;
+ size_t m = 10; // first submenu index
+ 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,
+ replace2string(suggestion, selection,
+ true, // case sensitive
+ true, // match word
+ false, // all words
+ true, // forward
+ false))); // find next
+ if (i < m)
+ add(w);
+ else
+ item.submenu().add(w);
+ }
+ if (i > m)
+ add(item);
+ if (i > 0)
+ add(MenuItem(MenuItem::Separator));
+ docstring const arg = wl.word() + " " + from_ascii(wl.lang()->lang());
+ add(MenuItem(MenuItem::Command, qt_("Add to personal dictionary|n"),
+ FuncRequest(LFUN_SPELLING_ADD, arg)));
+ add(MenuItem(MenuItem::Command, qt_("Ignore all|I"),
+ FuncRequest(LFUN_SPELLING_IGNORE, arg)));
+ }
+ }
+ break;
+ case SpellChecker::LEARNED_WORD: {
+ LYXERR(Debug::GUI, "Learned Word.");
+ docstring const arg = wl.word() + " " + from_ascii(wl.lang()->lang());
+ add(MenuItem(MenuItem::Command, qt_("Remove from personal dictionary|r"),
+ FuncRequest(LFUN_SPELLING_REMOVE, arg)));
+ }
+ break;
+ case SpellChecker::NO_DICTIONARY:
+ LYXERR(Debug::GUI, "No dictionary for language " + from_ascii(wl.lang()->lang()));
+ // FALLTHROUGH
+ case SpellChecker::WORD_OK:
+ case SpellChecker::COMPOUND_WORD:
+ case SpellChecker::ROOT_FOUND:
+ case SpellChecker::IGNORED_WORD:
+ break;
+ }
+}
+
+struct sortLanguageByName {
+ bool operator()(const Language * a, const Language * b) const {
+ return qt_(a->display()).localeAwareCompare(qt_(b->display())) < 0;
+ }
+};
+
+void MenuDefinition::expandLanguageSelector(Buffer const * buf)
+{
+ if (!buf)
+ return;
+
+ std::set<Language const *> languages_buffer =
+ buf->masterBuffer()->getLanguages();
+
+ if (languages_buffer.size() < 2)
+ return;
+
+ std::set<Language const *, sortLanguageByName> languages;
+
+ 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);
+ }
+
+ MenuItem item(MenuItem::Submenu, qt_("Language|L"));
+ item.setSubmenu(MenuDefinition(qt_("Language")));
+ QString morelangs = qt_("More Languages ...|M");
+ QStringList accelerators;
+ if (morelangs.contains('|'))
+ accelerators.append(morelangs.section('|', -1));
+ std::set<Language const *, sortLanguageByName>::const_iterator const begin = languages.begin();
+ for (std::set<Language const *, sortLanguageByName>::const_iterator cit = begin;
+ cit != languages.end(); ++cit) {
+ QString label = qt_((*cit)->display());
+ // try to add an accelerator
+ bool success = false;
+ // try capitals first
+ for (int i = 0; i < label.size(); ++i) {
+ QChar const ch = label[i];
+ if (!ch.isUpper())
+ continue;
+ if (!accelerators.contains(ch, Qt::CaseInsensitive)) {
+ label = label + toqstr("|") + ch;
+ accelerators.append(ch);
+ success = true;
+ break;
+ }
+ }
+ // if all capitals are taken, try the rest
+ if (!success) {
+ for (int i = 0; i < label.size(); ++i) {
+ if (label[i].isSpace())
+ continue;
+ QString const ch = QString(label[i]);
+ if (!accelerators.contains(ch, Qt::CaseInsensitive)) {
+ label = label + toqstr("|") + ch;
+ accelerators.append(ch);
+ break;
+ }
+ }
+ }
+ MenuItem w(MenuItem::Command, label,
+ FuncRequest(LFUN_LANGUAGE, (*cit)->lang() + " set"));
+ item.submenu().addWithStatusCheck(w);
+ }
+ item.submenu().add(MenuItem(MenuItem::Separator));
+ item.submenu().add(MenuItem(MenuItem::Command, morelangs,
+ FuncRequest(LFUN_DIALOG_SHOW, "character")));
+ add(item);
+}
+
+
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) {
- string const file = lfit->absFilename();
- QString const label = QString("%1. %2|%3").arg(ii)
- .arg(toqstr(makeDisplayPath(file, 30))).arg(ii);
- add(MenuItem(MenuItem::Command, label, FuncRequest(LFUN_FILE_OPEN, file)));
+ for (; lfit != lf.end() && ii <= lyxrc.num_lastfiles; ++lfit, ++ii) {
+ string const file = lfit->absFileName();
+ QString const short_path = toqstr(makeDisplayPath(file, 30));
+ QString const long_path = toqstr(makeDisplayPath(file));
+ QString label;
+ if (ii < 10)
+ label = QString("%1. %2|%3").arg(ii).arg(short_path).arg(ii);
+ else
+ label = QString("%1. %2").arg(ii).arg(short_path);
+ add(MenuItem(MenuItem::Command, label,
+ FuncRequest(LFUN_FILE_OPEN, file), long_path));
}
}
void MenuDefinition::expandDocuments()
{
+ MenuItem item(MenuItem::Submenu, qt_("Hidden|H"));
+ item.setSubmenu(MenuDefinition(qt_("Hidden|H")));
+
Buffer * first = theBufferList().first();
- if (first) {
- Buffer * b = first;
- int ii = 1;
-
- // We cannot use a for loop as the buffer list cycles.
- do {
+ if (!first) {
+ add(MenuItem(MenuItem::Info, qt_("<No Documents Open>")));
+ return;
+ }
+
+ int i = 0;
+ while (true) {
+ if (!guiApp->currentView())
+ break;
+ GuiWorkArea * wa = guiApp->currentView()->workArea(i);
+ if (!wa)
+ break;
+ Buffer const & b = wa->bufferView().buffer();
+ 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,
+ FuncRequest(LFUN_BUFFER_SWITCH, b.absFileName())));
+ ++i;
+ }
+
+
+ i = 0;
+ Buffer * b = first;
+ // We cannot use a for loop as the buffer list cycles.
+ do {
+ if (!(guiApp->currentView()
+ && guiApp->currentView()->workArea(*b))) {
QString label = toqstr(b->fileName().displayName(20));
if (!b->isClean())
label += "*";
- if (ii < 10)
- label = QString::number(ii) + ". " + label + '|' + QString::number(ii);
- add(MenuItem(MenuItem::Command, 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,
FuncRequest(LFUN_BUFFER_SWITCH, b->absFileName())));
-
- b = theBufferList().next(b);
- ++ii;
- } while (b != first);
- } else {
- add(MenuItem(MenuItem::Command, qt_("No Documents Open!"),
- FuncRequest(LFUN_NOACTION)));
- }
+ ++i;
+ }
+ b = theBufferList().next(b);
+ } while (b != first);
+
+ if (!item.submenu().empty())
+ add(item);
}
{
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();
+ string const file = bm.bookmark(i).filename.absFileName();
QString const label = QString("%1. %2|%3").arg(i)
.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)
+void MenuDefinition::expandFormats(MenuItem::Kind const 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;
- FuncCode action;
+ FormatList formats;
+ FuncCode action = LFUN_NOACTION;
switch (kind) {
case MenuItem::ImportFormats:
action = LFUN_BUFFER_IMPORT;
break;
case MenuItem::ViewFormats:
- formats = buf->exportableFormats(true);
+ formats = buf->params().exportableFormats(true);
action = LFUN_BUFFER_VIEW;
break;
case MenuItem::UpdateFormats:
- formats = buf->exportableFormats(true);
+ formats = buf->params().exportableFormats(true);
action = LFUN_BUFFER_UPDATE;
break;
- default:
- formats = buf->exportableFormats(false);
+ case MenuItem::ExportFormats:
+ formats = buf->params().exportableFormats(false);
action = LFUN_BUFFER_EXPORT;
+ break;
+ default:
+ LATTEST(false);
+ return;
}
- sort(formats.begin(), formats.end(), &compareFormat);
- Formats::const_iterator fit = formats.begin();
- Formats::const_iterator end = formats.end();
- for (; fit != end ; ++fit) {
- if ((*fit)->dummy())
+ 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));
+
+ for (Format const * f : formats) {
+ if (f->dummy())
continue;
- docstring lab = from_utf8((*fit)->prettyname());
- docstring scut = from_utf8((*fit)->shortcut());
+ docstring lab = f->prettyname();
+ docstring const scut = from_utf8(f->shortcut());
docstring const tmplab = lab;
-
+
if (!scut.empty())
lab += char_type('|') + scut;
- docstring lab_i18n = translateIfPossible(lab);
+ docstring const lab_i18n = translateIfPossible(lab);
+ docstring const shortcut = split(lab_i18n, lab, '|');
+
bool const untranslated = (lab == lab_i18n);
- QString const shortcut = toqstr(split(lab_i18n, lab, '|'));
- QString label = toqstr(lab);
- if (untranslated)
- // this might happen if the shortcut
- // has been redefined
- label = toqstr(translateIfPossible(tmplab));
+ docstring label = untranslated ? translateIfPossible(tmplab) : lab;
switch (kind) {
case MenuItem::ImportFormats:
- label += "...";
+ label += from_ascii("...");
break;
case MenuItem::ViewFormats:
- case MenuItem::ExportFormats:
case MenuItem::UpdateFormats:
- if (!(*fit)->documentFormat())
+ if (f->name() == buf->params().getDefaultOutputFormat()) {
+ docstring lbl = (kind == MenuItem::ViewFormats
+ ? bformat(_("View [%1$s]|V"), label)
+ : bformat(_("Update [%1$s]|U"), label));
+ add(MenuItem(MenuItem::Command, toqstr(lbl), FuncRequest(action)));
+ continue;
+ }
+ // fall through
+ case MenuItem::ExportFormats:
+ if (!f->inExportMenu())
continue;
break;
default:
- LASSERT(false, /**/);
- break;
+ // we already asserted earlier in this case
+ // LATTEST(false);
+ continue;
}
- if (!shortcut.isEmpty())
+ if (!shortcut.empty())
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) {
+ // 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, f->name())));
+ else
+ add(MenuItem(MenuItem::Command, toqstr(label),
+ FuncRequest(action, f->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();
FloatList::const_iterator end = floats.end();
+ set<string> seen;
for (; cit != end; ++cit) {
- addWithStatusCheck(MenuItem(MenuItem::Command,
- qt_(cit->second.listName()),
- FuncRequest(LFUN_FLOAT_LIST_INSERT,
- cit->second.type())));
+ if (!cit->second.usesFloatPkg()) {
+ // Different floats could declare the same ListCommand. We only
+ // want it on the list once, though.
+ string const & list_cmd = cit->second.listCommand();
+ if (list_cmd.empty())
+ // we do not know how to generate such a list
+ continue;
+ // This form of insert returns an iterator pointing to the newly
+ // inserted element OR the existing element with that value, and
+ // a bool indicating whether we inserted a new element. So we can
+ // see if one is there and insert it if not all at once.
+ pair<set<string>::iterator, bool> ret = seen.insert(list_cmd);
+ if (!ret.second)
+ continue;
+ }
+ string const & list_name = cit->second.listName();
+ addWithStatusCheck(MenuItem(MenuItem::Command, qt_(list_name),
+ FuncRequest(LFUN_FLOAT_LIST_INSERT, cit->second.floattype())));
}
}
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();
QString const label = qt_(cit->second.name());
addWithStatusCheck(MenuItem(MenuItem::Command, label,
FuncRequest(LFUN_FLOAT_INSERT,
- cit->second.type())));
+ cit->second.floattype())));
}
}
-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)
- addWithStatusCheck(MenuItem(MenuItem::Command,
+ 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_ascii("Flex:")))
+ label = label.substr(5);
+ 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() && s == "custom")
- add(MenuItem(MenuItem::Command,
- qt_("No custom insets defined!"),
- FuncRequest(LFUN_NOACTION)));
+ if (items_.empty() && type == InsetLayout::CUSTOM && !buf->hasReadonlyFlag())
+ 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());
- if (toc_list[i].depth() == depth
- && shortcut_count < 9) {
- if (label.contains(QString::number(shortcut_count + 1)))
- label += '|' + QString::number(++shortcut_count);
+ label += limitStringLength(toc_list[i].asString());
+ if (toc_list[i].depth() == depth) {
+ label += '|';
+ if (shortcut_count < 9) {
+ if (label.contains(QString::number(shortcut_count + 1)))
+ label += QString::number(++shortcut_count);
+ }
}
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());
- if (toc_list[pos].depth() == depth &&
- shortcut_count < 9) {
- if (label.contains(QString::number(shortcut_count + 1)))
- label += '|' + QString::number(++shortcut_count);
+ label += limitStringLength(toc_list[pos].asString());
+ if (toc_list[pos].depth() == depth) {
+ label += '|';
+ if (shortcut_count < 9) {
+ if (label.contains(QString::number(shortcut_count + 1)))
+ 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::Command, qt_("No Document Open!"),
- FuncRequest(LFUN_NOACTION)));
+ 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")
+ // 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 (toc.first == "tableofcontents" || toc.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())));
- }
- }
-
- 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);
- 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 (!TocBackend::isOther(toc.first))
add(item);
- } else
+ else
other_lists.add(item);
}
if (!other_lists.empty()) {
item.setSubmenu(other_lists);
add(item);
}
-
// 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);
+ add(MenuItem(MenuItem::Separator));
+ 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())
+ expandToc2(*cit->second, 0, cit->second->size(), 0,
+ "tableofcontents");
+ else
+ add(MenuItem(MenuItem::Info, qt_("(Empty Table of Contents)")));
+ }
+}
+
+
+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);
}
docstring_list::const_iterator end = sel.end();
for (unsigned int index = 0; cit != end; ++cit, ++index) {
- add(MenuItem(MenuItem::Command, toqstr(*cit),
+ add(MenuItem(MenuItem::Command, toqstr(*cit) + '|',
FuncRequest(LFUN_PASTE, convert<string>(index))));
}
}
void MenuDefinition::expandBranches(Buffer const * buf)
{
- if (!buf) {
- add(MenuItem(MenuItem::Command,
- qt_("No Document Open!"),
- FuncRequest(LFUN_NOACTION)));
+ if (!buf || buf->hasReadonlyFlag())
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);
+ } else
+ label += char_type('|');
+ 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) {
+ docstring const label =
+ bformat(_("Index: %1$s"), cit->index());
+ addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(label),
+ FuncRequest(LFUN_INDEX_PRINT, cit->shortcut())));
+ } else {
+ docstring const label =
+ bformat(_("Index Entry (%1$s)"), 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(p);
+ addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(cit->index()),
+ FuncRequest(LFUN_INSET_MODIFY, data)));
+ } else {
+ docstring const label =
+ bformat(_("Index Entry (%1$s)"), 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,
FuncRequest(LFUN_NOACTION)));
return;
}
- InsetCommand const * citinset =
- static_cast<InsetCommand const *>(inset);
-
+ InsetCitation const * citinset =
+ static_cast<InsetCitation const *>(inset);
+
Buffer const * buf = &bv->buffer();
- docstring key = citinset->getParam("key");
- // we can only handle one key currently
- if (contains(key, ','))
- key = qstring_to_ucs4(toqstr(key).split(',')[0]);
+ BufferParams const & bp = buf->masterParams();
+ string const cmd = citinset->params().getCmdName();
- vector<CiteStyle> citeStyleList = citeStyles(buf->params().citeEngine());
- docstring_list citeStrings =
- buf->masterBibInfo().getCiteStrings(key, bv->buffer());
+ docstring const & key = citinset->getParam("key");
+ if (key.empty()) {
+ add(MenuItem(MenuItem::Command,
+ qt_("No citations selected!"),
+ FuncRequest(LFUN_NOACTION)));
+ return;
+ }
- docstring_list::const_iterator cit = citeStrings.begin();
- docstring_list::const_iterator end = citeStrings.end();
+ size_t const n = cmd.size();
+ bool const force = isUpperCase(cmd[0]);
+ bool const star = cmd[n] == '*';
+
+ vector<docstring> const keys = getVectorFromString(key);
+
+ 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.forceUpperCase = force;
+ ci.Starred = star;
+ ci.context = CiteItem::Dialog;
+ ci.max_size = 40;
+ ci.isQualified = qualified;
+ ci.pretexts = pres;
+ ci.posttexts = posts;
+ BiblioInfo::CiteStringMap citeStrings =
+ buf->masterBibInfo().getCiteStrings(keys, citeStyleList, bv->buffer(), ci);
+
+ 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;
- CiteStyle cst = citeStyleList[ii - 1];
- cs.style = cst;
+ docstring label = cit->second;
+ CitationStyle cs = citeStyleList[ii - 1];
+ cs.forceUpperCase &= force;
+ cs.hasStarredVersion &= star;
addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(label),
- FuncRequest(LFUN_NEXT_INSET_MODIFY,
+ FuncRequest(LFUN_INSET_MODIFY,
"changetype " + from_utf8(citationStyleToString(cs)))));
}
+
+ if (cs.hasStarredVersion) {
+ docstring starred = _("All authors|h");
+ // Check if we have a custom string/tooltip for the starred version
+ if (!cs.stardesc.empty()) {
+ string val =
+ bp.documentClass().getCiteMacro(buf->params().citeEngineType(), cs.stardesc);
+ if (!val.empty())
+ starred = translateIfPossible(from_utf8(val));
+ // Transform qt-style accelerators to menu-style
+ int const amps = count_char(starred, '&');
+ if (amps > 0) {
+ if (amps > 1)
+ starred = subst(starred, from_ascii("&&"), from_ascii("<:amp:>"));
+ size_t n = starred.find('&');
+ char_type accel = char_type();
+ if (n != docstring::npos && n < starred.size() - 1)
+ accel = starred[n + 1];
+ starred = subst(starred, from_ascii("&"), from_ascii(""));
+ if (amps > 1)
+ starred = subst(starred, from_ascii("<:amp:>"), from_ascii("&&"));
+ if (accel != char_type())
+ starred = starred + '|' + accel;
+ }
+ }
+ add(MenuItem(MenuItem::Separator));
+ addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(starred),
+ FuncRequest(LFUN_INSET_MODIFY, "toggleparam star")));
+ }
+
+ if (cs.forceUpperCase) {
+ if (!cs.hasStarredVersion)
+ add(MenuItem(MenuItem::Separator));
+ addWithStatusCheck(MenuItem(MenuItem::Command, toqstr(_("Force upper case|u")),
+ FuncRequest(LFUN_INSET_MODIFY, "toggleparam casing")));
+ }
+}
+
+
+void MenuDefinition::expandArguments(BufferView const * bv, bool switcharg)
+{
+ if (!bv)
+ return;
+
+ if (!bv->cursor().inTexted())
+ return;
+
+ Inset const * inset = &bv->cursor().inset();
+ 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;
+ docstring str = arg.menustring.empty()? arg.labelstring : arg.menustring;
+ QString item = toqstr(translateIfPossible(str));
+ if (switcharg)
+ add(MenuItem(MenuItem::Command, item,
+ FuncRequest(LFUN_INSET_MODIFY,
+ from_ascii("changetype ")
+ + from_ascii((*lait).first))));
+ else
+ add(MenuItem(MenuItem::Command, item,
+ FuncRequest(LFUN_ARGUMENT_INSERT,
+ from_ascii((*lait).first))));
+ }
+}
+
+
+void MenuDefinition::expandCaptions(Buffer const * buf, bool switchcap)
+{
+ if (!buf)
+ return;
+
+ DocumentClass const & dc = buf->params().documentClass();
+ vector< pair<docstring, FuncRequest> > caps;
+ for (pair<docstring, InsetLayout> const & il : dc.insetLayouts()) {
+ docstring instype;
+ docstring const type = split(il.first, instype, ':');
+ if (instype == from_ascii("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) {
+ add(MenuItem(MenuItem::Command, qt_("Caption"), caps.front().second));
+ return;
+ }
+
+ MenuDefinition captions;
+ 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);
+ if (switchcap)
+ add(MenuItem(MenuItem::Command, toqstr(cmitem), cap.second));
+ else
+ captions.add(MenuItem(MenuItem::Command, toqstr(trtype), cap.second));
+ }
+ if (!captions.empty()) {
+ MenuItem item(MenuItem::Submenu, qt_("Caption"));
+ item.setSubmenu(captions);
+ add(item);
+ }
+}
+
+
+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 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));
+ 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));
+ }
+ 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));
+ }
+
+ 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)
+ 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"))));
+ }
}
} // namespace anon
{
/// 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.size() == 0) {
+ if (menu.empty()) {
LYXERR(Debug::GUI, "\tERROR: empty menu " << menu.name());
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());
- } else {
- // we have a MenuItem::Command
- qMenu.addAction(new Action(view, QIcon(), label(*m),
- m->func(), QString(), &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_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,
+ QStyleHintReturn *returnData = 0) const
+ {
+ if (hint == QStyle::SH_UnderlineShortcut)
+ return 1;
+ return QProxyStyle::styleHint(hint, opt, widget, returnData);
+ }
+};
+#endif
+
/////////////////////////////////////////////////////////////////////
// Menu implementation
/////////////////////////////////////////////////////////////////////
-Menu::Menu(GuiView * gv, QString const & name, bool top_level)
+Menu::Menu(GuiView * gv, QString const & name, bool top_level, bool keyboard)
: QMenu(gv), d(new Menu::Impl)
{
+#if (defined(Q_OS_WIN) || defined(Q_CYGWIN_WIN)) && (QT_VERSION >= 0x040600)
+ if (keyboard)
+ setStyle(new AlwaysMnemonicStyle);
+#else
+ (void) keyboard;
+#endif
d->top_level_menu = top_level? new MenuDefinition : 0;
d->view = gv;
d->name = name;
}
+void Menu::clear()
+{
+ QList<QAction *> items = actions();
+ for (int i = 0; i != items.size(); ++i) {
+ // QAction::menu() returns 0 if there's no submenu.
+ delete items.at(i)->menu();
+ }
+ QMenu::clear();
+}
+
+
/////////////////////////////////////////////////////////////////////
// Menus::Impl definition and implementation
/////////////////////////////////////////////////////////////////////
/// 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, 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 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:
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 const MacMenuEntry entries[] = {
{LFUN_DIALOG_SHOW, "aboutlyx", "About LyX",
QAction::AboutRole},
{LFUN_DIALOG_SHOW, "prefs", "Preferences",
QAction::PreferencesRole},
+#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 (specialmenu_.size() == 0) {
+ if (first_call) {
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();
- for (size_t i = 0 ; cit != end ; ++cit, ++i) {
- Action * action = new Action(view, 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.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, "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::LanguageSelector:
+ tomenu.expandLanguageSelector(buf);
+ break;
+
+ case MenuItem::Arguments:
+ tomenu.expandArguments(bv, false);
+ break;
+
+ case MenuItem::SwitchArguments:
+ 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::SwitchQuotes:
+ tomenu.expandQuotes(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);
}
}
{
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
//
/////////////////////////////////////////////////////////////////////
Menus::~Menus()
{
- delete d;
+ delete d;
}
enum {
md_menu,
md_menubar,
- md_endmenuset,
+ md_endmenuset
};
LexerKeyword menutags[] = {
void Menus::fillMenuBar(QMenuBar * qmb, GuiView * view, bool initial)
{
if (initial) {
-#ifdef Q_WS_MACX
- // setup special mac specific menu item
- d->macxMenuBarInit(view, qmb);
+#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.
+ 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());
- if (d->menubar_.size() == 0) {
+ if (d->menubar_.empty()) {
LYXERR(Debug::GUI, "\tERROR: empty menu bar"
<< d->menubar_.name());
return;
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();
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;
if (qmenu->d->name.isEmpty())
return;
- // Here, We make sure that theLyXFunc points to the correct LyXView.
- theLyXFunc().setLyXView(qmenu->d->view);
+ docstring identifier = qstring_to_ucs4(qmenu->d->name);
+ MenuDefinition fromLyxMenu(qmenu->d->name);
+ while (!identifier.empty()) {
+ docstring menu_name;
+ identifier = split(identifier, menu_name, ';');
+
+ if (!d->hasMenu(toqstr(menu_name))) {
+ LYXERR(Debug::GUI, "\tWARNING: non existing menu: "
+ << menu_name);
+ continue;
+ }
+
+ MenuDefinition cat_menu = d->getMenu(toqstr(menu_name));
+ //FIXME: 50 is a wild guess. We should take into account here
+ //the expansion of menu items, disabled optional items etc.
+ bool const in_sub_menu = !fromLyxMenu.empty()
+ && fromLyxMenu.size() + cat_menu.size() > 50 ;
+ if (in_sub_menu)
+ fromLyxMenu.catSub(menu_name);
+ else
+ fromLyxMenu.cat(cat_menu);
+ fromLyxMenu.add(MenuItem(MenuItem::Separator));
+ }
- if (!d->hasMenu(qmenu->d->name)) {
- qmenu->addAction(qt_("No action defined!"));
- LYXERR(Debug::GUI, "\tWARNING: non existing menu: "
- << qmenu->d->name);
+ if (fromLyxMenu.empty()) {
+ qmenu->addAction(qt_("No Action Defined!"));
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);
+ qmenu->d->populate(qmenu, *qmenu->d->top_level_menu);
}
-Menu * Menus::menu(QString const & name, GuiView & view)
+Menu * Menus::menu(QString const & name, GuiView & view, bool keyboard)
{
LYXERR(Debug::GUI, "Context menu requested: " << name);
Menu * menu = d->name_map_[&view].value(name, 0);
return 0;
}
- menu = new Menu(&view, name, true);
+ menu = new Menu(&view, name, true, keyboard);
d->name_map_[&view][name] = menu;
return menu;
}
} // namespace frontend
} // namespace lyx
-#include "Menus_moc.cpp"
+#include "moc_Menus.cpp"
projects / lyx.git / blobdiff