#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"
#include "BufferView.h"
#include "CmdDef.h"
#include "Color.h"
+#include "Converter.h"
#include "CutAndPaste.h"
#include "ErrorList.h"
#include "Font.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/PathChanger.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 <queue>
+#include <QFontDatabase>
#include <QByteArray>
#include <QClipboard>
#include <QDateTime>
#ifdef Q_WS_X11
#include <X11/Xatom.h>
#include <X11/Xlib.h>
+#include <QX11Info>
#undef CursorShape
#undef None
+#elif defined(QPA_XCB)
+#include <xcb/xcb.h>
+#ifdef HAVE_QT5_X11_EXTRAS
+#include <QtX11Extras/QX11Info>
+#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 <QWindowsMime>
+#define QWINDOWSMIME QWindowsMime
+#else
+#include <QWinMime>
+#define QWINDOWSMIME QWinMime
+#endif
#ifdef Q_CC_GNU
#include <wtypes.h>
#endif
#include <objidl.h>
-#endif // Q_WS_WIN
+#endif
+#endif
-#ifdef Q_WS_MACX
+#ifdef Q_OS_MAC
#include <QMacPasteboardMime>
-#endif // Q_WS_MACX
+#endif // Q_OS_MAC
-#include "support/bind.h"
#include <boost/crc.hpp>
#include <exception>
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) {
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);
- string const code = l ? l->code() : string();
+ code = l ? l->code() : "C";
theLocale = QLocale(toqstr(code));
}
- string const code = fromqstr(theLocale.name());
// Qt tries to outsmart us and transforms en_US to C.
Messages::guiLanguage((code == "C") ? "en_US" : code);
QLocale::setDefault(theLocale);
if (qt_formats.empty())
LYXERR(Debug::GRAPHICS, "\nQt4 Problem: No Format available!");
+ bool jpeg_found = false;
+ bool jpg_found = false;
for (QList<QByteArray>::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);
}
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;
}
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_;
};
// Upper case comes before lower case
// Please don't change the formatting, this list is parsed by
// development/tools/generate_symbols_images.py.
-PngMap sorted_png_map[] = {
+ImgMap sorted_img_map[] = {
{ "Arrownot", "arrownot2"},
{ "Arrowvert", "arrowvert2"},
{ "Bowtie", "bowtie2" },
{ "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" },
};
-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);
// 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
-PngMap sorted_theme_icon_map[] = {
+ImgMap sorted_theme_icon_map[] = {
{ "bookmark-goto 0", "go-jump" },
{ "buffer-new", "document-new" },
- { "buffer-print", "document-print" },
{ "buffer-write", "document-save" },
{ "buffer-write-as", "document-save-as" },
{ "buffer-zoom-in", "zoom-in" },
{ "cut", "edit-cut" },
{ "depth-decrement", "format-indent-less" },
{ "depth-increment", "format-indent-more" },
- { "dialog-show print", "document-print" },
{ "dialog-show spellchecker", "tools-check-spelling" },
{ "dialog-show-new-inset graphics", "insert-image" },
{ "dialog-toggle findreplaceadv", "edit-find-replace" },
{ "window-new", "window-new" }
};
-size_t const nr_sorted_theme_icon_map = sizeof(sorted_theme_icon_map) / sizeof(PngMap);
+size_t const nr_sorted_theme_icon_map = sizeof(sorted_theme_icon_map) / sizeof(ImgMap);
-QString findPng(QString const & name)
+QString findImg(QString const & name)
{
- PngMap const * const begin = sorted_png_map;
- PngMap const * const end = begin + nr_sorted_png_map;
+ 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
QString themeIconName(QString const & action)
{
- PngMap const * const begin = sorted_theme_icon_map;
- PngMap const * const end = begin + nr_sorted_theme_icon_map;
+ ImgMap const * const begin = sorted_theme_icon_map;
+ ImgMap const * const end = begin + nr_sorted_theme_icon_map;
LASSERT(sorted(begin, end), /**/);
- PngMap const * const it = find_if(begin, end, CompareKey(action));
+ ImgMap const * const it = find_if(begin, end, CompareKey(action));
if (it != end)
return it->value;
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/";
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;
QStringList imagedirs;
imagedirs << "images/" << "images/ipa/";
- for (int i = 0; i < imagedirs.size(); ++i) {
+ search_mode mode = theGuiApp()->imageSearchMode();
+ for (int i = 0; i < imagedirs.size(); ++i) {
QString imagedir = imagedirs.at(i) + path;
- FileName fname = imageLibFileSearch(imagedir, name1, "png");
+ FileName fname = imageLibFileSearch(imagedir, name1, "svgz,png", mode);
if (fname.exists())
return toqstr(fname.absFileName());
- fname = imageLibFileSearch(imagedir, name2, "png");
+ fname = imageLibFileSearch(imagedir, name2, "svgz,png", mode);
if (fname.exists())
return toqstr(fname.absFileName());
}
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) {
QString imagedir = "images/";
- FileName fname = imageLibFileSearch(imagedir, "unknown", "png");
+ 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))
- return QIcon::fromTheme(theme_icon);
+ if (QIcon::hasThemeIcon(theme_icon)) {
+ QIcon const thmicn = QIcon::fromTheme(theme_icon);
+ if (!thmicn.isNull())
+ return thmicn;
+ }
}
#endif
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);
}
}
};
-#ifdef Q_WS_MACX
+#ifdef Q_OS_MAC
// QMacPasteboardMimeGraphics can only be compiled on Mac.
class QMacPasteboardMimeGraphics : public QMacPasteboardMime
////////////////////////////////////////////////////////////////////////
// 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)
}
-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;
}
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))
QVector<FORMATETC> formatsForMime(QString const & mimetype,
- QMimeData const * mimedata) const
+ QMimeData const * /*mimedata*/) const
{
QVector<FORMATETC> formats;
if (mimetype == emfMimeType() || mimetype == wmfMimeType())
}
};
-#endif // Q_WS_WIN
+#endif
+#endif
/// Allows to check whether ESC was pressed during a long operation
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;
+ #endif
#endif
initKeySequences(&theTopLevelKeymap());
}
///
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
/// Only used on mac.
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
GuiApplication::~GuiApplication()
{
-#ifdef Q_WS_MACX
+#ifdef Q_OS_MAC
closeAllLinkBackLinks();
#endif
delete d;
QCoreApplication::setOrganizationName(app_name);
QCoreApplication::setOrganizationDomain("lyx.org");
QCoreApplication::setApplicationName(lyx_package);
+#if QT_VERSION >= 0x050000
+ QCoreApplication::setAttribute(Qt::AA_UseHighDpiPixmaps);
+#endif
qsrand(QDateTime::currentDateTime().toTime_t());
// Install 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.
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);
/// Only needed with Qt/Mac.
installTranslator(new MenuTranslator(this));
///
- setupApplescript();
+ 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
// 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);
+
+ // make sure tooltips are formatted
+ installEventFilter(new ToolTipFormatter(this));
}
}
+double GuiApplication::pixelRatio() const
+{
+#if QT_VERSION >= 0x050000
+ return qt_scale_factor * devicePixelRatio();
+#else
+ return 1.0;
+#endif
+}
+
+
void GuiApplication::clearSession()
{
QSettings settings;
}
+docstring Application::mathIcon(docstring const & c)
+{
+ return qstring_to_ucs4(findImg(toqstr(c)));
+}
+
+
FuncStatus GuiApplication::getStatus(FuncRequest const & cmd) const
{
FuncStatus status;
}
-void GuiApplication::dispatch(FuncRequest const & cmd)
+DispatchResult const & GuiApplication::dispatch(FuncRequest const & cmd)
{
Buffer * buffer = 0;
if (current_view_ && current_view_->currentBufferView()) {
// the buffer may have been closed by one action
if (theBufferList().isLoaded(buffer))
buffer->undo().endUndoGroup();
+
+ d->dispatch_result_ = dr;
+ return d->dispatch_result_;
}
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
// 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));
}
// 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();
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 const 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"),
boost::crc_32_type crc;
crc = for_each(fname.begin(), fname.end(), crc);
createView(crc.checksum());
+ // we know current_view_ is non-null, because createView sets it.
+ // but let's make sure
+ LASSERT(current_view_, break);
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 {
+ // we know !d->views.empty(), so this should be ok
+ // but let's make sure
+ LASSERT(current_view_, break);
current_view_->openDocument(fname);
+ if (cmd.origin() == FuncRequest::LYXSERVER) {
+ current_view_->raise();
+ current_view_->activateWindow();
+ current_view_->showNormal();
+ }
+ }
break;
}
}
// 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;
}
// 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.
+ // 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
+ // UI, then, nothing would happen. This seems fairly unlikely, but
// it definitely is a bug.
break;
QList<GuiView *> allViews = d->views_.values();
- // this foreach does not modify any buffer. It just collects info on local visibility of buffers
- // and on which buffer is active in each view.
+ // 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();
- foreach (GuiView * view, allViews) {
- // all of the buffers might be locally hidden. That is, there is no active buffer.
- if (!view || !view->currentBufferView() || !&view->currentBufferView()->buffer())
+ 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();
}
// put things back to how they were (if possible).
- foreach (GuiView * view, allViews) {
+ 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))
istringstream ss(argument);
Lexer lex;
lex.setStream(ss);
-
+
// See #9236
- // We need to make sure that, after we recreat the DocumentClass,
+ // 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);
if (current_view_ == 0)
createView();
}
+ // fall through
}
default:
}
+//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();
return;
// 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_->restartCursor();
+ 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_->restartCursor();
+ }
+ 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();
// 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.
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);
QString const GuiApplication::typewriterFontName()
{
- QFont font;
- 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();
+ }
+}
+
+
+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;
}
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
#endif
(void) sm;
#else
- if (sm.allowsInteraction() && !closeAllViews())
+ if (sm.allowsInteraction() && !prepareAllViewsForLogout())
sm.cancel();
+ else
+ sm.release();
#endif
}
void GuiApplication::unregisterView(GuiView * gv)
{
- LAPPERR(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;
+ }
}
theSession().lastOpened().clear();
QList<GuiView *> const views = d->views_.values();
- foreach (GuiView * view, views) {
+ for (GuiView * view : views) {
if (!view->closeScheduled())
return false;
}
}
+bool GuiApplication::prepareAllViewsForLogout()
+{
+ if (d->views_.empty())
+ return true;
+
+ QList<GuiView *> const views = d->views_.values();
+ for (GuiView * view : views) {
+ if (!view->prepareAllBuffersForLogout())
+ return false;
+ }
+
+ return true;
+}
+
+
GuiView & GuiApplication::view(int id) const
{
LAPPERR(d->views_.contains(id));
void GuiApplication::hideDialogs(string const & name, Inset * inset) const
{
QList<GuiView *> const views = d->views_.values();
- foreach (GuiView * view, views)
+ for (GuiView * view : views)
view->hideDialog(name, inset);
}
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;
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<XEvent *>(&nev));
+ return true;
+ }
}
break;
}
}
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<xcb_generic_event_t *>(message);
+
+ switch (ev->response_type) {
+ case XCB_SELECTION_REQUEST: {
+ xcb_selection_request_event_t * srev =
+ reinterpret_cast<xcb_selection_request_event_t *>(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<char const *>(&nev));
+ xcb_flush(con);
+#endif
+ return true;
+ }
+ }
+ break;
+ }
+ case XCB_SELECTION_CLEAR: {
+ xcb_selection_clear_event_t * scev =
+ reinterpret_cast<xcb_selection_clear_event_t *>(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