X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ffrontends%2Fqt4%2FGuiApplication.cpp;h=22c129b350285ff7164f86ed36cd9fc4ef5c7116;hb=91a5263d681c60544501bd402b8c5c215ea071bd;hp=e4a4797f61a4112cec662ea1de7675b1646d7152;hpb=9236a93894f6a182eb17a219b216eff747e50a27;p=lyx.git diff --git a/src/frontends/qt4/GuiApplication.cpp b/src/frontends/qt4/GuiApplication.cpp index e4a4797f61..d4b1701758 100644 --- a/src/frontends/qt4/GuiApplication.cpp +++ b/src/frontends/qt4/GuiApplication.cpp @@ -14,10 +14,10 @@ #include "GuiApplication.h" +#include "ToolTipFormatter.h" #include "ColorCache.h" #include "ColorSet.h" #include "GuiClipboard.h" -#include "GuiImage.h" #include "GuiKeySymbol.h" #include "GuiSelection.h" #include "GuiView.h" @@ -32,12 +32,17 @@ #include "Buffer.h" #include "BufferList.h" +#include "BufferParams.h" #include "BufferView.h" #include "CmdDef.h" #include "Color.h" +#include "Converter.h" +#include "CutAndPaste.h" +#include "ErrorList.h" #include "Font.h" #include "FuncRequest.h" #include "FuncStatus.h" +#include "GuiWorkArea.h" #include "Intl.h" #include "KeyMap.h" #include "Language.h" @@ -53,37 +58,39 @@ #include "Thesaurus.h" #include "version.h" +#include "insets/InsetText.h" + #include "support/convert.h" #include "support/debug.h" #include "support/ExceptionMessage.h" #include "support/FileName.h" #include "support/filetools.h" -#include "support/foreach.h" #include "support/ForkedCalls.h" #include "support/gettext.h" #include "support/lassert.h" #include "support/lstrings.h" #include "support/lyxalgo.h" // sorted +#include "support/textutils.h" #include "support/Messages.h" #include "support/os.h" #include "support/Package.h" -#include "support/Path.h" -#include "support/Systemcall.h" +#include "support/TempFile.h" -#ifdef Q_WS_MACX +#ifdef Q_OS_MAC +#include "support/AppleScript.h" #include "support/linkback/LinkBackProxy.h" #endif #include #include -#include #include +#include #include #include -#include #include #include +#include #include #include #include @@ -91,7 +98,6 @@ #include #include #include -#include #include #include #include @@ -100,34 +106,47 @@ #include #include #include -#include #include #include #include -#include #include #include -#if QT_VERSION >= 0x040400 #include -#endif #include #ifdef Q_WS_X11 #include #include +#include #undef CursorShape #undef None +#elif defined(QPA_XCB) +#include +#ifdef HAVE_QT5_X11_EXTRAS +#include +#endif #endif -#ifdef Q_WS_WIN +#if (QT_VERSION < 0x050000) || (QT_VERSION >= 0x050400) +#if defined(Q_OS_WIN) || defined(Q_CYGWIN_WIN) +#if (QT_VERSION < 0x050000) #include +#define QWINDOWSMIME QWindowsMime +#else +#include +#define QWINDOWSMIME QWinMime +#endif #ifdef Q_CC_GNU #include #endif #include -#endif // Q_WS_WIN +#endif +#endif + +#ifdef Q_OS_MAC +#include +#endif // Q_OS_MAC -#include "support/bind.h" #include #include @@ -152,7 +171,7 @@ namespace lyx { frontend::Application * createApplication(int & argc, char * argv[]) { -#ifndef Q_WS_X11 +#if !defined(Q_WS_X11) && !defined(QPA_XCB) // prune -geometry argument(s) by shifting // the following ones 2 places down. for (int i = 0 ; i < argc ; ++i) { @@ -165,6 +184,12 @@ frontend::Application * createApplication(int & argc, char * argv[]) } } #endif + +#if defined(Q_OS_WIN) || defined(Q_CYGWIN_WIN) + // On Windows, allow bringing the LyX window to top + AllowSetForegroundWindow(ASFW_ANY); +#endif + frontend::GuiApplication * guiApp = new frontend::GuiApplication(argc, argv); // I'd rather do that in the constructor, but I do not think that // the palette is accessible there. @@ -172,6 +197,26 @@ frontend::Application * createApplication(int & argc, char * argv[]) return guiApp; } + +void setLocale() +{ + QLocale theLocale; + string code; + if (lyxrc.gui_language == "auto") { + theLocale = QLocale::system(); + code = fromqstr(theLocale.name()); + } else { + Language const * l = languages.getLanguage(lyxrc.gui_language); + code = l ? l->code() : "C"; + theLocale = QLocale(toqstr(code)); + } + // Qt tries to outsmart us and transforms en_US to C. + Messages::guiLanguage((code == "C") ? "en_US" : code); + QLocale::setDefault(theLocale); + setlocale(LC_NUMERIC, "C"); +} + + namespace frontend { @@ -188,14 +233,35 @@ vector loadableImageFormats() if (qt_formats.empty()) LYXERR(Debug::GRAPHICS, "\nQt4 Problem: No Format available!"); + bool jpeg_found = false; + bool jpg_found = false; for (QList::const_iterator it = qt_formats.begin(); it != qt_formats.end(); ++it) { LYXERR(Debug::GRAPHICS, (const char *) *it << ", "); string ext = ascii_lowercase((const char *) *it); // special case - if (ext == "jpeg") + if (ext == "jpeg") { + jpeg_found = true; + if (jpg_found) + continue; ext = "jpg"; + } + else if (ext == "jpg") { + jpg_found = true; + if (jpeg_found) + continue; + } + else if (lyxrc.use_converter_cache && + (ext == "svg" || ext == "svgz") && + theConverters().isReachable("svg", "png")) + // Qt only supports SVG 1.2 tiny. See #9778. We prefer displaying + // the SVG as in the output. However we require that the converter + // cache is enabled since this is expensive. We also require that + // an explicit svg->png converter is defined, since the default + // converter could produce bad quality as well. This assumes that + // png can always be loaded. + continue; fmts.push_back(ext); } @@ -211,13 +277,13 @@ vector loadableImageFormats() namespace { -struct PngMap { +struct ImgMap { QString key; QString value; }; -bool operator<(PngMap const & lhs, PngMap const & rhs) +bool operator<(ImgMap const & lhs, ImgMap const & rhs) { return lhs.key < rhs.key; } @@ -226,7 +292,7 @@ bool operator<(PngMap const & lhs, PngMap const & rhs) class CompareKey { public: CompareKey(QString const & name) : name_(name) {} - bool operator()(PngMap const & other) const { return other.key == name_; } + bool operator()(ImgMap const & other) const { return other.key == name_; } private: QString const name_; }; @@ -234,84 +300,191 @@ private: // this must be sorted alphabetically // Upper case comes before lower case -PngMap sorted_png_map[] = { +// Please don't change the formatting, this list is parsed by +// development/tools/generate_symbols_images.py. +ImgMap sorted_img_map[] = { + { "Arrownot", "arrownot2"}, + { "Arrowvert", "arrowvert2"}, + { "Bowtie", "bowtie2" }, + { "Box", "box2" }, { "Bumpeq", "bumpeq2" }, + { "CIRCLE", "circle3" }, { "Cap", "cap2" }, + { "CheckedBox", "checkedbox2" }, + { "Circle", "circle2" }, + { "Colonapprox", "colonapprox2" }, + { "Coloneq", "coloneq2" }, + { "Coloneqq", "coloneqq2" }, + { "Colonsim", "colonsim2" }, { "Cup", "cup2" }, + { "DOWNarrow", "downarrow3" }, { "Delta", "delta2" }, { "Diamond", "diamond2" }, + { "Doteq", "doteq2" }, { "Downarrow", "downarrow2" }, + { "Eqcolon", "eqcolon2" }, + { "Eqqcolon", "eqqcolon2" }, { "Gamma", "gamma2" }, + { "Join", "join2" }, + { "LEFTCIRCLE", "leftcircle3" }, + { "LEFTarrow", "leftarrow3" }, + { "LEFTcircle", "leftcircle4" }, + { "LHD", "lhd2" }, { "Lambda", "lambda2" }, + { "Lbag", "lbag2"}, { "Leftarrow", "leftarrow2" }, + { "Leftcircle", "leftcircle2" }, { "Leftrightarrow", "leftrightarrow2" }, + { "Longarrownot", "longarrownot2"}, { "Longleftarrow", "longleftarrow2" }, { "Longleftrightarrow", "longleftrightarrow2" }, + { "Longmapsfrom", "longmapsfrom2"}, + { "Longmapsto", "longmapsto2"}, { "Longrightarrow", "longrightarrow2" }, + { "Mapsfrom", "mapsfrom2"}, + { "Mapsfromchar", "mapsfromchar2"}, + { "Mapsto", "mapsto2"}, + { "Mapstochar", "mapstochar2"}, { "Omega", "omega2" }, { "Phi", "phi2" }, { "Pi", "pi2" }, { "Psi", "psi2" }, + { "RHD", "rhd2" }, + { "RIGHTCIRCLE", "rightcircle3" }, + { "RIGHTarrow", "rightarrow3" }, + { "RIGHTcircle", "rightcircle4" }, + { "Rbag", "rbag2"}, { "Rightarrow", "rightarrow2" }, + { "Rightcircle", "rightcircle2" }, { "Sigma", "sigma2" }, + { "Square", "square2" }, { "Subset", "subset2" }, { "Supset", "supset2" }, { "Theta", "theta2" }, + { "Thorn", "thorn2" }, + { "UParrow", "uparrow3" }, { "Uparrow", "uparrow2" }, { "Updownarrow", "updownarrow2" }, { "Upsilon", "upsilon2" }, { "Vdash", "vdash3" }, { "Vert", "vert2" }, + { "XBox", "xbox3" }, + { "Xbox", "xbox2" }, { "Xi", "xi2" }, + { "lVert", "vert2" }, + { "lvert", "vert" }, { "nLeftarrow", "nleftarrow2" }, { "nLeftrightarrow", "nleftrightarrow2" }, { "nRightarrow", "nrightarrow2" }, { "nVDash", "nvdash3" }, + { "nVdash", "nvdash4" }, { "nvDash", "nvdash2" }, + { "rVert", "vert2" }, + { "rvert", "vert" }, { "textrm \\AA", "textrm_AA"}, { "textrm \\O", "textrm_O"}, - { "vDash", "vdash2" } + { "vDash", "vdash2" }, + { "varDelta", "vardelta2" }, + { "varGamma", "vargamma2" }, + { "varLambda", "varlambda2" }, + { "varOmega", "varomega2" }, + { "varPhi", "varphi2" }, + { "varPi", "varpi2" }, + { "varPsi", "varpsi2" }, + { "varSigma", "varsigma2" }, + { "varTheta", "vartheta2" }, + { "varUpsilon", "varupsilon2" }, + { "varXi", "varxi2" } }; -size_t const nr_sorted_png_map = sizeof(sorted_png_map) / sizeof(PngMap); +size_t const nr_sorted_img_map = sizeof(sorted_img_map) / sizeof(ImgMap); -QString findPng(QString const & name) +// This list specifies which system's theme icon is related to which lyx +// command. It was based on: +// http://standards.freedesktop.org/icon-naming-spec/icon-naming-spec-latest.html +// this must be sorted alphabetically +// Upper case comes before lower case +ImgMap sorted_theme_icon_map[] = { + { "bookmark-goto 0", "go-jump" }, + { "buffer-new", "document-new" }, + { "buffer-write", "document-save" }, + { "buffer-write-as", "document-save-as" }, + { "buffer-zoom-in", "zoom-in" }, + { "buffer-zoom-out", "zoom-out" }, + { "copy", "edit-copy" }, + { "cut", "edit-cut" }, + { "depth-decrement", "format-indent-less" }, + { "depth-increment", "format-indent-more" }, + { "dialog-show spellchecker", "tools-check-spelling" }, + { "dialog-show-new-inset graphics", "insert-image" }, + { "dialog-toggle findreplaceadv", "edit-find-replace" }, + { "file-open", "document-open" }, + { "font-bold", "format-text-bold" }, + { "font-ital", "format-text-italic" }, + { "font-strikeout", "format-text-strikethrough" }, + { "font-underline", "format-text-underline" }, + { "lyx-quit", "application-exit" }, + { "paste", "edit-paste" }, + { "redo", "edit-redo" }, + { "undo", "edit-undo" }, + { "window-close", "window-close" }, + { "window-new", "window-new" } +}; + +size_t const nr_sorted_theme_icon_map = sizeof(sorted_theme_icon_map) / sizeof(ImgMap); + + +QString findImg(QString const & name) { - PngMap const * const begin = sorted_png_map; - PngMap const * const end = begin + nr_sorted_png_map; - LASSERT(sorted(begin, end), /**/); + ImgMap const * const begin = sorted_img_map; + ImgMap const * const end = begin + nr_sorted_img_map; + LATTEST(sorted(begin, end)); - PngMap const * const it = find_if(begin, end, CompareKey(name)); + ImgMap const * const it = find_if(begin, end, CompareKey(name)); - QString png_name; + QString img_name; if (it != end) { - png_name = it->value; + img_name = it->value; } else { - png_name = name; - png_name.replace('_', "underscore"); - png_name.replace(' ', '_'); + img_name = name; + img_name.replace('_', "underscore"); + img_name.replace(' ', '_'); // This way we can have "math-delim { }" on the toolbar. - png_name.replace('(', "lparen"); - png_name.replace(')', "rparen"); - png_name.replace('[', "lbracket"); - png_name.replace(']', "rbracket"); - png_name.replace('{', "lbrace"); - png_name.replace('}', "rbrace"); - png_name.replace('|', "bars"); - png_name.replace(',', "thinspace"); - png_name.replace(':', "mediumspace"); - png_name.replace(';', "thickspace"); - png_name.replace('!', "negthinspace"); + img_name.replace('(', "lparen"); + img_name.replace(')', "rparen"); + img_name.replace('[', "lbracket"); + img_name.replace(']', "rbracket"); + img_name.replace('{', "lbrace"); + img_name.replace('}', "rbrace"); + img_name.replace('|', "bars"); + img_name.replace(',', "thinspace"); + img_name.replace(':', "mediumspace"); + img_name.replace(';', "thickspace"); + img_name.replace('!', "negthinspace"); } - LYXERR(Debug::GUI, "findPng(" << name << ")\n" - << "Looking for math PNG called \"" << png_name << '"'); - return png_name; + LYXERR(Debug::GUI, "findImg(" << name << ")\n" + << "Looking for math icon called \"" << img_name << '"'); + return img_name; } -} // namespace anon +} // namespace + + +QString themeIconName(QString const & action) +{ + ImgMap const * const begin = sorted_theme_icon_map; + ImgMap const * const end = begin + nr_sorted_theme_icon_map; + LASSERT(sorted(begin, end), /**/); + + ImgMap const * const it = find_if(begin, end, CompareKey(action)); + + if (it != end) + return it->value; + return QString(); +} QString iconName(FuncRequest const & f, bool unknown) @@ -324,13 +497,13 @@ QString iconName(FuncRequest const & f, bool unknown) case LFUN_MATH_INSERT: if (!f.argument().empty()) { path = "math/"; - name1 = findPng(toqstr(f.argument()).mid(1)); + name1 = findImg(toqstr(f.argument()).mid(1)); } break; case LFUN_MATH_DELIM: case LFUN_MATH_BIGDELIM: path = "math/"; - name1 = findPng(toqstr(f.argument())); + name1 = findImg(toqstr(f.argument())); break; case LFUN_CALL: path = "commands/"; @@ -341,24 +514,9 @@ QString iconName(FuncRequest const & f, bool unknown) docstring firstcom; docstring dummy = split(f.argument(), firstcom, ';'); name1 = toqstr(firstcom); - // FIXME: we should rename the icons to tabular-xxx instead of - // "tabular-feature-xxx" - name1.replace("inset-modify tabular", "tabular-feature"); name1.replace(' ', '_'); break; } - case LFUN_INSET_MODIFY: { - // FIXME: we should rename the icons to tabular-xxx instead of - // "tabular-feature-xxx" and generalize this naming to all - // insets, not to tabular using ones. - string inset_name; - string const command = split(to_utf8(f.argument()), inset_name, ' '); - if (insetCode(inset_name) == TABULAR_CODE) { - name1 = "tabular-feature "+ toqstr(command); - name1.replace(' ', '_'); - break; - } - } default: name2 = toqstr(lyxaction.getActionName(f.action())); name1 = name2; @@ -370,14 +528,19 @@ QString iconName(FuncRequest const & f, bool unknown) } } - QString imagedir = "images/" + path; - FileName fname = imageLibFileSearch(imagedir, name1, "png"); - if (fname.exists()) - return toqstr(fname.absFileName()); + QStringList imagedirs; + imagedirs << "images/" << "images/ipa/"; + search_mode mode = theGuiApp()->imageSearchMode(); + for (int i = 0; i < imagedirs.size(); ++i) { + QString imagedir = imagedirs.at(i) + path; + FileName fname = imageLibFileSearch(imagedir, name1, "svgz,png", mode); + if (fname.exists()) + return toqstr(fname.absFileName()); - fname = imageLibFileSearch(imagedir, name2, "png"); - if (fname.exists()) - return toqstr(fname.absFileName()); + fname = imageLibFileSearch(imagedir, name2, "svgz,png", mode); + if (fname.exists()) + return toqstr(fname.absFileName()); + } path = ":/images/" + path; QDir res(path); @@ -385,69 +548,99 @@ QString iconName(FuncRequest const & f, bool unknown) LYXERR0("Directory " << path << " not found in resource!"); return QString(); } - name1 += ".png"; - if (res.exists(name1)) - return path + name1; + if (res.exists(name1 + ".svgz")) + return path + name1 + ".svgz"; + else if (res.exists(name1 + ".png")) + return path + name1 + ".png"; - name2 += ".png"; - if (res.exists(name2)) - return path + name2; + if (res.exists(name2 + ".svgz")) + return path + name2 + ".svgz"; + else if (res.exists(name2 + ".png")) + return path + name2 + ".png"; LYXERR(Debug::GUI, "Cannot find icon with filename " - << "\"" << name1 << "\"" + << "\"" << name1 << ".{svgz,png}\"" << " or filename " - << "\"" << name2 << "\"" + << "\"" << name2 << ".{svgz,png}\"" << " for command \"" << lyxaction.getActionName(f.action()) << '(' << to_utf8(f.argument()) << ")\""); if (unknown) { - imagedir = "images/"; - fname = imageLibFileSearch(imagedir, "unknown", "png"); + QString imagedir = "images/"; + FileName fname = imageLibFileSearch(imagedir, "unknown", "svgz,png", mode); if (fname.exists()) return toqstr(fname.absFileName()); - return QString(":/images/unknown.png"); + return QString(":/images/unknown.svgz"); } return QString(); } + +bool getPixmap(QPixmap & pixmap, QString const & path) +{ + return pixmap.load(path); +} + + QPixmap getPixmap(QString const & path, QString const & name, QString const & ext) { - QPixmap pixmap; QString imagedir = path; - FileName fname = imageLibFileSearch(imagedir, name, ext); - QString path1 = toqstr(fname.absFileName()); - QString path2 = ":/" + path + name + "." + ext; + FileName fname = imageLibFileSearch(imagedir, name, ext, theGuiApp()->imageSearchMode()); + QString fpath = toqstr(fname.absFileName()); + QPixmap pixmap = QPixmap(); - if (pixmap.load(path1)) { + if (getPixmap(pixmap, fpath)) { return pixmap; } - else if (pixmap.load(path2)) { - return pixmap; + + QStringList exts = ext.split(","); + fpath = ":/" + path + name + "."; + for (int i = 0; i < exts.size(); ++i) { + if (getPixmap(pixmap, fpath + exts.at(i))) { + return pixmap; + } } + bool const list = ext.contains(","); LYXERR0("Cannot load pixmap \"" - << path << name << '.' << ext - << "\", please verify resource system!"); + << path << name << "." << (list ? "{" : "") << ext + << (list ? "}" : "") << "\", please verify resource system!"); return QPixmap(); } + QIcon getIcon(FuncRequest const & f, bool unknown) { +#if (QT_VERSION >= 0x040600) + if (lyxrc.use_system_theme_icons) { + // use the icons from system theme that are available + QString action = toqstr(lyxaction.getActionName(f.action())); + if (!f.argument().empty()) + action += " " + toqstr(f.argument()); + QString const theme_icon = themeIconName(action); + if (QIcon::hasThemeIcon(theme_icon)) { + QIcon const thmicn = QIcon::fromTheme(theme_icon); + if (!thmicn.isNull()) + return thmicn; + } + } +#endif + QString icon = iconName(f, unknown); if (icon.isEmpty()) return QIcon(); //LYXERR(Debug::GUI, "Found icon: " << icon); - QPixmap pm; - if (!pm.load(icon)) { + QPixmap pixmap = QPixmap(); + if (!getPixmap(pixmap,icon)) { LYXERR0("Cannot load icon " << icon << " please verify resource system!"); return QIcon(); } - return QIcon(pm); + return QIcon(pixmap); } @@ -471,55 +664,49 @@ public: }; -//////////////////////////////////////////////////////////////////////// -// -// Mac specific stuff goes here... -// -//////////////////////////////////////////////////////////////////////// - -class MenuTranslator : public QTranslator +class GuiTranslator : public QTranslator { public: - MenuTranslator(QObject * parent) + GuiTranslator(QObject * parent = nullptr) : QTranslator(parent) {} - QString translate(const char * /*context*/, - const char * sourceText, - const char * /*comment*/ = 0) + virtual QString translate(const char * /* context */, + const char *sourceText, +#if QT_VERSION >= 0x050000 + const char * /* disambiguation */ = 0, int /* n */ = -1) const +#else + const char * /*comment*/ = 0) const +#endif { - string const s = sourceText; - if (s == N_("About %1") || s == N_("Preferences") - || s == N_("Reconfigure") || s == N_("Quit %1")) - return qt_(s); - else - return QString(); + // Here we declare the strings that need to be translated from Qt own GUI + // This is needed to include these strings to po files + _("About %1"); + _("Preferences"); + _("Reconfigure"); + _("Quit %1"); + _("&OK"); + // Already in po: "Cancel", "&Cancel" + _("Apply"); // Already in po: "&Apply" + _("Reset"); // Already in po: "&Reset" "R&eset" "Rese&t" + + docstring s = getGuiMessages().getIfFound(sourceText); + // This test should eventually be removed when translations are updated + if (s.empty()) + LYXERR(Debug::LOCALE, "Missing translation for `" + << string(sourceText) << "'"); + return toqstr(s); } }; -class GlobalMenuBar : public QMenuBar -{ -public: - /// - GlobalMenuBar() : QMenuBar(0) {} - /// - bool event(QEvent * e) - { - if (e->type() == QEvent::ShortcutOverride) { - // && activeWindow() == 0) { - QKeyEvent * ke = static_cast(e); - KeySymbol sym; - setKeySymbol(&sym, ke); - guiApp->processKeySym(sym, q_key_state(ke->modifiers())); - e->accept(); - return true; - } - return false; - } -}; +//////////////////////////////////////////////////////////////////////// +// +// Mac specific stuff goes here... +// +//////////////////////////////////////////////////////////////////////// -#ifdef Q_WS_MACX +#ifdef Q_OS_MAC // QMacPasteboardMimeGraphics can only be compiled on Mac. class QMacPasteboardMimeGraphics : public QMacPasteboardMime @@ -579,7 +766,8 @@ public: //////////////////////////////////////////////////////////////////////// // Windows specific stuff goes here... -#ifdef Q_WS_WIN +#if (QT_VERSION < 0x050000) || (QT_VERSION >= 0x050400) +#if defined(Q_OS_WIN) || defined(Q_CYGWIN_WIN) // QWindowsMimeMetafile can only be compiled on Windows. static FORMATETC cfFromMime(QString const & mimetype) @@ -599,12 +787,12 @@ static FORMATETC cfFromMime(QString const & mimetype) } -class QWindowsMimeMetafile : public QWindowsMime { +class QWindowsMimeMetafile : public QWINDOWSMIME { public: QWindowsMimeMetafile() {} - bool canConvertFromMime(FORMATETC const & formatetc, - QMimeData const * mimedata) const + bool canConvertFromMime(FORMATETC const & /*formatetc*/, + QMimeData const * /*mimedata*/) const { return false; } @@ -618,14 +806,14 @@ public: return pDataObj->QueryGetData(&formatetc) == S_OK; } - bool convertFromMime(FORMATETC const & formatetc, - const QMimeData * mimedata, STGMEDIUM * pmedium) const + bool convertFromMime(FORMATETC const & /*formatetc*/, + const QMimeData * /*mimedata*/, STGMEDIUM * /*pmedium*/) const { return false; } QVariant convertToMime(QString const & mimetype, IDataObject * pDataObj, - QVariant::Type preferredType) const + QVariant::Type /*preferredType*/) const { QByteArray data; if (!canConvertToMime(mimetype, pDataObj)) @@ -656,7 +844,7 @@ public: QVector formatsForMime(QString const & mimetype, - QMimeData const * mimedata) const + QMimeData const * /*mimedata*/) const { QVector formats; if (mimetype == emfMimeType() || mimetype == wmfMimeType()) @@ -676,36 +864,53 @@ public: } }; -#endif // Q_WS_WIN +#endif +#endif /// Allows to check whether ESC was pressed during a long operation class KeyChecker : public QObject { private: bool pressed_; + bool started_; public: - KeyChecker() { - pressed_ = false; - } + KeyChecker() : pressed_(false), started_(false) {} + void start() { QCoreApplication::instance()->installEventFilter(this); pressed_ = false; + started_ = true; } void stop() { QCoreApplication::instance()->removeEventFilter(this); + started_ = false; } bool pressed() { QCoreApplication::processEvents(); return pressed_; } + bool started() const { + return started_; + } bool eventFilter(QObject *obj, QEvent *event) { LYXERR(Debug::ACTION, "Event Type: " << event->type()); switch (event->type()) { case QEvent::Show: case QEvent::Hide: case QEvent::Resize: + case QEvent::UpdateRequest: + case QEvent::CursorChange: + case QEvent::ActionChanged: + case QEvent::EnabledChange: + case QEvent::SockAct: + case QEvent::Timer: + case QEvent::Paint: + case QEvent::ToolTipChange: + case QEvent::LayoutRequest: + case QEvent::MetaCall: return QObject::eventFilter(obj, event); default: + // FIXME Blocking all these events is a bad idea. QKeyEvent *keyEvent = dynamic_cast(event); if (keyEvent && keyEvent->key() == Qt::Key_Escape) pressed_ = true; @@ -724,9 +929,11 @@ struct GuiApplication::Private Private(): language_model_(0), meta_fake_bit(NoModifier), global_menubar_(0) { - #ifdef Q_WS_WIN + #if (QT_VERSION < 0x050000) || (QT_VERSION >= 0x050400) + #if defined(Q_OS_WIN) || defined(Q_CYGWIN_WIN) /// WMF Mime handler for Windows clipboard. - wmf_mime_ = new QWindowsMimeMetafile(); + wmf_mime_ = new QWindowsMimeMetafile; + #endif #endif initKeySequences(&theTopLevelKeymap()); } @@ -747,8 +954,10 @@ struct GuiApplication::Private FontLoader font_loader_; /// ColorCache color_cache_; - /// + /// the built-in Qt translation mechanism QTranslator qt_trans_; + /// LyX gettext-based translation for Qt elements + GuiTranslator gui_trans_; /// QHash socket_notifiers_; /// @@ -772,6 +981,9 @@ struct GuiApplication::Private /// KeyModifier meta_fake_bit; + /// The result of last dispatch action + DispatchResult dispatch_result_; + /// Multiple views container. /** * Warning: This must not be a smart pointer as the destruction of the @@ -781,16 +993,18 @@ struct GuiApplication::Private QHash views_; /// Only used on mac. - GlobalMenuBar * global_menubar_; + QMenuBar * global_menubar_; -#ifdef Q_WS_MACX +#ifdef Q_OS_MAC /// Linkback mime handler for MacOSX. QMacPasteboardMimeGraphics mac_pasteboard_mime_; #endif -#ifdef Q_WS_WIN +#if (QT_VERSION < 0x050000) || (QT_VERSION >= 0x050400) +#if defined(Q_OS_WIN) || defined(Q_CYGWIN_WIN) /// WMF Mime handler for Windows clipboard. QWindowsMimeMetafile * wmf_mime_; +#endif #endif /// Allows to check whether ESC was pressed during a long operation @@ -802,7 +1016,7 @@ GuiApplication * guiApp; GuiApplication::~GuiApplication() { -#ifdef Q_WS_MACX +#ifdef Q_OS_MAC closeAllLinkBackLinks(); #endif delete d; @@ -817,10 +1031,22 @@ GuiApplication::GuiApplication(int & argc, char ** argv) QCoreApplication::setOrganizationName(app_name); QCoreApplication::setOrganizationDomain("lyx.org"); QCoreApplication::setApplicationName(lyx_package); +#if QT_VERSION >= 0x050000 + QCoreApplication::setAttribute(Qt::AA_UseHighDpiPixmaps); +#endif - // Install translator for GUI elements. + qsrand(QDateTime::currentDateTime().toTime_t()); + + // Install LyX translator for missing Qt translations + installTranslator(&d->gui_trans_); + // Install Qt native translator for GUI elements. installTranslator(&d->qt_trans_); +#ifdef QPA_XCB + // Enable reception of XCB events. + installNativeEventFilter(this); +#endif + // FIXME: quitOnLastWindowClosed is true by default. We should have a // lyxrc setting for this in order to let the application stay resident. // But then we need some kind of dock icon, at least on Windows. @@ -828,17 +1054,15 @@ GuiApplication::GuiApplication(int & argc, char ** argv) if (lyxrc.quit_on_last_window_closed) setQuitOnLastWindowClosed(false); */ -#ifdef Q_WS_MACX +#ifdef Q_OS_MAC // FIXME: Do we need a lyxrc setting for this on Mac? This behaviour // seems to be the default case for applications like LyX. setQuitOnLastWindowClosed(false); - // This allows to translate the strings that appear in the LyX menu. - /// A translator suitable for the entries in the LyX menu. - /// Only needed with Qt/Mac. - installTranslator(new MenuTranslator(this)); + /// + setupApplescript(); #endif -#ifdef Q_WS_X11 +#if defined(Q_WS_X11) || defined(QPA_XCB) // doubleClickInterval() is 400 ms on X11 which is just too long. // On Windows and Mac OS X, the operating system's value is used. // On Microsoft Windows, calling this function sets the double @@ -873,12 +1097,13 @@ GuiApplication::GuiApplication(int & argc, char ** argv) this, SLOT(handleRegularEvents())); d->general_timer_.start(); -#if QT_VERSION >= 0x040400 // maxThreadCount() defaults in general to 2 on single or dual-processor. // This is clearly not enough in a time where we use threads for // document preview and/or export. 20 should be OK. QThreadPool::globalInstance()->setMaxThreadCount(20); -#endif + + // make sure tooltips are formatted + installEventFilter(new ToolTipFormatter(this)); } @@ -888,6 +1113,16 @@ GuiApplication * theGuiApp() } +double GuiApplication::pixelRatio() const +{ +#if QT_VERSION >= 0x050000 + return qt_scale_factor * devicePixelRatio(); +#else + return 1.0; +#endif +} + + void GuiApplication::clearSession() { QSettings settings; @@ -901,6 +1136,12 @@ docstring Application::iconName(FuncRequest const & f, bool unknown) } +docstring Application::mathIcon(docstring const & c) +{ + return qstring_to_ucs4(findImg(toqstr(c))); +} + + FuncStatus GuiApplication::getStatus(FuncRequest const & cmd) const { FuncStatus status; @@ -1077,6 +1318,30 @@ bool GuiApplication::getStatus(FuncRequest const & cmd, FuncStatus & flag) const enable = true; break; + case LFUN_BUFFER_FORALL: { + if (theBufferList().empty()) { + flag.message(from_utf8(N_("Command not allowed without a buffer open"))); + flag.setEnabled(false); + break; + } + + FuncRequest const cmdToPass = lyxaction.lookupFunc(cmd.getLongArg(0)); + if (cmdToPass.action() == LFUN_UNKNOWN_ACTION) { + flag.message(from_utf8(N_("the argument of buffer-forall is not valid"))); + flag.setEnabled(false); + } + break; + } + + case LFUN_DIALOG_SHOW: { + string const name = cmd.getArg(0); + return name == "aboutlyx" + || name == "prefs" + || name == "texinfo" + || name == "progress" + || name == "compare"; + } + default: return false; } @@ -1090,12 +1355,12 @@ bool GuiApplication::getStatus(FuncRequest const & cmd, FuncStatus & flag) const static docstring makeDispatchMessage(docstring const & msg, FuncRequest const & cmd) { - const bool verbose = (cmd.origin() == FuncRequest::MENU + const bool be_verbose = (cmd.origin() == FuncRequest::MENU || cmd.origin() == FuncRequest::TOOLBAR || cmd.origin() == FuncRequest::COMMANDBUFFER); - if (cmd.action() == LFUN_SELF_INSERT || !verbose) { - LYXERR(Debug::ACTION, "dispatch msg is " << msg); + if (cmd.action() == LFUN_SELF_INSERT || !be_verbose) { + LYXERR(Debug::ACTION, "dispatch msg is `" << msg << "'"); return msg; } @@ -1130,17 +1395,40 @@ static docstring makeDispatchMessage(docstring const & msg, } -void GuiApplication::dispatch(FuncRequest const & cmd) +DispatchResult const & GuiApplication::dispatch(FuncRequest const & cmd) { - if (current_view_ && current_view_->currentBufferView()) + DispatchResult dr; + + Buffer * buffer = 0; + if (cmd.view_origin() && current_view_ != cmd.view_origin()) { + //setCurrentView(cmd.view_origin); //does not work + dr.setError(true); + dr.setMessage(_("Wrong focus!")); + d->dispatch_result_ = dr; + return d->dispatch_result_; + } + if (current_view_ && current_view_->currentBufferView()) { current_view_->currentBufferView()->cursor().saveBeforeDispatchPosXY(); + buffer = ¤t_view_->currentBufferView()->buffer(); + } + + dr.screenUpdate(Update::FitCursor); + { + // This handles undo groups automagically + UndoGroupHelper ugh(buffer); + dispatch(cmd, dr); + } - DispatchResult dr; // redraw the screen at the end (first of the two drawing steps). // This is done unless explicitly requested otherwise - dr.screenUpdate(Update::FitCursor); - dispatch(cmd, dr); + updateCurrentView(cmd, dr); + d->dispatch_result_ = dr; + return d->dispatch_result_; +} + +void GuiApplication::updateCurrentView(FuncRequest const & cmd, DispatchResult & dr) +{ if (!current_view_) return; @@ -1149,6 +1437,9 @@ void GuiApplication::dispatch(FuncRequest const & cmd) if (dr.needBufferUpdate()) { bv->cursor().clearBufferUpdate(); bv->buffer().updateBuffer(); + } else if (dr.needChangesUpdate()) { + // updateBuffer() already updates the change-tracking presence flag + bv->buffer().updateChangesPresent(); } // BufferView::update() updates the ViewMetricsInfo and // also initializes the position cache for all insets in @@ -1160,7 +1451,7 @@ void GuiApplication::dispatch(FuncRequest const & cmd) theSelection().haveSelection(bv->cursor().selection()); // update gui - current_view_->restartCursor(); + current_view_->restartCaret(); } if (dr.needMessageUpdate()) { // Some messages may already be translated, so we cannot use _() @@ -1177,7 +1468,7 @@ void GuiApplication::gotoBookmark(unsigned int idx, bool openFile, return; BookmarksSection::Bookmark const & bm = theSession().bookmarks().bookmark(idx); - LASSERT(!bm.filename.empty(), /**/); + LASSERT(!bm.filename.empty(), return); string const file = bm.filename.absFileName(); // if the file is not opened, open it. if (!theBufferList().exists(bm.filename)) { @@ -1200,6 +1491,7 @@ void GuiApplication::gotoBookmark(unsigned int idx, bool openFile, // if the current buffer is not that one, switch to it. BufferView * doc_bv = current_view_ ? current_view_->documentBufferView() : 0; + Cursor const * old = doc_bv ? &doc_bv->cursor() : 0; if (!doc_bv || doc_bv->buffer().fileName() != tmp.filename) { if (switchToBuffer) { dispatch(FuncRequest(LFUN_BUFFER_SWITCH, file)); @@ -1211,16 +1503,19 @@ void GuiApplication::gotoBookmark(unsigned int idx, bool openFile, } // moveToPosition try paragraph id first and then paragraph (pit, pos). - if (!doc_bv->moveToPosition( + if (!doc_bv || !doc_bv->moveToPosition( tmp.bottom_pit, tmp.bottom_pos, tmp.top_id, tmp.top_pos)) return; + Cursor & cur = doc_bv->cursor(); + if (old && cur != *old) + notifyCursorLeavesOrEnters(*old, cur); + // bm changed if (idx == 0) return; // Cursor jump succeeded! - Cursor const & cur = doc_bv->cursor(); pit_type new_pit = cur.pit(); pos_type new_pos = cur.pos(); int new_id = cur.paragraph().id(); @@ -1243,23 +1538,21 @@ void GuiApplication::reconfigure(string const & option) current_view_->message(_("Running configure...")); // Run configure in user lyx directory - PathChanger p(package().user_support()); - string configure_command = package().configure_command(); - configure_command += option; - Systemcall one; - int ret = one.startscript(Systemcall::Wait, configure_command); - p.pop(); + string const lock_file = package().getConfigureLockName(); + int fd = fileLock(lock_file.c_str()); + int const ret = package().reconfigureUserLyXDir(option); // emit message signal. if (current_view_) current_view_->message(_("Reloading configuration...")); lyxrc.read(libFileSearch(QString(), "lyxrc.defaults"), false); // Re-read packages.lst LaTeXPackages::getAvailable(); + fileUnlock(fd, lock_file.c_str()); if (ret) Alert::information(_("System reconfiguration failed"), _("The system reconfiguration has failed.\n" - "Default textclass is used but LyX may " + "Default textclass is used but LyX may\n" "not be able to work properly.\n" "Please reconfigure again if needed.")); else @@ -1311,6 +1604,13 @@ void GuiApplication::dispatch(FuncRequest const & cmd, DispatchResult & dr) return; }; + if (cmd.origin() == FuncRequest::LYXSERVER) { + if (current_view_ && current_view_->currentBufferView()) + current_view_->currentBufferView()->cursor().saveBeforeDispatchPosXY(); + // we will also need to redraw the screen at the end + dr.screenUpdate(Update::FitCursor); + } + // Assumes that the action will be dispatched. dr.dispatched(true); @@ -1345,20 +1645,13 @@ void GuiApplication::dispatch(FuncRequest const & cmd, DispatchResult & dr) case LFUN_SCREEN_FONT_UPDATE: { // handle the screen font changes. d->font_loader_.update(); - // Backup current_view_ - GuiView * view = current_view_; - // Set current_view_ to zero to forbid GuiWorkArea::redraw() - // to skip the refresh. - current_view_ = 0; - theBufferList().changed(false); - // Restore current_view_ - current_view_ = view; + dr.screenUpdate(Update::Force | Update::FitCursor); break; } case LFUN_BUFFER_NEW: validateCurrentView(); - if (d->views_.empty() + if (!current_view_ || (!lyxrc.open_buffers_in_tabs && current_view_->documentBufferView() != 0)) { createView(QString(), false); // keep hidden current_view_->newDocument(to_utf8(cmd.argument()), false); @@ -1371,7 +1664,7 @@ void GuiApplication::dispatch(FuncRequest const & cmd, DispatchResult & dr) case LFUN_BUFFER_NEW_TEMPLATE: validateCurrentView(); - if (d->views_.empty() + if (!current_view_ || (!lyxrc.open_buffers_in_tabs && current_view_->documentBufferView() != 0)) { createView(); current_view_->newDocument(to_utf8(cmd.argument()), true); @@ -1383,21 +1676,38 @@ void GuiApplication::dispatch(FuncRequest const & cmd, DispatchResult & dr) break; case LFUN_FILE_OPEN: { + // FIXME: normally the code below is not needed, since getStatus makes sure that + // current_view_ is not null. validateCurrentView(); // FIXME: create a new method shared with LFUN_HELP_OPEN. string const fname = to_utf8(cmd.argument()); - if (d->views_.empty() || (!lyxrc.open_buffers_in_tabs - && current_view_->documentBufferView() != 0)) { + bool const is_open = FileName::isAbsolute(fname) + && theBufferList().getBuffer(FileName(fname)); + if (!current_view_ + || (!lyxrc.open_buffers_in_tabs + && current_view_->documentBufferView() != 0 + && !is_open)) { // We want the ui session to be saved per document and not per // window number. The filename crc is a good enough identifier. boost::crc_32_type crc; crc = for_each(fname.begin(), fname.end(), crc); createView(crc.checksum()); current_view_->openDocument(fname); - if (current_view_ && !current_view_->documentBufferView()) + if (!current_view_->documentBufferView()) current_view_->close(); - } else + else if (cmd.origin() == FuncRequest::LYXSERVER) { + current_view_->raise(); + current_view_->activateWindow(); + current_view_->showNormal(); + } + } else { current_view_->openDocument(fname); + if (cmd.origin() == FuncRequest::LYXSERVER) { + current_view_->raise(); + current_view_->activateWindow(); + current_view_->showNormal(); + } + } break; } @@ -1422,13 +1732,8 @@ void GuiApplication::dispatch(FuncRequest const & cmd, DispatchResult & dr) current_view_->message(bformat(_("Opening help file %1$s..."), makeDisplayPath(fname.absFileName()))); Buffer * buf = current_view_->loadDocument(fname, false); - -#ifndef DEVEL_VERSION if (buf) - buf->setReadonly(true); -#else - (void) buf; -#endif + buf->setReadonly(!current_view_->develMode()); break; } @@ -1462,6 +1767,8 @@ void GuiApplication::dispatch(FuncRequest const & cmd, DispatchResult & dr) } // Make sure we don't keep old colors in cache. d->color_cache_.clear(); + // Update the current view + lyx::dispatch(FuncRequest(LFUN_SCREEN_FONT_UPDATE)); break; } @@ -1482,8 +1789,20 @@ void GuiApplication::dispatch(FuncRequest const & cmd, DispatchResult & dr) } actOnUpdatedPrefs(lyxrc_orig, lyxrc); - resetGui(); + // If the request comes from the minibuffer, then we can't reset + // the GUI, since that would destory the minibuffer itself and + // cause a crash, since we are currently in one of the methods of + // GuiCommandBuffer. See bug #8540. + if (cmd.origin() != FuncRequest::COMMANDBUFFER) + resetGui(); + // else + // FIXME Unfortunately, that leaves a bug here, since we cannot + // reset the GUI in this case. If the changes to lyxrc affected the + // UI, then, nothing would happen. This seems fairly unlikely, but + // it definitely is a bug. + + dr.forceBufferUpdate(); break; } @@ -1541,12 +1860,19 @@ void GuiApplication::dispatch(FuncRequest const & cmd, DispatchResult & dr) // repeat command string countstr; string rest = split(argument, countstr, ' '); - istringstream is(countstr); - int count = 0; - is >> count; - //lyxerr << "repeat: count: " << count << " cmd: " << rest << endl; - for (int i = 0; i < count; ++i) - dispatch(lyxaction.lookupFunc(rest)); + int const count = convert(countstr); + // an arbitrary number to limit number of iterations + int const max_iter = 10000; + if (count > max_iter) { + dr.setMessage(bformat(_("Cannot iterate more than %1$d times"), max_iter)); + dr.setError(true); + } else { + for (int i = 0; i < count; ++i) { + FuncRequest lfun = lyxaction.lookupFunc(rest); + lfun.allowAsync(false); + dispatch(lfun); + } + } break; } @@ -1556,18 +1882,89 @@ void GuiApplication::dispatch(FuncRequest const & cmd, DispatchResult & dr) // FIXME: this LFUN should also work without any view. Buffer * buffer = (current_view_ && current_view_->documentBufferView()) ? &(current_view_->documentBufferView()->buffer()) : 0; - if (buffer) - buffer->undo().beginUndoGroup(); + // This handles undo groups automagically + UndoGroupHelper ugh(buffer); while (!arg.empty()) { string first; arg = split(arg, first, ';'); FuncRequest func(lyxaction.lookupFunc(first)); + func.allowAsync(false); func.setOrigin(cmd.origin()); dispatch(func); } - // the buffer may have been closed by one action - if (theBufferList().isLoaded(buffer)) - buffer->undo().endUndoGroup(); + break; + } + + case LFUN_BUFFER_FORALL: { + FuncRequest funcToRun = lyxaction.lookupFunc(cmd.getLongArg(0)); + funcToRun.allowAsync(false); + + map views_lVisible; + map activeBuffers; + + QList allViews = d->views_.values(); + + // this for does not modify any buffer. It just collects info on local + // visibility of buffers and on which buffer is active in each view. + Buffer * const last = theBufferList().last(); + for(GuiView * view : allViews) { + // all of the buffers might be locally hidden. That is, there is no + // active buffer. + if (!view || !view->currentBufferView()) + activeBuffers[view] = 0; + else + activeBuffers[view] = &view->currentBufferView()->buffer(); + + // find out if each is locally visible or locally hidden. + // we don't use a for loop as the buffer list cycles. + Buffer * b = theBufferList().first(); + while (true) { + bool const locallyVisible = view && view->workArea(*b); + if (locallyVisible) { + bool const exists_ = (views_lVisible.find(b) != views_lVisible.end()); + // only need to overwrite/add if we don't already know a buffer is globally + // visible or we do know but we would prefer to dispatch LFUN from the + // current view because of cursor position issues. + if (!exists_ || (exists_ && views_lVisible[b] != current_view_)) + views_lVisible[b] = view; + } + if (b == last) + break; + b = theBufferList().next(b); + } + } + + GuiView * const homeView = currentView(); + Buffer * b = theBufferList().first(); + Buffer * nextBuf = 0; + int numProcessed = 0; + while (true) { + if (b != last) + nextBuf = theBufferList().next(b); // get next now bc LFUN might close current. + + bool const visible = (views_lVisible.find(b) != views_lVisible.end()); + if (visible) { + // first change to a view where b is locally visible, preferably current_view_. + GuiView * const vLv = views_lVisible[b]; + vLv->setBuffer(b); + lyx::dispatch(funcToRun); + numProcessed++; + } + if (b == last) + break; + b = nextBuf; + } + + // put things back to how they were (if possible). + for (GuiView * view : allViews) { + Buffer * originalBuf = activeBuffers[view]; + // there might not have been an active buffer in this view or it might have been closed by the LFUN. + if (theBufferList().isLoaded(originalBuf)) + view->setBuffer(originalBuf); + } + homeView->setFocus(); + + dr.setMessage(bformat(_("Applied \"%1$s\" to %2$d buffer(s)"), from_utf8(cmd.getLongArg(0)), numProcessed)); break; } @@ -1623,7 +2020,16 @@ void GuiApplication::dispatch(FuncRequest const & cmd, DispatchResult & dr) istringstream ss(argument); Lexer lex; lex.setStream(ss); + + // See #9236 + // We need to make sure that, after we recreat the DocumentClass, + // which we do in readHeader, we apply it to the document itself. + DocumentClassConstPtr olddc = defaults.params().documentClassPtr(); int const unknown_tokens = defaults.readHeader(lex); + DocumentClassConstPtr newdc = defaults.params().documentClassPtr(); + ErrorList el; + InsetText & theinset = static_cast(defaults.inset()); + cap::switchBetweenClasses(olddc, newdc, theinset, el); if (unknown_tokens != 0) { lyxerr << "Warning in LFUN_BUFFER_SAVE_AS_DEFAULT!\n" @@ -1656,6 +2062,24 @@ void GuiApplication::dispatch(FuncRequest const & cmd, DispatchResult & dr) lyxerr.setLevel(Debug::value(to_utf8(cmd.argument()))); break; + case LFUN_DIALOG_SHOW: { + string const name = cmd.getArg(0); + + if ( name == "aboutlyx" + || name == "prefs" + || name == "texinfo" + || name == "progress" + || name == "compare") + { + // work around: on Mac OS the application + // is not terminated when closing the last view. + // Create a new one to be able to dispatch the + // LFUN_DIALOG_SHOW to this view. + if (current_view_ == 0) + createView(); + } + } + // fall through default: // The LFUN must be for one of GuiView, BufferView, Buffer or Cursor; // let's try that: @@ -1663,6 +2087,9 @@ void GuiApplication::dispatch(FuncRequest const & cmd, DispatchResult & dr) current_view_->dispatch(cmd, dr); break; } + + if (cmd.origin() == FuncRequest::LYXSERVER) + updateCurrentView(cmd, dr); } @@ -1701,21 +2128,45 @@ void GuiApplication::handleKeyFunc(FuncCode action) } +//Keep this in sync with GuiApplication::processKeySym below +bool GuiApplication::queryKeySym(KeySymbol const & keysym, + KeyModifier state) const +{ + // Do nothing if we have nothing + if (!keysym.isOK() || keysym.isModifier()) + return false; + // Do a one-deep top-level lookup for cancel and meta-fake keys. + KeySequence seq; + FuncRequest func = seq.addkey(keysym, state); + // When not cancel or meta-fake, do the normal lookup. + if ((func.action() != LFUN_CANCEL) && (func.action() != LFUN_META_PREFIX)) { + seq = d->keyseq; + func = seq.addkey(keysym, (state | d->meta_fake_bit)); + } + // Maybe user can only reach the key via holding down shift. + // Let's see. But only if shift is the only modifier + if (func.action() == LFUN_UNKNOWN_ACTION && state == ShiftModifier) + // If addkey looked up a command and did not find further commands then + // seq has been reset at this point + func = seq.addkey(keysym, NoModifier); + + LYXERR(Debug::KEY, " Key (queried) [action=" << func.action() << "][" + << seq.print(KeySequence::Portable) << ']'); + return func.action() != LFUN_UNKNOWN_ACTION; +} + + +//Keep this in sync with GuiApplication::queryKeySym above void GuiApplication::processKeySym(KeySymbol const & keysym, KeyModifier state) { LYXERR(Debug::KEY, "KeySym is " << keysym.getSymbolName()); // Do nothing if we have nothing (JMarc) - if (!keysym.isOK()) { - LYXERR(Debug::KEY, "Empty kbd action (probably composing)"); - if (current_view_) - current_view_->restartCursor(); - return; - } - - if (keysym.isModifier()) { + if (!keysym.isOK() || keysym.isModifier()) { + if (!keysym.isOK()) + LYXERR(Debug::KEY, "Empty kbd action (probably composing)"); if (current_view_) - current_view_->restartCursor(); + current_view_->restartCaret(); return; } @@ -1759,23 +2210,60 @@ void GuiApplication::processKeySym(KeySymbol const & keysym, KeyModifier state) // Let's see. But only if shift is the only modifier if (func.action() == LFUN_UNKNOWN_ACTION && state == ShiftModifier) { LYXERR(Debug::KEY, "Trying without shift"); + // If addkey looked up a command and did not find further commands then + // seq has been reset at this point func = d->keyseq.addkey(keysym, NoModifier); LYXERR(Debug::KEY, "Action now " << func.action()); } if (func.action() == LFUN_UNKNOWN_ACTION) { - // Hmm, we didn't match any of the keysequences. See - // if it's normal insertable text not already covered - // by a binding + // We didn't match any of the key sequences. + // See if it's normal insertable text not already + // covered by a binding if (keysym.isText() && d->keyseq.length() == 1) { + // Non-printable characters (such as ASCII control characters) + // must not be inserted (#5704) + if (!isPrintable(encoded_last_key)) { + LYXERR(Debug::KEY, "Non-printable character! Omitting."); + if (current_view_) + current_view_->restartCaret(); + return; + } + // The following modifier check is not needed on Mac. + // The keysym is either not text or it is different + // from the non-modifier keysym. See #9875 for the + // broken alt-modifier effect of having this code active. +#if !defined(Q_OS_MAC) + // If a non-Shift Modifier is used we have a non-bound key sequence + // (such as Alt+j = j). This should be omitted (#5575). + // On Windows, AltModifier and ControlModifier are both + // set when AltGr is pressed. Therefore, in order to not + // break AltGr-bound symbols (see #5575 for details), + // unbound Ctrl+Alt key sequences are allowed. + if ((state & AltModifier || state & ControlModifier || state & MetaModifier) +#if defined(Q_OS_WIN) || defined(Q_CYGWIN_WIN) + && !(state & AltModifier && state & ControlModifier) +#endif + ) + { + if (current_view_) { + current_view_->message(_("Unknown function.")); + current_view_->restartCaret(); + } + return; + } +#endif + // Since all checks above were passed, we now really have text that + // is to be inserted (e.g., AltGr-bound symbols). Thus change the + // func to LFUN_SELF_INSERT and thus cause the text to be inserted + // below. LYXERR(Debug::KEY, "isText() is true, inserting."); - func = FuncRequest(LFUN_SELF_INSERT, - FuncRequest::KEYBOARD); + func = FuncRequest(LFUN_SELF_INSERT, FuncRequest::KEYBOARD); } else { - LYXERR(Debug::KEY, "Unknown, !isText() - giving up"); + LYXERR(Debug::KEY, "Unknown Action and not isText() -- giving up"); if (current_view_) { current_view_->message(_("Unknown function.")); - current_view_->restartCursor(); + current_view_->restartCaret(); } return; } @@ -1809,8 +2297,12 @@ void GuiApplication::processFuncRequestAsync(FuncRequest const & func) void GuiApplication::processFuncRequestQueue() { while (!d->func_request_queue_.empty()) { - processFuncRequest(d->func_request_queue_.front()); + // take the item from the stack _before_ processing the + // request in order to avoid race conditions from nested + // or parallel requests (see #10406) + FuncRequest const fr(d->func_request_queue_.front()); d->func_request_queue_.pop(); + processFuncRequest(fr); } } @@ -1873,6 +2365,8 @@ void GuiApplication::createView(QString const & geometry_arg, bool autoShow, LYXERR(Debug::GUI, "About to create new window with ID " << id); GuiView * view = new GuiView(id); + // `view' is the new current_view_. Tell coverity that is is not 0. + LATTEST(current_view_); // register view d->views_[id] = view; @@ -1882,22 +2376,55 @@ void GuiApplication::createView(QString const & geometry_arg, bool autoShow, } if (!geometry_arg.isEmpty()) { -#ifdef Q_WS_WIN +#if defined(Q_OS_WIN) || defined(Q_CYGWIN_WIN) int x, y; int w, h; - QRegExp re( "[=]*(?:([0-9]+)[xX]([0-9]+)){0,1}[ ]*(?:([+-][0-9]*)([+-][0-9]*)){0,1}" ); + QChar sx, sy; + QRegExp re( "[=]*(?:([0-9]+)[xX]([0-9]+)){0,1}[ ]*(?:([+-][0-9]*)){0,1}(?:([+-][0-9]*)){0,1}" ); re.indexIn(geometry_arg); w = re.cap(1).toInt(); h = re.cap(2).toInt(); x = re.cap(3).toInt(); y = re.cap(4).toInt(); + sx = re.cap(3).isEmpty() ? '+' : re.cap(3).at(0); + sy = re.cap(4).isEmpty() ? '+' : re.cap(4).at(0); + // Set initial geometry such that we can get the frame size. view->setGeometry(x, y, w, h); + int framewidth = view->geometry().x() - view->x(); + int titleheight = view->geometry().y() - view->y(); + // Negative displacements must be interpreted as distances + // from the right or bottom screen borders. + if (sx == '-' || sy == '-') { + QRect rec = QApplication::desktop()->screenGeometry(); + if (sx == '-') + x += rec.width() - w - framewidth; + if (sy == '-') + y += rec.height() - h - titleheight; + view->setGeometry(x, y, w, h); + } + // Make sure that the left and top frame borders are visible. + if (view->x() < 0 || view->y() < 0) { + if (view->x() < 0) + x = framewidth; + if (view->y() < 0) + y = titleheight; + view->setGeometry(x, y, w, h); + } #endif } view->setFocus(); } +bool GuiApplication::unhide(Buffer * buf) +{ + if (!currentView()) + return false; + currentView()->setBuffer(buf, false); + return true; +} + + Clipboard & GuiApplication::clipboard() { return d->clipboard_; @@ -1971,17 +2498,10 @@ void GuiApplication::exit(int status) void GuiApplication::setGuiLanguage() { - // Set the language defined by the user. - setRcGuiLanguage(); - - QString const default_language = toqstr(Messages::defaultLanguage()); - LYXERR(Debug::LOCALE, "Trying to set default locale to: " << default_language); - QLocale const default_locale(default_language); - QLocale::setDefault(default_locale); - + setLocale(); + QLocale theLocale; // install translation file for Qt built-in dialogs - QString const language_name = QString("qt_") + default_locale.name(); - + QString const language_name = QString("qt_") + theLocale.name(); // language_name can be short (e.g. qt_zh) or long (e.g. qt_zh_CN). // Short-named translator can be loaded from a long name, but not the // opposite. Therefore, long name should be used without truncation. @@ -1995,7 +2515,7 @@ void GuiApplication::setGuiLanguage() << language_name); } - switch (default_locale.language()) { + switch (theLocale.language()) { case QLocale::Arabic : case QLocale::Hebrew : case QLocale::Persian : @@ -2017,14 +2537,17 @@ void GuiApplication::execBatchCommands() // Gives some error box here. return; -#ifdef Q_WS_MACX +#ifdef Q_OS_MAC #if QT_VERSION > 0x040600 setAttribute(Qt::AA_MacDontSwapCtrlAndMeta,lyxrc.mac_dontswap_ctrl_meta); +#endif +#if QT_VERSION > 0x050100 + setAttribute(Qt::AA_UseHighDpiPixmaps,true); #endif // Create the global default menubar which is shown for the dialogs // and if no GuiView is visible. // This must be done after the session was recovered to know the "last files". - d->global_menubar_ = new GlobalMenuBar(); + d->global_menubar_ = new QMenuBar(0); d->menus_.fillMenuBar(d->global_menubar_, 0, true); #endif @@ -2039,13 +2562,12 @@ QAbstractItemModel * GuiApplication::languageModel() QStandardItemModel * lang_model = new QStandardItemModel(this); lang_model->insertColumns(0, 3); - int current_row; - QIcon speller(getPixmap("images/", "dialog-show_spellchecker", "png")); - QIcon saurus(getPixmap("images/", "thesaurus-entry", "png")); + QIcon speller(getPixmap("images/", "dialog-show_spellchecker", "svgz,png")); + QIcon saurus(getPixmap("images/", "thesaurus-entry", "svgz,png")); Languages::const_iterator it = lyx::languages.begin(); Languages::const_iterator end = lyx::languages.end(); for (; it != end; ++it) { - current_row = lang_model->rowCount(); + int current_row = lang_model->rowCount(); lang_model->insertRows(current_row, 1); QModelIndex pl_item = lang_model->index(current_row, 0); QModelIndex sp_item = lang_model->index(current_row, 1); @@ -2063,9 +2585,7 @@ QAbstractItemModel * GuiApplication::languageModel() } d->language_model_ = new QSortFilterProxyModel(this); d->language_model_->setSourceModel(lang_model); -#if QT_VERSION >= 0x040300 d->language_model_->setSortLocaleAware(true); -#endif return d->language_model_; } @@ -2087,7 +2607,7 @@ void GuiApplication::restoreGuiSession() // not be added at all (help files). for (size_t i = 0; i < lastopened.size(); ++i) { FileName const & file_name = lastopened[i].file_name; - if (d->views_.empty() || (!lyxrc.open_buffers_in_tabs + if (!current_view_ || (!lyxrc.open_buffers_in_tabs && current_view_->documentBufferView() != 0)) { boost::crc_32_type crc; string const & fname = file_name.absFileName(); @@ -2113,7 +2633,6 @@ void GuiApplication::restoreGuiSession() QString const GuiApplication::romanFontName() { QFont font; - font.setKerning(false); font.setStyleHint(QFont::Serif); font.setFamily("serif"); @@ -2124,7 +2643,6 @@ QString const GuiApplication::romanFontName() QString const GuiApplication::sansFontName() { QFont font; - font.setKerning(false); font.setStyleHint(QFont::SansSerif); font.setFamily("sans"); @@ -2134,12 +2652,41 @@ QString const GuiApplication::sansFontName() QString const GuiApplication::typewriterFontName() { - QFont font; - font.setKerning(false); - font.setStyleHint(QFont::TypeWriter); - font.setFamily("monospace"); + return QFontInfo(typewriterSystemFont()).family(); +} - return QFontInfo(font).family(); + +namespace { + // We cannot use QFont::fixedPitch() because it doesn't + // return the fact but only if it is requested. + static bool isFixedPitch(const QFont & font) { + const QFontInfo fi(font); + return fi.fixedPitch(); + } +} // namespace + + +QFont const GuiApplication::typewriterSystemFont() +{ +#if QT_VERSION >= 0x050200 + QFont font = QFontDatabase::systemFont(QFontDatabase::FixedFont); +#else + QFont font("monospace"); +#endif + if (!isFixedPitch(font)) { + // try to enforce a real monospaced font + font.setStyleHint(QFont::Monospace); + if (!isFixedPitch(font)) { + font.setStyleHint(QFont::TypeWriter); + if (!isFixedPitch(font)) font.setFamily("courier"); + } + } +#ifdef Q_OS_MAC + // On a Mac the result is too small and it's not practical to + // rely on Qtconfig utility to change the system settings of Qt. + font.setPointSize(12); +#endif + return font; } @@ -2188,7 +2735,8 @@ bool GuiApplication::notify(QObject * receiver, QEvent * event) #endif // In release mode, try to exit gracefully. this->exit(1); - + // FIXME: GCC 7 thinks we can fall through here. Can we? + // fall through case BufferException: { if (!current_view_ || !current_view_->documentBufferView()) return false; @@ -2284,13 +2832,18 @@ void GuiApplication::unregisterSocketCallback(int fd) void GuiApplication::commitData(QSessionManager & sm) { - /// The implementation is required to avoid an application exit - /// when session state save is triggered by session manager. - /// The default implementation sends a close event to all - /// visible top level widgets when session managment allows - /// interaction. - /// We are changing that to close all wiew one by one. - /// FIXME: verify if the default implementation is enough now. + /** The implementation is required to avoid an application exit + ** when session state save is triggered by session manager. + ** The default implementation sends a close event to all + ** visible top level widgets when session managment allows + ** interaction. + ** We are changing that to check the state of each buffer in all + ** views and ask the users what to do if buffers are dirty. + ** Furthermore, we save the session state. + ** We do NOT close the views here since the user still can cancel + ** the logout process (see #9277); also, this would hide LyX from + ** an OSes own session handling (application restoration). + **/ #ifdef QT_NO_SESSIONMANAGER #ifndef _MSC_VER #warning Qt is compiled without session manager @@ -2299,18 +2852,21 @@ void GuiApplication::commitData(QSessionManager & sm) #endif (void) sm; #else - if (sm.allowsInteraction() && !closeAllViews()) + if (sm.allowsInteraction() && !prepareAllViewsForLogout()) sm.cancel(); + else + sm.release(); #endif } void GuiApplication::unregisterView(GuiView * gv) { - LASSERT(d->views_[gv->id()] == gv, /**/); - d->views_.remove(gv->id()); - if (current_view_ == gv) - current_view_ = 0; + if(d->views_.contains(gv->id()) && d->views_.value(gv->id()) == gv) { + d->views_.remove(gv->id()); + if (current_view_ == gv) + current_view_ = 0; + } } @@ -2323,8 +2879,8 @@ bool GuiApplication::closeAllViews() // are already entries in the lastOpened list. theSession().lastOpened().clear(); - QList views = d->views_.values(); - foreach (GuiView * view, views) { + QList const views = d->views_.values(); + for (GuiView * view : views) { if (!view->closeScheduled()) return false; } @@ -2334,17 +2890,32 @@ bool GuiApplication::closeAllViews() } +bool GuiApplication::prepareAllViewsForLogout() +{ + if (d->views_.empty()) + return true; + + QList const views = d->views_.values(); + for (GuiView * view : views) { + if (!view->prepareAllBuffersForLogout()) + return false; + } + + return true; +} + + GuiView & GuiApplication::view(int id) const { - LASSERT(d->views_.contains(id), /**/); + LAPPERR(d->views_.contains(id)); return *d->views_.value(id); } void GuiApplication::hideDialogs(string const & name, Inset * inset) const { - QList views = d->views_.values(); - foreach (GuiView * view, views) + QList const views = d->views_.values(); + for (GuiView * view : views) view->hideDialog(name, inset); } @@ -2352,7 +2923,7 @@ void GuiApplication::hideDialogs(string const & name, Inset * inset) const Buffer const * GuiApplication::updateInset(Inset const * inset) const { Buffer const * buffer_ = 0; - QHash::iterator end = d->views_.end(); + QHash::const_iterator end = d->views_.end(); for (QHash::iterator it = d->views_.begin(); it != end; ++it) { if (Buffer const * ptr = (*it)->updateInset(inset)) buffer_ = ptr; @@ -2364,7 +2935,16 @@ Buffer const * GuiApplication::updateInset(Inset const * inset) const bool GuiApplication::searchMenu(FuncRequest const & func, docstring_list & names) const { - return d->menus_.searchMenu(func, names); + BufferView * bv = 0; + if (current_view_) + bv = current_view_->currentBufferView(); + return d->menus_.searchMenu(func, names, bv); +} + + +bool GuiApplication::hasBufferView() const +{ + return (current_view_ && current_view_->currentBufferView()); } @@ -2432,7 +3012,7 @@ GuiApplication::ReturnValues GuiApplication::readUIFile(FileName ui_path) QString const file = toqstr(lex.getString()); bool const success = readUIFile(file, true); if (!success) { - LYXERR0("Failed to read inlcuded file: " << fromqstr(file)); + LYXERR0("Failed to read included file: " << fromqstr(file)); return ReadError; } break; @@ -2524,14 +3104,14 @@ bool GuiApplication::readUIFile(QString const & name, bool include) if (retval == FormatMismatch) { LYXERR(Debug::FILES, "Converting ui file to format " << LFUN_FORMAT); - FileName const tempfile = FileName::tempName("convert_ui"); + TempFile tmp("convertXXXXXX.ui"); + FileName const tempfile = tmp.name(); bool const success = prefs2prefs(ui_path, tempfile, true); if (!success) { LYXERR0("Unable to convert " << ui_path.absFileName() << " to format " << LFUN_FORMAT << "."); } else { retval = readUIFile(tempfile); - tempfile.removeFile(); } } @@ -2591,6 +3171,11 @@ void GuiApplication::stopLongOperation() { } +bool GuiApplication::longOperationStarted() { + return d->key_checker_.started(); +} + + //////////////////////////////////////////////////////////////////////// // // X11 specific stuff goes here... @@ -2609,8 +3194,26 @@ bool GuiApplication::x11EventFilter(XEvent * xev) BufferView * bv = current_view_->currentBufferView(); if (bv) { docstring const sel = bv->requestSelection(); - if (!sel.empty()) + if (!sel.empty()) { d->selection_.put(sel); + // Refresh the selection request timestamp. + // We have to do this by ourselves as Qt seems + // not doing that, maybe because of our + // "persistent selection" implementation + // (see comments in GuiSelection.cpp). + XSelectionEvent nev; + nev.type = SelectionNotify; + nev.display = xev->xselectionrequest.display; + nev.requestor = xev->xselectionrequest.requestor; + nev.selection = xev->xselectionrequest.selection; + nev.target = xev->xselectionrequest.target; + nev.property = 0L; // None + nev.time = CurrentTime; + XSendEvent(QX11Info::display(), + nev.requestor, False, 0, + reinterpret_cast(&nev)); + return true; + } } break; } @@ -2626,6 +3229,65 @@ bool GuiApplication::x11EventFilter(XEvent * xev) } return false; } +#elif defined(QPA_XCB) +bool GuiApplication::nativeEventFilter(const QByteArray & eventType, + void * message, long *) +{ + if (!current_view_ || eventType != "xcb_generic_event_t") + return false; + + xcb_generic_event_t * ev = static_cast(message); + + switch (ev->response_type) { + case XCB_SELECTION_REQUEST: { + xcb_selection_request_event_t * srev = + reinterpret_cast(ev); + if (srev->selection != XCB_ATOM_PRIMARY) + break; + LYXERR(Debug::SELECTION, "X requested selection."); + BufferView * bv = current_view_->currentBufferView(); + if (bv) { + docstring const sel = bv->requestSelection(); + if (!sel.empty()) { + d->selection_.put(sel); +#ifdef HAVE_QT5_X11_EXTRAS + // Refresh the selection request timestamp. + // We have to do this by ourselves as Qt seems + // not doing that, maybe because of our + // "persistent selection" implementation + // (see comments in GuiSelection.cpp). + xcb_selection_notify_event_t nev; + nev.response_type = XCB_SELECTION_NOTIFY; + nev.requestor = srev->requestor; + nev.selection = srev->selection; + nev.target = srev->target; + nev.property = XCB_NONE; + nev.time = XCB_CURRENT_TIME; + xcb_connection_t * con = QX11Info::connection(); + xcb_send_event(con, 0, srev->requestor, + XCB_EVENT_MASK_NO_EVENT, + reinterpret_cast(&nev)); + xcb_flush(con); +#endif + return true; + } + } + break; + } + case XCB_SELECTION_CLEAR: { + xcb_selection_clear_event_t * scev = + reinterpret_cast(ev); + if (scev->selection != XCB_ATOM_PRIMARY) + break; + LYXERR(Debug::SELECTION, "Lost selection."); + BufferView * bv = current_view_->currentBufferView(); + if (bv) + bv->clearSelection(); + break; + } + } + return false; +} #endif } // namespace frontend @@ -2646,7 +3308,7 @@ void hideDialogs(std::string const & name, Inset * inset) frontend::FontLoader & theFontLoader() { - LASSERT(frontend::guiApp, /**/); + LAPPERR(frontend::guiApp); return frontend::guiApp->fontLoader(); } @@ -2659,7 +3321,7 @@ frontend::FontMetrics const & theFontMetrics(Font const & f) frontend::FontMetrics const & theFontMetrics(FontInfo const & f) { - LASSERT(frontend::guiApp, /**/); + LAPPERR(frontend::guiApp); return frontend::guiApp->fontLoader().metrics(f); } @@ -2672,14 +3334,14 @@ frontend::FontMetrics const & theFontMetrics(FontInfo const & f) frontend::Clipboard & theClipboard() { - LASSERT(frontend::guiApp, /**/); + LAPPERR(frontend::guiApp); return frontend::guiApp->clipboard(); } frontend::Selection & theSelection() { - LASSERT(frontend::guiApp, /**/); + LAPPERR(frontend::guiApp); return frontend::guiApp->selection(); }