#include "ColorCache.h"
#include "ColorSet.h"
#include "GuiClipboard.h"
-#include "GuiImage.h"
#include "GuiKeySymbol.h"
#include "GuiSelection.h"
#include "GuiView.h"
#include "Buffer.h"
#include "BufferList.h"
+#include "BufferParams.h"
#include "BufferView.h"
#include "CmdDef.h"
#include "Color.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"
-#include "LaTeXFeatures.h"
+#include "LaTeXPackages.h"
#include "Lexer.h"
#include "LyX.h"
#include "LyXAction.h"
#include "Thesaurus.h"
#include "version.h"
+#include "insets/InsetText.h"
+
#include "support/convert.h"
#include "support/debug.h"
#include "support/ExceptionMessage.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 <QByteArray>
#include <QClipboard>
#include <QDateTime>
+#include <QDesktopWidget>
#include <QDir>
+#include <QEvent>
#include <QEventLoop>
#include <QFileOpenEvent>
#include <QFileInfo>
#include <QHash>
#include <QIcon>
#include <QImageReader>
+#include <QKeyEvent>
#include <QLocale>
#include <QLibraryInfo>
#include <QList>
-#include <QMacPasteboardMime>
#include <QMenuBar>
#include <QMimeData>
#include <QObject>
#include <QRegExp>
#include <QSessionManager>
#include <QSettings>
+#include <QShowEvent>
#include <QSocketNotifier>
#include <QSortFilterProxyModel>
#include <QStandardItemModel>
#include <QTextCodec>
#include <QTimer>
#include <QTranslator>
-#if QT_VERSION >= 0x040400
#include <QThreadPool>
-#endif
#include <QWidget>
#ifdef Q_WS_X11
#include <X11/Xlib.h>
#undef CursorShape
#undef None
+#elif defined(QPA_XCB)
+#include <xcb/xcb.h>
#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_OS_MAC
+#include <QMacPasteboardMime>
+#endif // Q_OS_MAC
#include "support/bind.h"
#include <boost/crc.hpp>
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) {
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 {
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_;
};
// 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);
+
+// 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 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;
- 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
+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)
{
initializeResources();
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/";
}
}
- 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);
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)
+{
+ if (pixmap.load(path)) {
+#if QT_VERSION >= 0x050000
+ if (path.endsWith(".svgz") || path.endsWith(".svg") ) {
+ GuiApplication const * guiApp = theGuiApp();
+ if (guiApp != 0) {
+ pixmap.setDevicePixelRatio(guiApp->pixelRatio());
+ }
+ }
+#endif
+ return true;
+ }
+ return false;
+}
+
+
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) {
+ 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);
+ }
+#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);
}
: QTranslator(parent)
{}
+#if QT_VERSION >= 0x050000
+ virtual QString translate(const char * /* context */,
+ const char *sourceText,
+ const char * /* disambiguation */ = 0, int /* n */ = -1) const
+#else
QString translate(const char * /*context*/,
const char * sourceText,
- const char * /*comment*/ = 0)
+ const char * /*comment*/ = 0) const
+#endif
{
string const s = sourceText;
if (s == N_("About %1") || s == N_("Preferences")
}
};
-class GlobalMenuBar : public QMenuBar
-{
-public:
- ///
- GlobalMenuBar() : QMenuBar(0) {}
-
- ///
- bool event(QEvent * e)
- {
- if (e->type() == QEvent::ShortcutOverride) {
- // && activeWindow() == 0) {
- QKeyEvent * ke = static_cast<QKeyEvent*>(e);
- KeySymbol sym;
- setKeySymbol(&sym, ke);
- guiApp->processKeySym(sym, q_key_state(ke->modifiers()));
- e->accept();
- return true;
- }
- return false;
- }
-};
-
-#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() {}
}
};
-#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), 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<QKeyEvent*>(event);
+ if (keyEvent && keyEvent->key() == Qt::Key_Escape)
+ pressed_ = true;
+ return true;
+ }
+ }
+};
+
////////////////////////////////////////////////////////////////////////
// GuiApplication::Private definition and implementation.
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());
}
///
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
QHash<int, GuiView *> 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
+ KeyChecker key_checker_;
};
GuiApplication::~GuiApplication()
{
-#ifdef Q_WS_MACX
+#ifdef Q_OS_MAC
closeAllLinkBackLinks();
#endif
delete d;
QCoreApplication::setOrganizationDomain("lyx.org");
QCoreApplication::setApplicationName(lyx_package);
+ 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);
/// 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
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
}
}
+double GuiApplication::pixelRatio() const
+{
+#if QT_VERSION >= 0x050000
+ return 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;
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 <LFUN-COMMAND> 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;
}
}
-void GuiApplication::dispatch(FuncRequest const & cmd)
+DispatchResult const & GuiApplication::dispatch(FuncRequest const & cmd)
{
- if (current_view_ && current_view_->currentBufferView())
+ Buffer * buffer = 0;
+ if (current_view_ && current_view_->currentBufferView()) {
current_view_->currentBufferView()->cursor().saveBeforeDispatchPosXY();
+ buffer = ¤t_view_->currentBufferView()->buffer();
+ if (buffer)
+ buffer->undo().beginUndoGroup();
+ }
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);
+
+ // the buffer may have been closed by one action
+ if (theBufferList().isLoaded(buffer))
+ buffer->undo().endUndoGroup();
+
+ d->dispatch_result_ = dr;
+ return d->dispatch_result_;
+}
+
+void GuiApplication::updateCurrentView(FuncRequest const & cmd, DispatchResult & dr)
+{
if (!current_view_)
return;
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)) {
// 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->cursor();
if (!doc_bv || doc_bv->buffer().fileName() != tmp.filename) {
if (switchToBuffer) {
dispatch(FuncRequest(LFUN_BUFFER_SWITCH, file));
tmp.bottom_pit, tmp.bottom_pos, tmp.top_id, tmp.top_pos))
return;
+ Cursor & cur = doc_bv->cursor();
+ if (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 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
- LaTeXFeatures::getAvailable();
+ 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
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);
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 (d->views_.empty()
+ || (!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;
}
// 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;
}
}
actOnUpdatedPrefs(lyxrc_orig, lyxrc);
- setSpellChecker();
- 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.
break;
}
break;
}
+ case LFUN_BUFFER_FORALL: {
+ FuncRequest const funcToRun = lyxaction.lookupFunc(cmd.getLongArg(0));
+
+ map<Buffer *, GuiView *> views_lVisible;
+ map<GuiView *, Buffer *> activeBuffers;
+
+ 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.
+ 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())
+ 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).
+ foreach (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;
+ }
+
case LFUN_COMMAND_ALTERNATIVES: {
// argument contains ';'-terminated commands
string arg = argument;
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<InsetText &>(defaults.inset());
+ cap::switchBetweenClasses(olddc, newdc, theinset, el);
if (unknown_tokens != 0) {
lyxerr << "Warning in LFUN_BUFFER_SAVE_AS_DEFAULT!\n"
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:
current_view_->dispatch(cmd, dr);
break;
}
+
+ if (cmd.origin() == FuncRequest::LYXSERVER)
+ updateCurrentView(cmd, dr);
}
}
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();
if (d->global_menubar_)
d->global_menubar_->releaseKeyboard();
-#if QT_VERSION < 0x040700
- // the option to disable kerning in rowpainter
- // is needed only with Qt4.7.0 or better
- lyxrc.force_paint_single_char = false;
- system_lyxrc.force_paint_single_char = false;
-#endif
-
// create new view
int id = view_id;
while (d->views_.find(id) != d->views_.end())
}
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();
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.
<< language_name);
}
- switch (default_locale.language()) {
+ switch (theLocale.language()) {
case QLocale::Arabic :
case QLocale::Hebrew :
case QLocale::Persian :
// 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
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);
}
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_;
}
QString const GuiApplication::romanFontName()
{
QFont font;
- font.setKerning(false);
font.setStyleHint(QFont::Serif);
font.setFamily("serif");
QString const GuiApplication::sansFontName()
{
QFont font;
- font.setKerning(false);
font.setStyleHint(QFont::SansSerif);
font.setFamily("sans");
QString const GuiApplication::typewriterFontName()
{
QFont font;
- font.setKerning(false);
font.setStyleHint(QFont::TypeWriter);
font.setFamily("monospace");
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
- #warning Qt is compiled without session manager
+ #ifndef _MSC_VER
+ #warning Qt is compiled without session manager
+ #else
+ #pragma message("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)
{
- 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;
+ }
}
// are already entries in the lastOpened list.
theSession().lastOpened().clear();
- QList<GuiView *> views = d->views_.values();
+ QList<GuiView *> const views = d->views_.values();
foreach (GuiView * view, views) {
if (!view->closeScheduled())
return false;
}
+bool GuiApplication::prepareAllViewsForLogout()
+{
+ if (d->views_.empty())
+ return true;
+
+ QList<GuiView *> const views = d->views_.values();
+ foreach (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<GuiView *> views = d->views_.values();
+ QList<GuiView *> const views = d->views_.values();
foreach (GuiView * view, views)
view->hideDialog(name, inset);
}
Buffer const * GuiApplication::updateInset(Inset const * inset) const
{
Buffer const * buffer_ = 0;
- QHash<int, GuiView *>::iterator end = d->views_.end();
+ QHash<int, GuiView *>::const_iterator end = d->views_.end();
for (QHash<int, GuiView *>::iterator it = d->views_.begin(); it != end; ++it) {
if (Buffer const * ptr = (*it)->updateInset(inset))
buffer_ = ptr;
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();
}
}
}
+void GuiApplication::startLongOperation() {
+ d->key_checker_.start();
+}
+
+
+bool GuiApplication::longOperationCancelled() {
+ return d->key_checker_.pressed();
+}
+
+
+void GuiApplication::stopLongOperation() {
+ d->key_checker_.stop();
+}
+
+
+bool GuiApplication::longOperationStarted() {
+ return d->key_checker_.started();
+}
+
+
////////////////////////////////////////////////////////////////////////
//
// X11 specific stuff goes here...
}
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);
+ }
+ 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
frontend::FontLoader & theFontLoader()
{
- LASSERT(frontend::guiApp, /**/);
+ LAPPERR(frontend::guiApp);
return frontend::guiApp->fontLoader();
}
frontend::FontMetrics const & theFontMetrics(FontInfo const & f)
{
- LASSERT(frontend::guiApp, /**/);
+ LAPPERR(frontend::guiApp);
return frontend::guiApp->fontLoader().metrics(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();
}
projects / lyx.git / blobdiff