X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ffrontends%2Fqt4%2FGuiWorkArea.cpp;h=bb8de83dc072ad5d50e07855b11d97b565a7dc0e;hb=a0ce37147cffa39b1a5c8859eb001dd2194b22a1;hp=ef79b02fe3e1c7b0f76ef3e8b53cbf8866bbe2af;hpb=8590a51f9b4e6d35fdf3f6cf4765c06bca90be35;p=lyx.git

diff --git a/src/frontends/qt4/GuiWorkArea.cpp b/src/frontends/qt4/GuiWorkArea.cpp
index ef79b02fe3..bb8de83dc0 100644
--- a/src/frontends/qt4/GuiWorkArea.cpp
+++ b/src/frontends/qt4/GuiWorkArea.cpp
@@ -12,6 +12,7 @@
 #include <config.h>
 
 #include "GuiWorkArea.h"
+#include "GuiWorkArea_Private.h"
 
 #include "ColorCache.h"
 #include "FontLoader.h"
@@ -46,24 +47,31 @@
 #include "support/convert.h"
 #include "support/debug.h"
 #include "support/gettext.h"
-#include "support/FileName.h"
+#include "support/lassert.h"
+#include "support/TempFile.h"
 
 #include "frontends/Application.h"
 #include "frontends/FontMetrics.h"
 #include "frontends/WorkAreaManager.h"
 
 #include <QContextMenuEvent>
+#if (QT_VERSION < 0x050000)
 #include <QInputContext>
+#endif
+#include <QDrag>
 #include <QHelpEvent>
-#ifdef Q_WS_MACX
-#include <QMacStyle>
+#ifdef Q_OS_MAC
+#include <QProxyStyle>
 #endif
 #include <QMainWindow>
+#include <QMimeData>
 #include <QMenu>
 #include <QPainter>
 #include <QPalette>
 #include <QPixmapCache>
 #include <QScrollBar>
+#include <QStyleOption>
+#include <QStylePainter>
 #include <QTimer>
 #include <QToolButton>
 #include <QToolTip>
@@ -72,12 +80,8 @@
 #include "support/bind.h"
 
 #include <cmath>
+#include <iostream>
 
-#ifdef Q_WS_WIN
-int const CursorWidth = 2;
-#else
-int const CursorWidth = 1;
-#endif
 int const TabIndicatorWidth = 3;
 
 #undef KeyPress
@@ -128,7 +132,11 @@ namespace frontend {
 
 class CursorWidget {
 public:
-	CursorWidget() {}
+	CursorWidget() : rtl_(false), l_shape_(false), completable_(false),
+		show_(false), x_(0), cursor_width_(0)
+	{
+		recomputeWidth();
+	}
 
 	void draw(QPainter & painter)
 	{
@@ -140,8 +148,8 @@ public:
 		int r = rect_.right() - x_;
 		int bot = rect_.bottom();
 
-		// draw vertica linel
-		painter.fillRect(x_, y, CursorWidth, rect_.height(), color_);
+		// draw vertical line
+		painter.fillRect(x_, y, cursor_width_, rect_.height(), color_);
 
 		// draw RTL/LTR indication
 		painter.setPen(color_);
@@ -149,7 +157,7 @@ public:
 			if (rtl_)
 				painter.drawLine(x_, bot, x_ - l, bot);
 			else
-				painter.drawLine(x_, bot, x_ + CursorWidth + r, bot);
+				painter.drawLine(x_, bot, x_ + cursor_width_ + r, bot);
 		}
 
 		// draw completion triangle
@@ -160,8 +168,8 @@ public:
 				painter.drawLine(x_ - 1, m - d, x_ - 1 - d, m);
 				painter.drawLine(x_ - 1, m + d, x_ - 1 - d, m);
 			} else {
-				painter.drawLine(x_ + CursorWidth, m - d, x_ + CursorWidth + d, m);
-				painter.drawLine(x_ + CursorWidth, m + d, x_ + CursorWidth + d, m);
+				painter.drawLine(x_ + cursor_width_, m - d, x_ + cursor_width_ + d, m);
+				painter.drawLine(x_ + cursor_width_, m + d, x_ + cursor_width_ + d, m);
 			}
 		}
 	}
@@ -196,11 +204,17 @@ public:
 		}
 
 		// compute overall rectangle
-		rect_ = QRect(x - l, y, CursorWidth + r + l, h);
+		rect_ = QRect(x - l, y, cursor_width_ + r + l, h);
 	}
 
 	void show(bool set_show = true) { show_ = set_show; }
 	void hide() { show_ = false; }
+	int cursorWidth() const { return cursor_width_; }
+	void recomputeWidth() {
+		cursor_width_ = lyxrc.cursor_width
+			? lyxrc.cursor_width 
+			: 1 + int((lyxrc.zoom + 50) / 200.0);
+	}
 
 	QRect const & rect() { return rect_; }
 
@@ -219,6 +233,8 @@ private:
 	QRect rect_;
 	/// x position (were the vertical line is drawn)
 	int x_;
+	
+	int cursor_width_;
 };
 
 
@@ -229,50 +245,64 @@ SyntheticMouseEvent::SyntheticMouseEvent()
 {}
 
 
-GuiWorkArea::GuiWorkArea(QWidget *)
-	: buffer_view_(0), lyx_view_(0),
-	cursor_visible_(false),
-	need_resize_(false), schedule_redraw_(false),
-	preedit_lines_(1), completer_(new GuiCompleter(this, this)),
-	context_target_pos_()
+GuiWorkArea::Private::Private(GuiWorkArea * parent)
+: p(parent), screen_(0), buffer_view_(0), lyx_view_(0),
+  cursor_visible_(false), cursor_(0),
+  need_resize_(false), schedule_redraw_(false), preedit_lines_(1),
+  pixel_ratio_(1.0),
+  completer_(new GuiCompleter(p, p)), dialog_mode_(false),
+  read_only_(false), clean_(true)
+{
+}
+
+
+GuiWorkArea::GuiWorkArea(QWidget * /* w */)
+: d(new Private(this)) 
 {
 }
 
 
 GuiWorkArea::GuiWorkArea(Buffer & buffer, GuiView & gv)
-	: buffer_view_(0), read_only_(buffer.isReadonly()), lyx_view_(0),
-	cursor_visible_(false),
-	need_resize_(false), schedule_redraw_(false),
-	preedit_lines_(1), completer_(new GuiCompleter(this, this)),
-	context_target_pos_()
+: d(new Private(this))
 {
 	setGuiView(gv);
+	buffer.params().display_pixel_ratio = theGuiApp()->pixelRatio();
 	setBuffer(buffer);
 	init();
 }
 
 
+double GuiWorkArea::pixelRatio() const
+{
+#if QT_VERSION >= 0x050000
+	return qt_scale_factor * devicePixelRatio();
+#else
+	return 1.0;
+#endif
+}
+
+
 void GuiWorkArea::init()
 {
 	// Setup the signals
-	connect(&cursor_timeout_, SIGNAL(timeout()),
+	connect(&d->cursor_timeout_, SIGNAL(timeout()),
 		this, SLOT(toggleCursor()));
 
 	int const time = QApplication::cursorFlashTime() / 2;
 	if (time > 0) {
-		cursor_timeout_.setInterval(time);
-		cursor_timeout_.start();
+		d->cursor_timeout_.setInterval(time);
+		d->cursor_timeout_.start();
 	} else {
 		// let's initialize this just to be safe
-		cursor_timeout_.setInterval(500);
+		d->cursor_timeout_.setInterval(500);
 	}
 
-	screen_ = QPixmap(viewport()->width(), viewport()->height());
+	d->resetScreen();
 	// With Qt4.5 a mouse event will happen before the first paint event
 	// so make sure that the buffer view has an up to date metrics.
-	buffer_view_->resize(viewport()->width(), viewport()->height());
-	cursor_ = new frontend::CursorWidget();
-	cursor_->hide();
+	d->buffer_view_->resize(viewport()->width(), viewport()->height());
+	d->cursor_ = new frontend::CursorWidget();
+	d->cursor_->hide();
 
 	setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
 	setAcceptDrops(true);
@@ -288,9 +318,9 @@ void GuiWorkArea::init()
 
 	setFocusPolicy(Qt::StrongFocus);
 
-	setCursorShape(Qt::IBeamCursor);
+	d->setCursorShape(Qt::IBeamCursor);
 
-	synthetic_mouse_event_.timeout.timeout.connect(
+	d->synthetic_mouse_event_.timeout.timeout.connect(
 		bind(&GuiWorkArea::generateSyntheticMouseEvent,
 					this));
 
@@ -305,18 +335,20 @@ void GuiWorkArea::init()
 	// Must be set when creating custom text editing widgets.
 	setAttribute(Qt::WA_InputMethodEnabled, true);
 
-	dialog_mode_ = false;
+	d->dialog_mode_ = false;
 }
 
 
 GuiWorkArea::~GuiWorkArea()
 {
-	buffer_view_->buffer().workAreaManager().remove(this);
-	delete buffer_view_;
-	delete cursor_;
+	d->buffer_view_->buffer().workAreaManager().remove(this);
+	delete d->screen_;
+	delete d->buffer_view_;
+	delete d->cursor_;
 	// Completer has a QObject parent and is thus automatically destroyed.
 	// See #4758.
 	// delete completer_;
+	delete d;
 }
 
 
@@ -326,13 +358,13 @@ Qt::CursorShape GuiWorkArea::cursorShape() const
 }
 
 
-void GuiWorkArea::setCursorShape(Qt::CursorShape shape)
+void GuiWorkArea::Private::setCursorShape(Qt::CursorShape shape)
 {
-	viewport()->setCursor(shape);
+	p->viewport()->setCursor(shape);
 }
 
 
-void GuiWorkArea::updateCursorShape()
+void GuiWorkArea::Private::updateCursorShape()
 {
 	setCursorShape(buffer_view_->clickableInset() 
 		? Qt::PointingHandCursor : Qt::IBeamCursor);
@@ -341,14 +373,14 @@ void GuiWorkArea::updateCursorShape()
 
 void GuiWorkArea::setGuiView(GuiView & gv)
 {
-	lyx_view_ = &gv;
+	d->lyx_view_ = &gv;
 }
 
 
 void GuiWorkArea::setBuffer(Buffer & buffer)
 {
-	delete buffer_view_;
-	buffer_view_ = new BufferView(buffer);
+	delete d->buffer_view_;
+	d->buffer_view_ = new BufferView(buffer);
 	buffer.workAreaManager().add(this);
 
 	// HACK: Prevents an additional redraw when the scrollbar pops up
@@ -360,6 +392,7 @@ void GuiWorkArea::setBuffer(Buffer & buffer)
 	if (buffer.text().paragraphs().size() > 4)
 		setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
 	QTimer::singleShot(50, this, SLOT(fixVerticalScrollBar()));
+	Q_EMIT bufferViewChanged();
 }
 
 
@@ -372,13 +405,13 @@ void GuiWorkArea::fixVerticalScrollBar()
 
 void GuiWorkArea::close()
 {
-	lyx_view_->removeWorkArea(this);
+	d->lyx_view_->removeWorkArea(this);
 }
 
 
 void GuiWorkArea::setFullScreen(bool full_screen)
 {
-	buffer_view_->setFullScreen(full_screen);
+	d->buffer_view_->setFullScreen(full_screen);
 	setFrameStyle(QFrame::NoFrame);
 	if (full_screen) {
 		setFrameStyle(QFrame::NoFrame);
@@ -391,20 +424,20 @@ void GuiWorkArea::setFullScreen(bool full_screen)
 
 BufferView & GuiWorkArea::bufferView()
 {
-	return *buffer_view_;
+	return *d->buffer_view_;
 }
 
 
 BufferView const & GuiWorkArea::bufferView() const
 {
-	return *buffer_view_;
+	return *d->buffer_view_;
 }
 
 
 void GuiWorkArea::stopBlinkingCursor()
 {
-	cursor_timeout_.stop();
-	hideCursor();
+	d->cursor_timeout_.stop();
+	d->hideCursor();
 }
 
 
@@ -416,19 +449,19 @@ void GuiWorkArea::startBlinkingCursor()
 
 	Point p;
 	int h = 0;
-	buffer_view_->cursorPosAndHeight(p, h);
+	d->buffer_view_->cursorPosAndHeight(p, h);
 	// Don't start blinking if the cursor isn't on screen.
-	if (!buffer_view_->cursorInView(p, h))
+	if (!d->buffer_view_->cursorInView(p, h))
 		return;
 
-	showCursor();
+	d->showCursor();
 
 	//we're not supposed to cache this value.
 	int const time = QApplication::cursorFlashTime() / 2;
 	if (time <= 0)
 		return;
-	cursor_timeout_.setInterval(time);
-	cursor_timeout_.start();
+	d->cursor_timeout_.setInterval(time);
+	d->cursor_timeout_.start();
 }
 
 
@@ -440,46 +473,54 @@ void GuiWorkArea::redraw(bool update_metrics)
 
 	// No need to do anything if this is the current view. The BufferView
 	// metrics are already up to date.
-	if (update_metrics || lyx_view_ != guiApp->currentView()
-		|| lyx_view_->currentWorkArea() != this) {
+	if (update_metrics || d->lyx_view_ != guiApp->currentView()
+		|| d->lyx_view_->currentWorkArea() != this) {
 		// FIXME: it would be nice to optimize for the off-screen case.
-		buffer_view_->cursor().fixIfBroken();
-		buffer_view_->updateMetrics();
-		buffer_view_->cursor().fixIfBroken();
+		d->buffer_view_->cursor().fixIfBroken();
+		d->buffer_view_->updateMetrics();
+		d->buffer_view_->cursor().fixIfBroken();
 	}
 
 	// update cursor position, because otherwise it has to wait until
 	// the blinking interval is over
-	if (cursor_visible_) {
-		hideCursor();
-		showCursor();
+	if (d->cursor_visible_) {
+		d->hideCursor();
+		d->showCursor();
 	}
 
 	LYXERR(Debug::WORKAREA, "WorkArea::redraw screen");
-	updateScreen();
+	d->updateScreen();
 	update(0, 0, viewport()->width(), viewport()->height());
 
 	/// \warning: scrollbar updating *must* be done after the BufferView is drawn
 	/// because \c BufferView::updateScrollbar() is called in \c BufferView::draw().
-	updateScrollbar();
-	lyx_view_->updateStatusBar();
+	d->updateScrollbar();
+	d->lyx_view_->updateStatusBar();
 
 	if (lyxerr.debugging(Debug::WORKAREA))
-		buffer_view_->coordCache().dump();
+		d->buffer_view_->coordCache().dump();
 
-	setReadOnly(buffer_view_->buffer().isReadonly());
+	updateWindowTitle();
 
-	updateCursorShape();
+	d->updateCursorShape();
 }
 
 
+// Keep in sync with GuiWorkArea::processKeySym below
+bool GuiWorkArea::queryKeySym(KeySymbol const & key, KeyModifier mod) const
+{
+	return guiApp->queryKeySym(key, mod);
+}
+
+
+// Keep in sync with GuiWorkArea::queryKeySym above
 void GuiWorkArea::processKeySym(KeySymbol const & key, KeyModifier mod)
 {
-	if (lyx_view_->isFullScreen() && lyx_view_->menuBar()->isVisible()
+	if (d->lyx_view_->isFullScreen() && d->lyx_view_->menuBar()->isVisible()
 		&& lyxrc.full_screen_menubar) {
 		// FIXME HACK: we should not have to do this here. See related comment
 		// in GuiView::event() (QEvent::ShortcutOverride)
-		lyx_view_->menuBar()->hide();
+		d->lyx_view_->menuBar()->hide();
 	}
 
 	// In order to avoid bad surprise in the middle of an operation,
@@ -490,39 +531,27 @@ void GuiWorkArea::processKeySym(KeySymbol const & key, KeyModifier mod)
 }
 
 
-void GuiWorkArea::dispatch(FuncRequest const & cmd0, KeyModifier mod)
+void GuiWorkArea::Private::dispatch(FuncRequest const & cmd)
 {
 	// Handle drag&drop
-	if (cmd0.action() == LFUN_FILE_OPEN) {
+	if (cmd.action() == LFUN_FILE_OPEN) {
 		DispatchResult dr;
-		lyx_view_->dispatch(cmd0, dr);
+		lyx_view_->dispatch(cmd, dr);
 		return;
 	}
 
-	FuncRequest cmd;
-
-	if (cmd0.action() == LFUN_MOUSE_PRESS) {
-		if (mod == ShiftModifier)
-			cmd = FuncRequest(cmd0, "region-select");
-		else if (mod == ControlModifier)
-			cmd = FuncRequest(cmd0, "paragraph-select");
-		else
-			cmd = cmd0;
-	}
-	else
-		cmd = cmd0;
-
 	bool const notJustMovingTheMouse =
 		cmd.action() != LFUN_MOUSE_MOTION || cmd.button() != mouse_button::none;
 
 	// In order to avoid bad surprise in the middle of an operation, we better stop
 	// the blinking cursor.
 	if (notJustMovingTheMouse)
-		stopBlinkingCursor();
+		p->stopBlinkingCursor();
 
 	buffer_view_->mouseEventDispatch(cmd);
 
 	// Skip these when selecting
+	// FIXME: let GuiView take care of those.
 	if (cmd.action() != LFUN_MOUSE_MOTION) {
 		completer_->updateVisibility(false, false);
 		lyx_view_->updateDialogs();
@@ -534,26 +563,30 @@ void GuiWorkArea::dispatch(FuncRequest const & cmd0, KeyModifier mod)
 		// Slight hack: this is only called currently when we
 		// clicked somewhere, so we force through the display
 		// of the new status here.
+		// FIXME: let GuiView take care of those.
 		lyx_view_->clearMessage();
 
 		// Show the cursor immediately after any operation
-		startBlinkingCursor();
+		p->startBlinkingCursor();
 	}
 
 	updateCursorShape();
 }
 
 
-void GuiWorkArea::resizeBufferView()
+void GuiWorkArea::Private::resizeBufferView()
 {
 	// WARNING: Please don't put any code that will trigger a repaint here!
 	// We are already inside a paint event.
-	lyx_view_->setBusy(true);
-	Point p;
+	p->stopBlinkingCursor();
+	// Warn our container (GuiView).
+	p->busy(true);
+
+	Point point;
 	int h = 0;
-	buffer_view_->cursorPosAndHeight(p, h);
-	bool const cursor_in_view = buffer_view_->cursorInView(p, h);
-	buffer_view_->resize(viewport()->width(), viewport()->height());
+	buffer_view_->cursorPosAndHeight(point, h);
+	bool const cursor_in_view = buffer_view_->cursorInView(point, h);
+	buffer_view_->resize(p->viewport()->width(), p->viewport()->height());
 	if (cursor_in_view)
 		buffer_view_->scrollToCursor();
 	updateScreen();
@@ -564,13 +597,17 @@ void GuiWorkArea::resizeBufferView()
 	// as the scrollbar paramters are then set for the first time.
 	updateScrollbar();
 
-	lyx_view_->updateLayoutList();
-	lyx_view_->setBusy(false);
 	need_resize_ = false;
+	p->busy(false);
+	// Eventually, restart the cursor after the resize event.
+	// We might be resizing even if the focus is on another widget so we only
+	// restart the cursor if we have the focus.
+	if (p->hasFocus())
+		QTimer::singleShot(50, p, SLOT(startBlinkingCursor()));
 }
 
 
-void GuiWorkArea::showCursor()
+void GuiWorkArea::Private::showCursor()
 {
 	if (cursor_visible_)
 		return;
@@ -602,11 +639,18 @@ void GuiWorkArea::showCursor()
 		&& !completer_->popupVisible()
 		&& !completer_->inlineVisible();
 	cursor_visible_ = true;
+	cursor_->recomputeWidth();
+
+	//int cur_x = buffer_view_->getPos(cur).x_;
+	// We may have decided to slide the cursor row so that cursor
+	// is visible.
+	p.x_ -= buffer_view_->horizScrollOffset();
+
 	showCursor(p.x_, p.y_, h, l_shape, isrtl, completable);
 }
 
 
-void GuiWorkArea::hideCursor()
+void GuiWorkArea::Private::hideCursor()
 {
 	if (!cursor_visible_)
 		return;
@@ -618,39 +662,42 @@ void GuiWorkArea::hideCursor()
 
 void GuiWorkArea::toggleCursor()
 {
-	if (cursor_visible_)
-		hideCursor();
+	if (d->cursor_visible_)
+		d->hideCursor();
 	else
-		showCursor();
+		d->showCursor();
 }
 
 
-void GuiWorkArea::updateScrollbar()
+void GuiWorkArea::Private::updateScrollbar()
 {
 	ScrollbarParameters const & scroll_ = buffer_view_->scrollbarParameters();
-	// WARNING: don't touch at the scrollbar value like this:
-	//   verticalScrollBar()->setValue(scroll_.position);
-	// because this would cause a recursive signal/slot calling with
-	// GuiWorkArea::scrollTo
-	verticalScrollBar()->setRange(scroll_.min, scroll_.max);
-	verticalScrollBar()->setPageStep(scroll_.page_step);
-	verticalScrollBar()->setSingleStep(scroll_.single_step);
-	verticalScrollBar()->setSliderPosition(scroll_.position);
+	// Block signals to prevent setRange() and setSliderPosition from causing
+	// recursive calls via the signal valueChanged. (#10311)
+	QSignalBlocker blocker(p->verticalScrollBar());
+	p->verticalScrollBar()->setRange(scroll_.min, scroll_.max);
+	p->verticalScrollBar()->setPageStep(scroll_.page_step);
+	p->verticalScrollBar()->setSingleStep(scroll_.single_step);
+	p->verticalScrollBar()->setSliderPosition(0);
 }
 
 
 void GuiWorkArea::scrollTo(int value)
 {
 	stopBlinkingCursor();
-	buffer_view_->scrollDocView(value, true);
+	d->buffer_view_->scrollDocView(value, true);
 
 	if (lyxrc.cursor_follows_scrollbar) {
-		buffer_view_->setCursorFromScrollbar();
-		lyx_view_->updateLayoutList();
+		d->buffer_view_->setCursorFromScrollbar();
+		// FIXME: let GuiView take care of those.
+		d->lyx_view_->updateLayoutList();
 	}
 	// Show the cursor immediately after any operation.
 	startBlinkingCursor();
+	// FIXME QT5
+#ifdef Q_WS_X11
 	QApplication::syncX();
+#endif
 }
 
 
@@ -662,8 +709,8 @@ bool GuiWorkArea::event(QEvent * e)
 		if (lyxrc.use_tooltip) {
 			QPoint pos = helpEvent->pos();
 			if (pos.x() < viewport()->width()) {
-				QString s = toqstr(buffer_view_->toolTip(pos.x(), pos.y()));
-				QToolTip::showText(helpEvent->globalPos(), s);
+				QString s = toqstr(d->buffer_view_->toolTip(pos.x(), pos.y()));
+				QToolTip::showText(helpEvent->globalPos(), formatToolTip(s,35));
 			}
 			else
 				QToolTip::hideText();
@@ -673,7 +720,13 @@ bool GuiWorkArea::event(QEvent * e)
 		return true;
 	}
 
-	case QEvent::ShortcutOverride: {
+	case QEvent::ShortcutOverride:
+		// keyPressEvent is ShortcutOverride-aware and only accepts the event in
+		// this case
+		keyPressEvent(static_cast<QKeyEvent *>(e));
+		return e->isAccepted();
+
+	case QEvent::KeyPress: {
 		// We catch this event in order to catch the Tab or Shift+Tab key press
 		// which are otherwise reserved to focus switching between controls
 		// within a dialog.
@@ -697,31 +750,36 @@ bool GuiWorkArea::event(QEvent * e)
 
 void GuiWorkArea::contextMenuEvent(QContextMenuEvent * e)
 {
-	QPoint pos;
+	string name;
 	if (e->reason() == QContextMenuEvent::Mouse)
-		// the position is set on mouse press
-		pos = context_target_pos_;
-	else
-		pos = e->pos();
-	Cursor const & cur = buffer_view_->cursor();
-	if (e->reason() == QContextMenuEvent::Keyboard && cur.inTexted()) {
-		// Do not access the context menu of math right in front of before
-		// the cursor. This does not work when the cursor is in text.
-		Inset * inset = cur.paragraph().getInset(cur.pos());
-		if (inset && inset->asInsetMath())
-			--pos.rx();
-		else if (cur.pos() > 0) {
-			Inset * inset = cur.paragraph().getInset(cur.pos() - 1);
-			if (inset)
-				++pos.rx();
+		// the menu name is set on mouse press
+		name = d->context_menu_name_;
+	else {
+		QPoint pos = e->pos();
+		Cursor const & cur = d->buffer_view_->cursor();
+		if (e->reason() == QContextMenuEvent::Keyboard && cur.inTexted()) {
+			// Do not access the context menu of math right in front of before
+			// the cursor. This does not work when the cursor is in text.
+			Inset * inset = cur.paragraph().getInset(cur.pos());
+			if (inset && inset->asInsetMath())
+				--pos.rx();
+			else if (cur.pos() > 0) {
+				Inset * inset = cur.paragraph().getInset(cur.pos() - 1);
+				if (inset)
+					++pos.rx();
+			}
 		}
+		name = d->buffer_view_->contextMenu(pos.x(), pos.y());
 	}
-	docstring name = buffer_view_->contextMenu(pos.x(), pos.y());
+	
 	if (name.empty()) {
 		QAbstractScrollArea::contextMenuEvent(e);
 		return;
 	}
-	QMenu * menu = guiApp->menus().menu(toqstr(name), *lyx_view_);
+	// always show mnemonics when the keyboard is used to show the context menu
+	// FIXME: This should be fixed in Qt itself
+	bool const keyboard = (e->reason() == QContextMenuEvent::Keyboard);
+	QMenu * menu = guiApp->menus().menu(toqstr(name), *d->lyx_view_, keyboard);
 	if (!menu) {
 		QAbstractScrollArea::contextMenuEvent(e);
 		return;
@@ -736,8 +794,10 @@ void GuiWorkArea::contextMenuEvent(QContextMenuEvent * e)
 void GuiWorkArea::focusInEvent(QFocusEvent * e)
 {
 	LYXERR(Debug::DEBUG, "GuiWorkArea::focusInEvent(): " << this << endl);
-	if (lyx_view_->currentWorkArea() != this)
-		lyx_view_->setCurrentWorkArea(this);
+	if (d->lyx_view_->currentWorkArea() != this) {
+		d->lyx_view_->setCurrentWorkArea(this);
+		d->lyx_view_->currentWorkArea()->bufferView().buffer().updateBuffer();
+	}
 
 	startBlinkingCursor();
 	QAbstractScrollArea::focusInEvent(e);
@@ -754,35 +814,43 @@ void GuiWorkArea::focusOutEvent(QFocusEvent * e)
 
 void GuiWorkArea::mousePressEvent(QMouseEvent * e)
 {
-	if (dc_event_.active && dc_event_ == *e) {
-		dc_event_.active = false;
+	if (d->dc_event_.active && d->dc_event_ == *e) {
+		d->dc_event_.active = false;
 		FuncRequest cmd(LFUN_MOUSE_TRIPLE, e->x(), e->y(),
-			q_button_state(e->button()));
-		dispatch(cmd);
+			q_button_state(e->button()), q_key_state(e->modifiers()));
+		d->dispatch(cmd);
 		e->accept();
 		return;
 	}
 
-	if (e->button() == Qt::RightButton)
-		context_target_pos_ = e->pos();
-
+#if (QT_VERSION < 0x050000) && !defined(__HAIKU__)
 	inputContext()->reset();
+#endif
 
 	FuncRequest const cmd(LFUN_MOUSE_PRESS, e->x(), e->y(),
-		q_button_state(e->button()));
-	dispatch(cmd, q_key_state(e->modifiers()));
+			q_button_state(e->button()), q_key_state(e->modifiers()));
+	d->dispatch(cmd);
+
+	// Save the context menu on mouse press, because also the mouse
+	// cursor is set on mouse press. Afterwards, we can either release
+	// the mousebutton somewhere else, or the cursor might have moved
+	// due to the DEPM. We need to do this after the mouse has been
+	// set in dispatch(), because the selection state might change.
+	if (e->button() == Qt::RightButton)
+		d->context_menu_name_ = d->buffer_view_->contextMenu(e->x(), e->y());
+
 	e->accept();
 }
 
 
 void GuiWorkArea::mouseReleaseEvent(QMouseEvent * e)
 {
-	if (synthetic_mouse_event_.timeout.running())
-		synthetic_mouse_event_.timeout.stop();
+	if (d->synthetic_mouse_event_.timeout.running())
+		d->synthetic_mouse_event_.timeout.stop();
 
 	FuncRequest const cmd(LFUN_MOUSE_RELEASE, e->x(), e->y(),
-			      q_button_state(e->button()));
-	dispatch(cmd);
+			q_button_state(e->button()), q_key_state(e->modifiers()));
+	d->dispatch(cmd);
 	e->accept();
 }
 
@@ -792,7 +860,7 @@ void GuiWorkArea::mouseMoveEvent(QMouseEvent * e)
 	// we kill the triple click if we move
 	doubleClickTimeout();
 	FuncRequest cmd(LFUN_MOUSE_MOTION, e->x(), e->y(),
-		q_motion_state(e->buttons()));
+			q_motion_state(e->buttons()), q_key_state(e->modifiers()));
 
 	e->accept();
 
@@ -807,9 +875,9 @@ void GuiWorkArea::mouseMoveEvent(QMouseEvent * e)
 		else
 			cmd.set_y(e->y() + 21);
 		// Store the event, to be handled when the timeout expires.
-		synthetic_mouse_event_.cmd = cmd;
+		d->synthetic_mouse_event_.cmd = cmd;
 
-		if (synthetic_mouse_event_.timeout.running()) {
+		if (d->synthetic_mouse_event_.timeout.running()) {
 			// Discard the event. Note that it _may_ be handled
 			// when the timeout expires if
 			// synthetic_mouse_event_.cmd has not been overwritten.
@@ -820,22 +888,22 @@ void GuiWorkArea::mouseMoveEvent(QMouseEvent * e)
 			return;
 		}
 		
-		synthetic_mouse_event_.restart_timeout = true;
-		synthetic_mouse_event_.timeout.start();
+		d->synthetic_mouse_event_.restart_timeout = true;
+		d->synthetic_mouse_event_.timeout.start();
 		// Fall through to handle this event...
 
-	} else if (synthetic_mouse_event_.timeout.running()) {
+	} else if (d->synthetic_mouse_event_.timeout.running()) {
 		// Store the event, to be possibly handled when the timeout
 		// expires.
 		// Once the timeout has expired, normal control is returned
 		// to mouseMoveEvent (restart_timeout = false).
 		// This results in a much smoother 'feel' when moving the
 		// mouse back into the work area.
-		synthetic_mouse_event_.cmd = cmd;
-		synthetic_mouse_event_.restart_timeout = false;
+		d->synthetic_mouse_event_.cmd = cmd;
+		d->synthetic_mouse_event_.restart_timeout = false;
 		return;
 	}
-	dispatch(cmd);
+	d->dispatch(cmd);
 }
 
 
@@ -871,8 +939,10 @@ void GuiWorkArea::wheelEvent(QWheelEvent * ev)
 	int const lines = qApp->wheelScrollLines();
 	int const page_step = verticalScrollBar()->pageStep();
 	// Test if the wheel mouse is set to one screen at a time.
-	int scroll_value = lines > page_step
-		? page_step : lines * verticalScrollBar()->singleStep();
+	// This is according to
+	// https://doc.qt.io/qt-5/qapplication.html#wheelScrollLines-prop
+	int scroll_value =
+		min(lines * verticalScrollBar()->singleStep(), page_step);
 
 	// Take into account the rotation and the user preferences.
 	scroll_value = int(scroll_value * delta * lyxrc.mouse_wheel_speed);
@@ -888,14 +958,14 @@ void GuiWorkArea::wheelEvent(QWheelEvent * ev)
 
 void GuiWorkArea::generateSyntheticMouseEvent()
 {
-	int const e_y = synthetic_mouse_event_.cmd.y();
-	int const wh = buffer_view_->workHeight();
+	int const e_y = d->synthetic_mouse_event_.cmd.y();
+	int const wh = d->buffer_view_->workHeight();
 	bool const up = e_y < 0;
 	bool const down = e_y > wh;
 
 	// Set things off to generate the _next_ 'pseudo' event.
 	int step = 50;
-	if (synthetic_mouse_event_.restart_timeout) {
+	if (d->synthetic_mouse_event_.restart_timeout) {
 		// This is some magic formulae to determine the speed
 		// of scrolling related to the position of the mouse.
 		int time = 200;
@@ -908,33 +978,37 @@ void GuiWorkArea::generateSyntheticMouseEvent()
 				time = 40;
 			}
 		}
-		synthetic_mouse_event_.timeout.setTimeout(time);
-		synthetic_mouse_event_.timeout.start();
+		d->synthetic_mouse_event_.timeout.setTimeout(time);
+		d->synthetic_mouse_event_.timeout.start();
 	}
 
 	// Can we scroll further ?
 	int const value = verticalScrollBar()->value();
 	if (value == verticalScrollBar()->maximum()
 		  || value == verticalScrollBar()->minimum()) {
-		synthetic_mouse_event_.timeout.stop();
+		d->synthetic_mouse_event_.timeout.stop();
 		return;
 	}
 
 	// Scroll
 	if (step <= 2 * wh) {
-		buffer_view_->scroll(up ? -step : step);
-		buffer_view_->updateMetrics();
+		d->buffer_view_->scroll(up ? -step : step);
+		d->buffer_view_->updateMetrics();
 	} else {
-		buffer_view_->scrollDocView(value + up ? -step : step, false);
+		d->buffer_view_->scrollDocView(value + (up ? -step : step), false);
 	}
 
 	// In which paragraph do we have to set the cursor ?
-	Cursor & cur = buffer_view_->cursor();
-	TextMetrics const & tm = buffer_view_->textMetrics(cur.text());
+	Cursor & cur = d->buffer_view_->cursor();
+	// FIXME: we don't know howto handle math.
+	Text * text = cur.text();
+	if (!text)
+		return;
+	TextMetrics const & tm = d->buffer_view_->textMetrics(text);
 
-	pair<pit_type, const ParagraphMetrics *> p = up ? tm.first() : tm.last();
-	ParagraphMetrics const & pm = *p.second;
-	pit_type const pit = p.first;
+	pair<pit_type, const ParagraphMetrics *> pp = up ? tm.first() : tm.last();
+	ParagraphMetrics const & pm = *pp.second;
+	pit_type const pit = pp.first;
 
 	if (pm.rows().empty())
 		return;
@@ -950,26 +1024,30 @@ void GuiWorkArea::generateSyntheticMouseEvent()
 			break;
 		yy += h;
 	}
-	
+
 	// Find the position of the cursor
 	bool bound;
-	int x = synthetic_mouse_event_.cmd.x();
-	pos_type const pos = rit->pos() + tm.getColumnNearX(pit, *rit, x, bound);
+	int x = d->synthetic_mouse_event_.cmd.x();
+	pos_type const pos = tm.getPosNearX(*rit, x, bound);
 
 	// Set the cursor
 	cur.pit() = pit;
 	cur.pos() = pos;
 	cur.boundary(bound);
 
-	buffer_view_->buffer().changed(false);
+	d->buffer_view_->buffer().changed(false);
 	return;
 }
 
 
 void GuiWorkArea::keyPressEvent(QKeyEvent * ev)
 {
+	// this is also called for ShortcutOverride events. In this case, one must
+	// not act but simply accept the event explicitly.
+	bool const act = (ev->type() != QEvent::ShortcutOverride);
+
 	// Do not process here some keys if dialog_mode_ is set
-	if (dialog_mode_
+	if (d->dialog_mode_
 		&& (ev->modifiers() == Qt::NoModifier
 		    || ev->modifiers() == Qt::ShiftModifier)
 		&& (ev->key() == Qt::Key_Escape
@@ -981,11 +1059,12 @@ void GuiWorkArea::keyPressEvent(QKeyEvent * ev)
 	}
 
 	// intercept some keys if completion popup is visible
-	if (completer_->popupVisible()) {
+	if (d->completer_->popupVisible()) {
 		switch (ev->key()) {
 		case Qt::Key_Enter:
 		case Qt::Key_Return:
-			completer_->activate();
+			if (act)
+				d->completer_->activate();
 			ev->accept();
 			return;
 		}
@@ -994,22 +1073,49 @@ void GuiWorkArea::keyPressEvent(QKeyEvent * ev)
 	// do nothing if there are other events
 	// (the auto repeated events come too fast)
 	// it looks like this is only needed on X11
-#ifdef Q_WS_X11
-	if (qApp->hasPendingEvents() && ev->isAutoRepeat()) {
-		LYXERR(Debug::KEY, "system is busy: keyPress event ignored");
-		ev->ignore();
-		return;
+#if defined(Q_WS_X11) || defined(QPA_XCB)
+	// FIXME: this is a weird way to implement event compression. Also, this is
+	// broken with IBus.
+	if (act && qApp->hasPendingEvents() && ev->isAutoRepeat()) {
+		switch (ev->key()) {
+		case Qt::Key_PageDown:
+		case Qt::Key_PageUp:
+		case Qt::Key_Left:
+		case Qt::Key_Right:
+		case Qt::Key_Up:
+		case Qt::Key_Down:
+			LYXERR(Debug::KEY, "system is busy: scroll key event ignored");
+			ev->ignore();
+			return;
+		}
 	}
 #endif
 
-	LYXERR(Debug::KEY, " count: " << ev->count() << " text: " << ev->text()
-		<< " isAutoRepeat: " << ev->isAutoRepeat() << " key: " << ev->key());
+	KeyModifier const m = q_key_state(ev->modifiers());
+
+	std::string str;
+	if (m & ShiftModifier)
+		str += "Shift-";
+	if (m & ControlModifier)
+		str += "Control-";
+	if (m & AltModifier)
+		str += "Alt-";
+	if (m & MetaModifier)
+		str += "Meta-";
+
+	if (act)
+		LYXERR(Debug::KEY, " count: " << ev->count() << " text: " << ev->text()
+		       << " isAutoRepeat: " << ev->isAutoRepeat() << " key: " << ev->key()
+		       << " keyState: " << str);
 
 	KeySymbol sym;
 	setKeySymbol(&sym, ev);
 	if (sym.isOK()) {
-		processKeySym(sym, q_key_state(ev->modifiers()));
-		ev->accept();
+		if (act) {
+			processKeySym(sym, m);
+			ev->accept();
+		} else
+			ev->setAccepted(queryKeySym(sym, m));
 	} else {
 		ev->ignore();
 	}
@@ -1018,19 +1124,18 @@ void GuiWorkArea::keyPressEvent(QKeyEvent * ev)
 
 void GuiWorkArea::doubleClickTimeout()
 {
-	dc_event_.active = false;
+	d->dc_event_.active = false;
 }
 
 
 void GuiWorkArea::mouseDoubleClickEvent(QMouseEvent * ev)
 {
-	dc_event_ = DoubleClick(ev);
+	d->dc_event_ = DoubleClick(ev);
 	QTimer::singleShot(QApplication::doubleClickInterval(), this,
-			   SLOT(doubleClickTimeout()));
-	FuncRequest cmd(LFUN_MOUSE_DOUBLE,
-			ev->x(), ev->y(),
-			q_button_state(ev->button()));
-	dispatch(cmd);
+			SLOT(doubleClickTimeout()));
+	FuncRequest cmd(LFUN_MOUSE_DOUBLE, ev->x(), ev->y(),
+			q_button_state(ev->button()), q_key_state(ev->modifiers()));
+	d->dispatch(cmd);
 	ev->accept();
 }
 
@@ -1038,47 +1143,56 @@ void GuiWorkArea::mouseDoubleClickEvent(QMouseEvent * ev)
 void GuiWorkArea::resizeEvent(QResizeEvent * ev)
 {
 	QAbstractScrollArea::resizeEvent(ev);
-	need_resize_ = true;
+	d->need_resize_ = true;
 	ev->accept();
 }
 
 
-void GuiWorkArea::update(int x, int y, int w, int h)
+void GuiWorkArea::Private::update(int x, int y, int w, int h)
 {
-	viewport()->repaint(x, y, w, h);
+	p->viewport()->update(x, y, w, h);
 }
 
 
 void GuiWorkArea::paintEvent(QPaintEvent * ev)
 {
-	QRect const rc = ev->rect();
+	QRectF const rc = ev->rect();
 	// LYXERR(Debug::PAINTING, "paintEvent begin: x: " << rc.x()
 	//	<< " y: " << rc.y() << " w: " << rc.width() << " h: " << rc.height());
 
-	if (need_resize_) {
-		screen_ = QPixmap(viewport()->width(), viewport()->height());
-		resizeBufferView();
-		if (cursor_visible_) {
-			hideCursor();
-			showCursor();
+	if (d->needResize()) {
+		d->resetScreen();
+		d->resizeBufferView();
+		if (d->cursor_visible_) {
+			d->hideCursor();
+			d->showCursor();
 		}
 	}
 
 	QPainter pain(viewport());
-	pain.drawPixmap(rc, screen_, rc);
-	cursor_->draw(pain);
+	double const pr = pixelRatio();
+	QRectF const rcs = QRectF(rc.x() * pr, rc.y() * pr, rc.width() * pr, rc.height() * pr);
+
+	if (lyxrc.use_qimage) {
+		QImage const & image = static_cast<QImage const &>(*d->screen_);
+		pain.drawImage(rc, image, rcs);
+	} else {
+		QPixmap const & pixmap = static_cast<QPixmap const &>(*d->screen_);
+		pain.drawPixmap(rc, pixmap, rcs);
+	}
+	d->cursor_->draw(pain);
 	ev->accept();
 }
 
 
-void GuiWorkArea::updateScreen()
+void GuiWorkArea::Private::updateScreen()
 {
-	GuiPainter pain(&screen_);
+	GuiPainter pain(screen_, p->pixelRatio());
 	buffer_view_->draw(pain);
 }
 
 
-void GuiWorkArea::showCursor(int x, int y, int h,
+void GuiWorkArea::Private::showCursor(int x, int y, int h,
 	bool l_shape, bool rtl, bool completable)
 {
 	if (schedule_redraw_) {
@@ -1086,28 +1200,28 @@ void GuiWorkArea::showCursor(int x, int y, int h,
 		// the size of the new graphics, it's better the update everything.
 		// We can't use redraw() here because this would trigger a infinite
 		// recursive loop with showCursor().
-		buffer_view_->resize(viewport()->width(), viewport()->height());
+		buffer_view_->resize(p->viewport()->width(), p->viewport()->height());
 		updateScreen();
 		updateScrollbar();
-		viewport()->update(QRect(0, 0, viewport()->width(), viewport()->height()));
+		p->viewport()->update(QRect(0, 0, p->viewport()->width(), p->viewport()->height()));
 		schedule_redraw_ = false;
 		// Show the cursor immediately after the update.
 		hideCursor();
-		toggleCursor();
+		p->toggleCursor();
 		return;
 	}
 
 	cursor_->update(x, y, h, l_shape, rtl, completable);
 	cursor_->show();
-	viewport()->update(cursor_->rect());
+	p->viewport()->update(cursor_->rect());
 }
 
 
-void GuiWorkArea::removeCursor()
+void GuiWorkArea::Private::removeCursor()
 {
 	cursor_->hide();
 	//if (!qApp->focusWidget())
-		viewport()->update(cursor_->rect());
+		p->viewport()->update(cursor_->rect());
 }
 
 
@@ -1138,6 +1252,8 @@ void GuiWorkArea::inputMethodEvent(QInputMethodEvent * e)
 		stopBlinkingCursor();
 
 	// last_width : for checking if last preedit string was/wasn't empty.
+	// FIXME THREAD && FIXME
+	// We could have more than one work area, right?
 	static bool last_width = false;
 	if (!last_width && preedit_string.empty()) {
 		// if last_width is last length of preedit string.
@@ -1145,22 +1261,23 @@ void GuiWorkArea::inputMethodEvent(QInputMethodEvent * e)
 		return;
 	}
 
-	GuiPainter pain(&screen_);
-	buffer_view_->updateMetrics();
-	buffer_view_->draw(pain);
-	FontInfo font = buffer_view_->cursor().getFont().fontInfo();
+	GuiPainter pain(d->screen_, pixelRatio());
+	d->buffer_view_->updateMetrics();
+	d->buffer_view_->draw(pain);
+	// FIXME: shall we use real_current_font here? (see #10478)
+	FontInfo font = d->buffer_view_->cursor().getFont().fontInfo();
 	FontMetrics const & fm = theFontMetrics(font);
 	int height = fm.maxHeight();
-	int cur_x = cursor_->rect().left();
-	int cur_y = cursor_->rect().bottom();
+	int cur_x = d->cursor_->rect().left();
+	int cur_y = d->cursor_->rect().bottom();
 
 	// redraw area of preedit string.
 	update(0, cur_y - height, viewport()->width(),
-		(height + 1) * preedit_lines_);
+		(height + 1) * d->preedit_lines_);
 
 	if (preedit_string.empty()) {
 		last_width = false;
-		preedit_lines_ = 1;
+		d->preedit_lines_ = 1;
 		e->accept();
 		return;
 	}
@@ -1208,10 +1325,10 @@ void GuiWorkArea::inputMethodEvent(QInputMethodEvent * e)
 		rLength = 0;
 	}
 
-	int const right_margin = buffer_view_->rightMargin();
+	int const right_margin = d->buffer_view_->rightMargin();
 	Painter::preedit_style ps;
 	// Most often there would be only one line:
-	preedit_lines_ = 1;
+	d->preedit_lines_ = 1;
 	for (size_t pos = 0; pos != preedit_length; ++pos) {
 		char_type const typed_char = preedit_string[pos];
 		// reset preedit string style
@@ -1221,7 +1338,7 @@ void GuiWorkArea::inputMethodEvent(QInputMethodEvent * e)
 		if (cur_x + fm.width(typed_char) > viewport()->width() - right_margin) {
 			cur_x = right_margin;
 			cur_y += height + 1;
-			++preedit_lines_;
+			++d->preedit_lines_;
 		}
 		// preedit strings are displayed with dashed underline
 		// and partial strings are displayed white on black indicating
@@ -1242,8 +1359,8 @@ void GuiWorkArea::inputMethodEvent(QInputMethodEvent * e)
 	}
 
 	// update the preedit string screen area.
-	update(0, cur_y - preedit_lines_*height, viewport()->width(),
-		(height + 1) * preedit_lines_);
+	update(0, cur_y - d->preedit_lines_*height, viewport()->width(),
+		(height + 1) * d->preedit_lines_);
 
 	// Don't forget to accept the event!
 	e->accept();
@@ -1257,11 +1374,11 @@ QVariant GuiWorkArea::inputMethodQuery(Qt::InputMethodQuery query) const
 		// this is the CJK-specific composition window position and
 		// the context menu position when the menu key is pressed.
 		case Qt::ImMicroFocus:
-			cur_r = cursor_->rect();
-			if (preedit_lines_ != 1)
+			cur_r = d->cursor_->rect();
+			if (d->preedit_lines_ != 1)
 				cur_r.moveLeft(10);
 			cur_r.moveBottom(cur_r.bottom()
-				+ cur_r.height() * (preedit_lines_ - 1));
+				+ cur_r.height() * (d->preedit_lines_ - 1));
 			// return lower right of cursor in LyX.
 			return cur_r;
 		default:
@@ -1272,56 +1389,58 @@ QVariant GuiWorkArea::inputMethodQuery(Qt::InputMethodQuery query) const
 
 void GuiWorkArea::updateWindowTitle()
 {
-	docstring maximize_title;
-	docstring minimize_title;
-
-	Buffer & buf = buffer_view_->buffer();
-	FileName const fileName = buf.fileName();
-	if (!fileName.empty()) {
-		maximize_title = fileName.displayName(30);
-		minimize_title = from_utf8(fileName.onlyFileName());
-		if (buf.lyxvc().inUse()) {
-			if (buf.lyxvc().locking())
-				maximize_title +=  _(" (version control, locking)");
-			else
-				maximize_title +=  _(" (version control)");
-		}
-		if (!buf.isClean()) {
-			maximize_title += _(" (changed)");
-			minimize_title += char_type('*');
-		}
-		if (buf.isReadonly())
-			maximize_title += _(" (read only)");
+	Buffer const & buf = bufferView().buffer();
+	if (buf.fileName() != d->file_name_ || buf.isReadonly() != d->read_only_
+	    || buf.lyxvc().vcstatus() != d->vc_status_ || buf.isClean() != d->clean_) {
+		d->file_name_ = buf.fileName();
+		d->read_only_ = buf.isReadonly();
+		d->vc_status_ = buf.lyxvc().vcstatus();
+		d->clean_ = buf.isClean();
+		Q_EMIT titleChanged(this);
 	}
+}
 
-	QString title = windowTitle();
-	QString new_title = toqstr(maximize_title);
-	if (title == new_title)
-		return;
 
-	QWidget::setWindowTitle(new_title);
-	QWidget::setWindowIconText(toqstr(minimize_title));
-	titleChanged(this);
+bool GuiWorkArea::isFullScreen() const
+{
+	return d->lyx_view_ && d->lyx_view_->isFullScreen();
 }
 
 
-void GuiWorkArea::setReadOnly(bool read_only)
+void GuiWorkArea::scheduleRedraw()
 {
-	if (read_only_ == read_only)
-		return;
-	read_only_ = read_only;
-	updateWindowTitle();
-	if (this == lyx_view_->currentWorkArea())
-		lyx_view_->updateDialogs();
+	d->schedule_redraw_ = true;
 }
 
 
-bool GuiWorkArea::isFullScreen()
+bool GuiWorkArea::inDialogMode() const
 {
-	return lyx_view_ && lyx_view_->isFullScreen();
+	return d->dialog_mode_;
 }
 
 
+void GuiWorkArea::setDialogMode(bool mode)
+{
+	d->dialog_mode_ = mode;
+}
+
+
+GuiCompleter & GuiWorkArea::completer()
+{
+	return *d->completer_;
+}
+
+GuiView const & GuiWorkArea::view() const
+{
+	return *d->lyx_view_;
+}
+
+
+GuiView & GuiWorkArea::view()
+{
+	return *d->lyx_view_;
+}
+
 ////////////////////////////////////////////////////////////////////
 //
 // EmbeddedWorkArea
@@ -1331,8 +1450,9 @@ bool GuiWorkArea::isFullScreen()
 
 EmbeddedWorkArea::EmbeddedWorkArea(QWidget * w): GuiWorkArea(w)
 {
-	buffer_ = theBufferList().newBuffer(
-		support::FileName::tempName().absFileName() + "_embedded.internal");
+	support::TempFile tempfile("embedded.internal");
+	tempfile.setAutoRemove(false);
+	buffer_ = theBufferList().newInternalBuffer(tempfile.name().absFileName());
 	buffer_->setUnnamed(true);
 	buffer_->setFullyLoaded(true);
 	setBuffer(*buffer_);
@@ -1390,14 +1510,14 @@ void EmbeddedWorkArea::disable()
 //
 ////////////////////////////////////////////////////////////////////
 
-#ifdef Q_WS_MACX
-class NoTabFrameMacStyle : public QMacStyle {
+#ifdef Q_OS_MAC
+class NoTabFrameMacStyle : public QProxyStyle {
 public:
 	///
 	QRect subElementRect(SubElement element, const QStyleOption * option,
 			     const QWidget * widget = 0) const
 	{
-		QRect rect = QMacStyle::subElementRect(element, option, widget);
+		QRect rect = QProxyStyle::subElementRect(element, option, widget);
 		bool noBar = static_cast<QTabWidget const *>(widget)->count() <= 1;
 
 		// The Qt Mac style puts the contents into a 3 pixel wide box
@@ -1419,14 +1539,11 @@ NoTabFrameMacStyle noTabFrameMacStyle;
 
 
 TabWorkArea::TabWorkArea(QWidget * parent)
-	: QTabWidget(parent), clicked_tab_(-1)
+	: QTabWidget(parent), clicked_tab_(-1), midpressed_tab_(-1)
 {
-#ifdef Q_WS_MACX
+#ifdef Q_OS_MAC
 	setStyle(&noTabFrameMacStyle);
 #endif
-#if QT_VERSION < 0x040500
-	lyxrc.single_close_tab_button = true;
-#endif
 
 	QPalette pal = palette();
 	pal.setColor(QPalette::Active, QPalette::Button,
@@ -1442,7 +1559,7 @@ TabWorkArea::TabWorkArea(QWidget * parent)
 	closeBufferButton = new QToolButton(this);
 	closeBufferButton->setPalette(pal);
 	// FIXME: rename the icon to closebuffer.png
-	closeBufferButton->setIcon(QIcon(getPixmap("images/", "closetab", "png")));
+	closeBufferButton->setIcon(QIcon(getPixmap("images/", "closetab", "svgz,png")));
 	closeBufferButton->setText("Close File");
 	closeBufferButton->setAutoRaise(true);
 	closeBufferButton->setCursor(Qt::ArrowCursor);
@@ -1463,24 +1580,77 @@ TabWorkArea::TabWorkArea(QWidget * parent)
 	tb->setContextMenuPolicy(Qt::CustomContextMenu);
 	connect(tb, SIGNAL(customContextMenuRequested(const QPoint &)),
 		this, SLOT(showContextMenu(const QPoint &)));
-#if QT_VERSION >= 0x040500
 	connect(tb, SIGNAL(tabCloseRequested(int)),
 		this, SLOT(closeTab(int)));
-#endif
 
 	setUsesScrollButtons(true);
 }
 
 
+void TabWorkArea::mousePressEvent(QMouseEvent *me)
+{
+	if (me->button() == Qt::MidButton)
+		midpressed_tab_ = tabBar()->tabAt(me->pos());
+	else
+		QTabWidget::mousePressEvent(me);
+}
+
+
+void TabWorkArea::mouseReleaseEvent(QMouseEvent *me)
+{
+	if (me->button() == Qt::MidButton) {
+		int const midreleased_tab = tabBar()->tabAt(me->pos());
+		if (midpressed_tab_ == midreleased_tab && posIsTab(me->pos()))
+			closeTab(midreleased_tab);
+	} else
+		QTabWidget::mouseReleaseEvent(me);
+}
+
+
+void TabWorkArea::paintEvent(QPaintEvent * event)
+{
+	if (tabBar()->isVisible()) {
+		QTabWidget::paintEvent(event);
+	} else {
+		// Prevent the selected tab to influence the 
+		// painting of the frame of the tab widget.
+		// This is needed for gtk style in Qt.
+		QStylePainter p(this);
+#if QT_VERSION < 0x050000
+		QStyleOptionTabWidgetFrameV2 opt;
+#else
+		QStyleOptionTabWidgetFrame opt;
+#endif
+		initStyleOption(&opt);
+		opt.rect = style()->subElementRect(QStyle::SE_TabWidgetTabPane,
+			&opt, this);
+		opt.selectedTabRect = QRect();
+		p.drawPrimitive(QStyle::PE_FrameTabWidget, opt);
+	}
+}
+
+
+bool TabWorkArea::posIsTab(QPoint position)
+{
+	// tabAt returns -1 if tab does not covers position
+	return tabBar()->tabAt(position) > -1;
+}
+
+
 void TabWorkArea::mouseDoubleClickEvent(QMouseEvent * event)
 {
 	if (event->button() != Qt::LeftButton)
 		return;
 
+	// this code chunk is unnecessary because it seems the event only makes
+	// it this far if it is not on a tab. I'm not sure why this is (maybe
+	// it is handled and ended in DragTabBar?), and thus I'm not sure if
+	// this is true in all cases and if it will be true in the future so I
+	// leave this code for now. (skostysh, 2016-07-21)
+	//
 	// return early if double click on existing tabs
-	for (int i = 0; i < count(); ++i)
-		if (tabBar()->tabRect(i).contains(event->pos()))
-			return;
+	if (posIsTab(event->pos()))
+		return;
 
 	dispatch(FuncRequest(LFUN_BUFFER_NEW));
 }
@@ -1495,6 +1665,8 @@ void TabWorkArea::setFullScreen(bool full_screen)
 
 	if (lyxrc.full_screen_tabbar)
 		showBar(!full_screen && count() > 1);
+	else
+		showBar(count() > 1);
 }
 
 
@@ -1503,9 +1675,7 @@ void TabWorkArea::showBar(bool show)
 	tabBar()->setEnabled(show);
 	tabBar()->setVisible(show);
 	closeBufferButton->setVisible(show && lyxrc.single_close_tab_button);
-#if QT_VERSION >= 0x040500
 	setTabsClosable(!lyxrc.single_close_tab_button);
-#endif
 }
 
 
@@ -1515,7 +1685,7 @@ GuiWorkArea * TabWorkArea::currentWorkArea()
 		return 0;
 
 	GuiWorkArea * wa = dynamic_cast<GuiWorkArea *>(currentWidget());
-	LASSERT(wa, /**/);
+	LATTEST(wa);
 	return wa;
 }
 
@@ -1544,7 +1714,7 @@ void TabWorkArea::closeAll()
 {
 	while (count()) {
 		GuiWorkArea * wa = workArea(0);
-		LASSERT(wa, /**/);
+		LASSERT(wa, return);
 		removeTab(0);
 		delete wa;
 	}
@@ -1553,7 +1723,7 @@ void TabWorkArea::closeAll()
 
 bool TabWorkArea::setCurrentWorkArea(GuiWorkArea * work_area)
 {
-	LASSERT(work_area, /**/);
+	LASSERT(work_area, return false);
 	int index = indexOf(work_area);
 	if (index == -1)
 		return false;
@@ -1646,7 +1816,7 @@ void TabWorkArea::closeCurrentBuffer()
 		wa = currentWorkArea();
 	else {
 		wa = workArea(clicked_tab_);
-		LASSERT(wa, /**/);
+		LASSERT(wa, return);
 	}
 	wa->view().closeWorkArea(wa);
 }
@@ -1659,7 +1829,7 @@ void TabWorkArea::hideCurrentTab()
 		wa = currentWorkArea();
 	else {
 		wa = workArea(clicked_tab_);
-		LASSERT(wa, /**/);
+		LASSERT(wa, return);
 	}
 	wa->view().hideWorkArea(wa);
 }
@@ -1673,7 +1843,7 @@ void TabWorkArea::closeTab(int index)
 		wa = currentWorkArea();
 	else {
 		wa = workArea(index);
-		LASSERT(wa, /**/);
+		LASSERT(wa, return);
 	}
 	wa->view().closeWorkArea(wa);
 }
@@ -1683,7 +1853,7 @@ void TabWorkArea::closeTab(int index)
 class DisplayPath {
 public:
 	/// make vector happy
-	DisplayPath() {}
+	DisplayPath() : tab_(-1), dottedPrefix_(false) {}
 	///
 	DisplayPath(int tab, FileName const & filename)
 		: tab_(tab)
@@ -1713,7 +1883,7 @@ public:
 
 		if (!dotted) {
 			if (dottedPrefix_ && !prefix_.isEmpty())
-				prefix_ += ".../";
+				prefix_ += ellipsisSlash_;
 			prefix_ += postfix_.front() + "/";
 		}
 		dottedPrefix_ = dotted && !prefix_.isEmpty();
@@ -1726,7 +1896,7 @@ public:
 			return filename_;
 
 		bool dots = dottedPrefix_ || !postfix_.isEmpty();
-		return prefix_ + (dots ? ".../" : "") + filename_;
+		return prefix_ + (dots ? ellipsisSlash_ : "") + filename_;
 	}
 	///
 	QString forecastPathString() const
@@ -1735,7 +1905,7 @@ public:
 			return displayString();
 
 		return prefix_
-			+ (dottedPrefix_ ? ".../" : "")
+			+ (dottedPrefix_ ? ellipsisSlash_ : "")
 			+ postfix_.front() + "/";
 	}
 	///
@@ -1744,6 +1914,8 @@ public:
 	int tab() const { return tab_; }
 
 private:
+	/// ".../"
+	static QString const ellipsisSlash_;
 	///
 	QString prefix_;
 	///
@@ -1759,6 +1931,9 @@ private:
 };
 
 
+QString const DisplayPath::ellipsisSlash_ = QString(QChar(0x2026)) + "/";
+
+
 ///
 bool operator<(DisplayPath const & a, DisplayPath const & b)
 {
@@ -1834,6 +2009,8 @@ void TabWorkArea::updateTabTexts()
 			// that it makes the path more unique.
 			somethingChanged = true;
 			It sit = segStart;
+			// this is ok for the reason mentioned  in the previous comment.
+			// coverity[INVALIDATE_ITERATOR]
 			QString dspString = sit->forecastPathString();
 			LYXERR(Debug::GUI, "first forecast found for "
 			       << sit->abs() << " => " << dspString);
@@ -1867,12 +2044,19 @@ void TabWorkArea::updateTabTexts()
 
 	// set new tab titles
 	for (It it = paths.begin(); it != paths.end(); ++it) {
-		GuiWorkArea * i_wa = workArea(it->tab());
-		Buffer & buf = i_wa->bufferView().buffer();
+		int const tab_index = it->tab();
+		Buffer const & buf = workArea(tab_index)->bufferView().buffer();
+		QString tab_text = it->displayString().replace("&", "&&");
 		if (!buf.fileName().empty() && !buf.isClean())
-			setTabText(it->tab(), it->displayString() + "*");
-		else
-			setTabText(it->tab(), it->displayString());
+			tab_text += "*";
+		QString tab_tooltip = it->abs();
+		if (buf.isReadonly()) {
+			setTabIcon(tab_index, QIcon(getPixmap("images/", "emblem-readonly", "svgz,png")));
+			tab_tooltip = qt_("%1 (read only)").arg(it->abs());
+		} else
+			setTabIcon(tab_index, QIcon());
+		setTabText(tab_index, tab_text);
+		setTabToolTip(tab_index, tab_tooltip);
 	}
 }
 
@@ -1886,9 +2070,9 @@ void TabWorkArea::showContextMenu(const QPoint & pos)
 
 	// show tab popup
 	QMenu popup;
-	popup.addAction(QIcon(getPixmap("images/", "hidetab", "png")),
+	popup.addAction(QIcon(getPixmap("images/", "hidetab", "svgz,png")),
 		qt_("Hide tab"), this, SLOT(hideCurrentTab()));
-	popup.addAction(QIcon(getPixmap("images/", "closetab", "png")),
+	popup.addAction(QIcon(getPixmap("images/", "closetab", "svgz,png")),
 		qt_("Close tab"), this, SLOT(closeCurrentBuffer()));
 	popup.exec(tabBar()->mapToGlobal(pos));
 
@@ -1913,25 +2097,10 @@ DragTabBar::DragTabBar(QWidget* parent)
 	: QTabBar(parent)
 {
 	setAcceptDrops(true);
-#if QT_VERSION >= 0x040500
 	setTabsClosable(!lyxrc.single_close_tab_button);
-#endif
 }
 
 
-#if QT_VERSION < 0x040300
-int DragTabBar::tabAt(QPoint const & position) const
-{
-	const int max = count();
-	for (int i = 0; i < max; ++i) {
-		if (tabRect(i).contains(position))
-			return i;
-	}
-	return -1;
-}
-#endif
-
-
 void DragTabBar::mousePressEvent(QMouseEvent * event)
 {
 	if (event->button() == Qt::LeftButton)
@@ -1970,17 +2139,12 @@ void DragTabBar::mouseMoveEvent(QMouseEvent * event)
 	mimeData->setData("action", "tab-reordering") ;
 	drag->setMimeData(mimeData);
 
-#if QT_VERSION >= 0x040300
 	// get tab pixmap as cursor
 	QRect r = tabRect(tab);
 	QPixmap pixmap(r.size());
 	render(&pixmap, - r.topLeft());
 	drag->setPixmap(pixmap);
 	drag->exec();
-#else
-	drag->start(Qt::MoveAction);
-#endif
-
 }