#include "GuiApplication.h"
+#include "ToolTipFormatter.h"
#include "ColorCache.h"
#include "ColorSet.h"
#include "GuiClipboard.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 <queue>
#include <QByteArray>
-#include <QClipboard>
#include <QDateTime>
#include <QDesktopWidget>
#include <QDir>
#include <QEvent>
-#include <QEventLoop>
#include <QFileOpenEvent>
#include <QFileInfo>
+#include <QFontDatabase>
#include <QHash>
#include <QIcon>
#include <QImageReader>
#include <QRegExp>
#include <QSessionManager>
#include <QSettings>
-#include <QShowEvent>
#include <QSocketNotifier>
#include <QSortFilterProxyModel>
#include <QStandardItemModel>
-#include <QTextCodec>
#include <QTimer>
#include <QTranslator>
#include <QThreadPool>
#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
#if (QT_VERSION < 0x050000) || (QT_VERSION >= 0x050400)
#include <QMacPasteboardMime>
#endif // Q_OS_MAC
-#include "support/bind.h"
#include <boost/crc.hpp>
#include <exception>
}
}
#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.
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);
}
return img_name;
}
-} // namespace anon
+} // namespace
QString themeIconName(QString const & action)
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;
+ return pixmap.load(path);
}
if (getPixmap(pixmap, fpath)) {
return pixmap;
}
-
+
QStringList exts = ext.split(",");
fpath = ":/" + path + name + ".";
for (int i = 0; i < exts.size(); ++i) {
{
#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
};
-////////////////////////////////////////////////////////////////////////
-//
-// Mac specific stuff goes here...
-//
-////////////////////////////////////////////////////////////////////////
-
-class MenuTranslator : public QTranslator
+class GuiTranslator : public QTranslator
{
public:
- MenuTranslator(QObject * parent)
+ GuiTranslator(QObject * parent = nullptr)
: QTranslator(parent)
{}
-#if QT_VERSION >= 0x050000
virtual QString translate(const char * /* context */,
const char *sourceText,
+#if QT_VERSION >= 0x050000
const char * /* disambiguation */ = 0, int /* n */ = -1) const
#else
- QString translate(const char * /*context*/,
- const char * sourceText,
- const char * /*comment*/ = 0) const
+ 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);
}
};
+
+////////////////////////////////////////////////////////////////////////
+//
+// Mac specific stuff goes here...
+//
+////////////////////////////////////////////////////////////////////////
+
#ifdef Q_OS_MAC
// QMacPasteboardMimeGraphics can only be compiled on Mac.
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())
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<int, SocketNotifier *> socket_notifiers_;
///
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.
+ // 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
// 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
// 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 devicePixelRatio();
+ return qt_scale_factor * devicePixelRatio();
#else
return 1.0;
#endif
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;
}
DispatchResult const & GuiApplication::dispatch(FuncRequest const & cmd)
{
+ 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();
- if (buffer)
- buffer->undo().beginUndoGroup();
}
- DispatchResult dr;
+ dr.screenUpdate(Update::FitCursor);
+ {
+ // This handles undo groups automagically
+ UndoGroupHelper ugh(buffer);
+ dispatch(cmd, 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_;
}
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
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 _()
// 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();
+ 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 (cur != old)
- notifyCursorLeavesOrEnters(old, cur);
+ if (old && cur != *old)
+ notifyCursorLeavesOrEnters(*old, cur);
// bm changed
if (idx == 0)
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);
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);
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());
bool const is_open = FileName::isAbsolute(fname)
&& theBufferList().getBuffer(FileName(fname));
- if (d->views_.empty()
+ if (!current_view_
|| (!lyxrc.open_buffers_in_tabs
&& current_view_->documentBufferView() != 0
&& !is_open)) {
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;
}
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;
}
// UI, then, nothing would happen. This seems fairly unlikely, but
// it definitely is a bug.
+ dr.forceBufferUpdate();
break;
}
// 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<int>(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;
}
// 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 const funcToRun = lyxaction.lookupFunc(cmd.getLongArg(0));
+ FuncRequest funcToRun = lyxaction.lookupFunc(cmd.getLongArg(0));
+ funcToRun.allowAsync(false);
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.
+ // 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.
+ 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
}
// 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))
if (current_view_ == 0)
createView();
}
- // fall through
}
-
+ // fall through
default:
// The LFUN must be for one of GuiView, BufferView, Buffer or Cursor;
// let's try that:
}
+//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 (!keysym.isOK() || keysym.isModifier()) {
+ if (!keysym.isOK())
+ LYXERR(Debug::KEY, "Empty kbd action (probably composing)");
if (current_view_)
- current_view_->restartCursor();
- return;
- }
-
- if (keysym.isModifier()) {
- if (current_view_)
- current_view_->restartCursor();
+ current_view_->restartCaret();
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 (!isPrintable(encoded_last_key)) {
LYXERR(Debug::KEY, "Non-printable character! Omitting.");
if (current_view_)
- current_view_->restartCursor();
+ current_view_->restartCaret();
return;
}
// The following modifier check is not needed on Mac.
{
if (current_view_) {
current_view_->message(_("Unknown function."));
- current_view_->restartCursor();
+ current_view_->restartCaret();
}
return;
}
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;
}
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);
}
}
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;
}
+bool GuiApplication::unhide(Buffer * buf)
+{
+ if (!currentView())
+ return false;
+ currentView()->setBuffer(buf, false);
+ return true;
+}
+
+
Clipboard & GuiApplication::clipboard()
{
return d->clipboard_;
// 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();
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();
+ }
+} // 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;
}
#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;
theSession().lastOpened().clear();
QList<GuiView *> const views = d->views_.values();
- foreach (GuiView * view, views) {
+ for (GuiView * view : views) {
if (!view->closeScheduled())
return false;
}
return true;
QList<GuiView *> const views = d->views_.values();
- foreach (GuiView * view, views) {
+ for (GuiView * view : views) {
if (!view->prepareAllBuffersForLogout())
return false;
}
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);
}
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());
}
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;
}
BufferView * bv = current_view_->currentBufferView();
if (bv) {
docstring const sel = bv->requestSelection();
- if (!sel.empty())
+ 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;
}
projects / lyx.git / blobdiff