#include <config.h>
#include "GuiWorkArea.h"
+#include "GuiWorkArea_Private.h"
#include "ColorCache.h"
#include "FontLoader.h"
#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>
#include "support/bind.h"
#include <cmath>
+#include <iostream>
int const TabIndicatorWidth = 3;
class CursorWidget {
public:
- CursorWidget() {
+ CursorWidget() : rtl_(false), l_shape_(false), completable_(false),
+ show_(false), x_(0), cursor_width_(0)
+ {
recomputeWidth();
}
int cursorWidth() const { return cursor_width_; }
void recomputeWidth() {
cursor_width_ = lyxrc.cursor_width
- ? lyxrc.cursor_width
- : 1 + int((lyxrc.zoom + 50) / 200.0);
+ ? lyxrc.cursor_width
+ : 1 + int((lyxrc.currentZoom + 50) / 200.0);
}
QRect const & rect() { return rect_; }
QRect rect_;
/// x position (were the vertical line is drawn)
int x_;
-
+
int cursor_width_;
};
{}
-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))
+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), shell_escape_(false),
+ read_only_(false), clean_(true), externally_modified_(false)
+{
+}
+
+
+GuiWorkArea::GuiWorkArea(QWidget * /* w */)
+: d(new Private(this))
{
+ new CompressorProxy(this); // not a leak
}
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))
+: d(new Private(this))
{
+ new CompressorProxy(this); // not a leak
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);
setFocusPolicy(Qt::StrongFocus);
- setCursorShape(Qt::IBeamCursor);
-
- synthetic_mouse_event_.timeout.timeout.connect(
- bind(&GuiWorkArea::generateSyntheticMouseEvent,
- this));
+ d->setCursorShape(Qt::IBeamCursor);
- // Initialize the vertical Scroll Bar
- QObject::connect(verticalScrollBar(), SIGNAL(valueChanged(int)),
- this, SLOT(scrollTo(int)));
+ // This connection is closed at the same time as this is destroyed.
+ d->synthetic_mouse_event_.timeout.timeout.connect([this](){
+ generateSyntheticMouseEvent();
+ });
LYXERR(Debug::GUI, "viewport width: " << viewport()->width()
<< " viewport height: " << viewport()->height());
// 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_;
+ // If something is wrong with the buffer, we can ignore it safely
+ try {
+ d->buffer_view_->buffer().workAreaManager().remove(this);
+ } catch(...) {}
+ 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;
}
}
-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()
+ setCursorShape(buffer_view_->clickableInset()
? Qt::PointingHandCursor : Qt::IBeamCursor);
}
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
if (buffer.text().paragraphs().size() > 4)
setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
QTimer::singleShot(50, this, SLOT(fixVerticalScrollBar()));
+ Q_EMIT bufferViewChanged();
}
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);
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();
}
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();
}
// 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,
}
-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();
// 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();
// 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;
&& !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;
void GuiWorkArea::toggleCursor()
{
- if (cursor_visible_)
- hideCursor();
+ if (d->cursor_visible_)
+ d->hideCursor();
else
- showCursor();
+ d->showCursor();
}
-void GuiWorkArea::updateScrollbar()
+void GuiWorkArea::Private::updateScrollbar()
{
+ // Prevent setRange() and setSliderPosition from causing recursive calls via
+ // the signal valueChanged. (#10311)
+ QObject::disconnect(p->verticalScrollBar(), SIGNAL(valueChanged(int)),
+ p, SLOT(scrollTo(int)));
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);
+ p->verticalScrollBar()->setRange(scroll_.min, scroll_.max);
+ p->verticalScrollBar()->setPageStep(scroll_.page_step);
+ p->verticalScrollBar()->setSingleStep(scroll_.single_step);
+ p->verticalScrollBar()->setSliderPosition(0);
+ // Connect to the vertical scroll bar
+ QObject::connect(p->verticalScrollBar(), SIGNAL(valueChanged(int)),
+ p, SLOT(scrollTo(int)));
}
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
}
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();
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.
void GuiWorkArea::contextMenuEvent(QContextMenuEvent * e)
{
- docstring name;
+ string name;
if (e->reason() == QContextMenuEvent::Mouse)
// the menu name is set on mouse press
- name = context_menu_name_;
+ name = d->context_menu_name_;
else {
QPoint pos = e->pos();
- Cursor const & cur = buffer_view_->cursor();
+ 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.
++pos.rx();
}
}
- name = buffer_view_->contextMenu(pos.x(), pos.y());
+ name = d->buffer_view_->contextMenu(pos.x(), pos.y());
}
-
+
if (name.empty()) {
- QAbstractScrollArea::contextMenuEvent(e);
+ e->accept();
return;
}
// 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), *lyx_view_, keyboard);
+ QMenu * menu = guiApp->menus().menu(toqstr(name), *d->lyx_view_, keyboard);
if (!menu) {
- QAbstractScrollArea::contextMenuEvent(e);
+ e->accept();
return;
}
// Position the menu to the right.
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);
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 (QT_VERSION < 0x050000) && !defined(__HAIKU__)
+ inputContext()->reset();
+#endif
+
+ FuncRequest const cmd(LFUN_MOUSE_PRESS, e->x(), e->y(),
+ 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.
+ // 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)
- context_menu_name_ = buffer_view_->contextMenu(e->x(), e->y());
-
- inputContext()->reset();
+ d->context_menu_name_ = d->buffer_view_->contextMenu(e->x(), e->y());
- FuncRequest const cmd(LFUN_MOUSE_PRESS, e->x(), e->y(),
- q_button_state(e->button()));
- dispatch(cmd, q_key_state(e->modifiers()));
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();
}
// 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();
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.
// in the first place.
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);
}
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);
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;
if (up || down) {
int dist = up ? -e_y : e_y - wh;
time = max(min(200, 250000 / (dist * dist)), 1) ;
-
+
if (time < 40) {
step = 80000 / (time * time);
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();
- // FIXME: we don't know howto handle math.
+ Cursor & cur = d->buffer_view_->cursor();
+ // FIXME: we don't know how to handle math.
Text * text = cur.text();
if (!text)
return;
- TextMetrics const & tm = buffer_view_->textMetrics(text);
+ TextMetrics const & tm = d->buffer_view_->textMetrics(text);
+
+ // Quit gracefully if there are no metrics, since otherwise next
+ // line would crash (bug #10324).
+ // This situation seems related to a (not yet understood) timing problem.
+ if (tm.empty())
+ return;
- 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;
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;
}
+// CompressorProxy adapted from Kuba Ober https://stackoverflow.com/a/21006207
+CompressorProxy::CompressorProxy(GuiWorkArea * wa) : QObject(wa), flag_(false)
+{
+ qRegisterMetaType<KeySymbol>("KeySymbol");
+ qRegisterMetaType<KeyModifier>("KeyModifier");
+ connect(wa, SIGNAL(compressKeySym(KeySymbol, KeyModifier, bool)),
+ this, SLOT(slot(KeySymbol, KeyModifier, bool)),
+ Qt::QueuedConnection);
+ connect(this, SIGNAL(signal(KeySymbol, KeyModifier)),
+ wa, SLOT(processKeySym(KeySymbol, KeyModifier)));
+}
+
+
+bool CompressorProxy::emitCheck(bool isAutoRepeat)
+{
+ flag_ = true;
+ if (isAutoRepeat)
+ QCoreApplication::sendPostedEvents(this, QEvent::MetaCall); // recurse
+ bool result = flag_;
+ flag_ = false;
+ return result;
+}
+
+
+void CompressorProxy::slot(KeySymbol sym, KeyModifier mod, bool isAutoRepeat)
+{
+ if (emitCheck(isAutoRepeat))
+ Q_EMIT signal(sym, mod);
+ else
+ LYXERR(Debug::KEY, "system is busy: autoRepeat key event ignored");
+}
+
+
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_
+ bool const for_dialog_mode = d->dialog_mode_
&& (ev->modifiers() == Qt::NoModifier
|| ev->modifiers() == Qt::ShiftModifier)
&& (ev->key() == Qt::Key_Escape
|| ev->key() == Qt::Key_Enter
- || ev->key() == Qt::Key_Return)
- ) {
+ || ev->key() == Qt::Key_Return);
+ // also do not use autoRepeat to input shortcuts
+ bool const autoRepeat = ev->isAutoRepeat();
+
+ if (for_dialog_mode || (!act && autoRepeat)) {
ev->ignore();
return;
}
// 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;
}
}
- // 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;
+ KeyModifier const m = q_key_state(ev->modifiers());
+
+ if (act && lyxerr.debugging(Debug::KEY)) {
+ std::string str;
+ if (m & ShiftModifier)
+ str += "Shift-";
+ if (m & ControlModifier)
+ str += "Control-";
+ if (m & AltModifier)
+ str += "Alt-";
+ if (m & MetaModifier)
+ str += "Meta-";
+ LYXERR(Debug::KEY, " count: " << ev->count() << " text: " << ev->text()
+ << " isAutoRepeat: " << ev->isAutoRepeat() << " key: " << ev->key()
+ << " keyState: " << str);
}
-#endif
-
- KeyModifier 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-";
-
- 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) {
+ Q_EMIT compressKeySym(sym, m, autoRepeat);
+ ev->accept();
+ } else
+ // here, !autoRepeat, as determined at the beginning
+ ev->setAccepted(queryKeySym(sym, m));
} else {
ev->ignore();
}
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();
}
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_) {
// 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());
}
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.
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;
}
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
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
}
// 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();
// 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:
void GuiWorkArea::updateWindowTitle()
{
- docstring maximize_title;
- docstring minimize_title;
-
- Buffer const & buf = buffer_view_->buffer();
- FileName const file_name = buf.fileName();
- if (!file_name.empty()) {
- maximize_title = file_name.displayName(130);
- minimize_title = from_utf8(file_name.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.params().shell_escape != d->shell_escape_
+ || buf.hasReadonlyFlag() != d->read_only_
+ || buf.lyxvc().vcstatus() != d->vc_status_
+ || buf.isClean() != d->clean_
+ || buf.notifiesExternalModification() != d->externally_modified_) {
+ d->file_name_ = buf.fileName();
+ d->shell_escape_ = buf.params().shell_escape;
+ d->read_only_ = buf.hasReadonlyFlag();
+ d->vc_status_ = buf.lyxvc().vcstatus();
+ d->clean_ = buf.isClean();
+ d->externally_modified_ = buf.notifiesExternalModification();
+ Q_EMIT titleChanged(this);
}
+}
- QString const new_title = toqstr(maximize_title);
- if (new_title != windowTitle()) {
- 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::inDialogMode() const
+{
+ return d->dialog_mode_;
}
-bool GuiWorkArea::isFullScreen()
+void GuiWorkArea::setDialogMode(bool mode)
{
- return lyx_view_ && lyx_view_->isFullScreen();
+ 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
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_);
//
////////////////////////////////////////////////////////////////////
-#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
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,
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);
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));
}
if (lyxrc.full_screen_tabbar)
showBar(!full_screen && count() > 1);
+ else
+ showBar(count() > 1);
}
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
}
-GuiWorkArea * TabWorkArea::currentWorkArea()
+GuiWorkAreaContainer * TabWorkArea::widget(int index) const
{
- if (count() == 0)
- return 0;
+ QWidget * w = QTabWidget::widget(index);
+ if (!w)
+ return nullptr;
+ GuiWorkAreaContainer * wac = dynamic_cast<GuiWorkAreaContainer *>(w);
+ LATTEST(wac);
+ return wac;
+}
- GuiWorkArea * wa = dynamic_cast<GuiWorkArea *>(currentWidget());
- LASSERT(wa, /**/);
- return wa;
+
+GuiWorkAreaContainer * TabWorkArea::currentWidget() const
+{
+ return widget(currentIndex());
}
-GuiWorkArea * TabWorkArea::workArea(int index)
+GuiWorkArea * TabWorkArea::workArea(int index) const
{
- return dynamic_cast<GuiWorkArea *>(widget(index));
+ GuiWorkAreaContainer * w = widget(index);
+ if (!w)
+ return nullptr;
+ return w->workArea();
}
-GuiWorkArea * TabWorkArea::workArea(Buffer & buffer)
+GuiWorkArea * TabWorkArea::currentWorkArea() const
{
- // FIXME: this method doesn't work if we have more than work area
+ return workArea(currentIndex());
+}
+
+
+GuiWorkArea * TabWorkArea::workArea(Buffer & buffer) const
+{
+ // FIXME: this method doesn't work if we have more than one work area
// showing the same buffer.
for (int i = 0; i != count(); ++i) {
GuiWorkArea * wa = workArea(i);
void TabWorkArea::closeAll()
{
while (count()) {
- GuiWorkArea * wa = workArea(0);
- LASSERT(wa, /**/);
+ QWidget * wac = widget(0);
+ LASSERT(wac, return);
removeTab(0);
- delete wa;
+ delete wac;
}
}
+int TabWorkArea::indexOfWorkArea(GuiWorkArea * w) const
+{
+ for (int index = 0; index < count(); ++index)
+ if (workArea(index) == w)
+ return index;
+ return -1;
+}
+
+
bool TabWorkArea::setCurrentWorkArea(GuiWorkArea * work_area)
{
- LASSERT(work_area, /**/);
- int index = indexOf(work_area);
+ LASSERT(work_area, return false);
+ int index = indexOfWorkArea(work_area);
if (index == -1)
return false;
GuiWorkArea * TabWorkArea::addWorkArea(Buffer & buffer, GuiView & view)
{
GuiWorkArea * wa = new GuiWorkArea(buffer, view);
+ GuiWorkAreaContainer * wac = new GuiWorkAreaContainer(wa);
wa->setUpdatesEnabled(false);
// Hide tabbar if there's no tab (avoid a resize and a flashing tabbar
// when hiding it again below).
if (!(currentWorkArea() && currentWorkArea()->isFullScreen()))
showBar(count() > 0);
- addTab(wa, wa->windowTitle());
+ addTab(wac, wa->windowTitle());
QObject::connect(wa, SIGNAL(titleChanged(GuiWorkArea *)),
this, SLOT(updateTabTexts()));
if (currentWorkArea() && currentWorkArea()->isFullScreen())
bool TabWorkArea::removeWorkArea(GuiWorkArea * work_area)
{
LASSERT(work_area, return false);
- int index = indexOf(work_area);
+ int index = indexOfWorkArea(work_area);
if (index == -1)
return false;
work_area->setUpdatesEnabled(false);
+ QWidget * wac = widget(index);
removeTab(index);
- delete work_area;
+ delete wac;
if (count()) {
// make sure the next work area is enabled.
wa = currentWorkArea();
else {
wa = workArea(clicked_tab_);
- LASSERT(wa, /**/);
+ LASSERT(wa, return);
}
wa->view().closeWorkArea(wa);
}
wa = currentWorkArea();
else {
wa = workArea(clicked_tab_);
- LASSERT(wa, /**/);
+ LASSERT(wa, return);
}
wa->view().hideWorkArea(wa);
}
wa = currentWorkArea();
else {
wa = workArea(index);
- LASSERT(wa, /**/);
+ LASSERT(wa, return);
}
wa->view().closeWorkArea(wa);
}
class DisplayPath {
public:
/// make vector happy
- DisplayPath() {}
+ DisplayPath() : tab_(-1), dottedPrefix_(false) {}
///
DisplayPath(int tab, FileName const & filename)
: tab_(tab)
if (!dotted) {
if (dottedPrefix_ && !prefix_.isEmpty())
- prefix_ += ".../";
+ prefix_ += ellipsisSlash_;
prefix_ += postfix_.front() + "/";
}
dottedPrefix_ = dotted && !prefix_.isEmpty();
return filename_;
bool dots = dottedPrefix_ || !postfix_.isEmpty();
- return prefix_ + (dots ? ".../" : "") + filename_;
+ return prefix_ + (dots ? ellipsisSlash_ : "") + filename_;
}
///
QString forecastPathString() const
return displayString();
return prefix_
- + (dottedPrefix_ ? ".../" : "")
+ + (dottedPrefix_ ? ellipsisSlash_ : "")
+ postfix_.front() + "/";
}
///
int tab() const { return tab_; }
private:
+ /// ".../"
+ static QString const ellipsisSlash_;
///
QString prefix_;
///
};
+QString const DisplayPath::ellipsisSlash_ = QString(QChar(0x2026)) + "/";
+
+
///
bool operator<(DisplayPath const & a, DisplayPath const & b)
{
continue;
}
- // we found a non-atomic segment segStart <= sit <= it < next.
+ // We found a non-atomic segment
+ // We know that segStart <= it < next <= paths.end().
+ // The assertion below tells coverity about it.
+ LATTEST(segStart != paths.end());
+ QString dspString = segStart->forecastPathString();
+ LYXERR(Debug::GUI, "first forecast found for "
+ << segStart->abs() << " => " << dspString);
+ It sit = segStart;
+ ++sit;
// Shift path segments and hope for the best
// that it makes the path more unique.
somethingChanged = true;
- It sit = segStart;
- QString dspString = sit->forecastPathString();
- LYXERR(Debug::GUI, "first forecast found for "
- << sit->abs() << " => " << dspString);
- ++sit;
bool moreUnique = false;
for (; sit != next; ++sit) {
if (sit->forecastPathString() != dspString) {
for (It it = paths.begin(); it != paths.end(); ++it) {
int const tab_index = it->tab();
Buffer const & buf = workArea(tab_index)->bufferView().buffer();
- QString tab_text = it->displayString();
+ QString tab_text = it->displayString().replace("&", "&&");
if (!buf.fileName().empty() && !buf.isClean())
tab_text += "*";
+ QString tab_tooltip = it->abs();
+ if (buf.hasReadonlyFlag()) {
+ setTabIcon(tab_index, QIcon(getPixmap("images/", "emblem-readonly", "svgz,png")));
+ tab_tooltip = qt_("%1 (read only)").arg(tab_tooltip);
+ } else
+ setTabIcon(tab_index, QIcon());
+ if (buf.notifiesExternalModification()) {
+ QString const warn = qt_("%1 (modified externally)");
+ tab_tooltip = warn.arg(tab_tooltip);
+ tab_text += QChar(0x26a0);
+ }
setTabText(tab_index, tab_text);
- setTabToolTip(tab_index, it->abs());
+ setTabToolTip(tab_index, tab_tooltip);
}
}
// 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));
: 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)
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
-
}
}
+GuiWorkAreaContainer::GuiWorkAreaContainer(GuiWorkArea * wa, QWidget * parent)
+ : QWidget(parent), wa_(wa)
+{
+ LASSERT(wa, return);
+ Ui::WorkAreaUi::setupUi(this);
+ layout()->addWidget(wa);
+ connect(wa, SIGNAL(titleChanged(GuiWorkArea *)),
+ this, SLOT(updateDisplay()));
+ connect(reloadPB, SIGNAL(clicked()), this, SLOT(reload()));
+ connect(ignorePB, SIGNAL(clicked()), this, SLOT(ignore()));
+ setMessageColour({notificationFrame}, {reloadPB, ignorePB});
+ updateDisplay();
+}
+
+
+void GuiWorkAreaContainer::updateDisplay()
+{
+ Buffer const & buf = wa_->bufferView().buffer();
+ notificationFrame->setHidden(!buf.notifiesExternalModification());
+ QString const label = qt_("<b>The file %1 changed on disk.</b>")
+ .arg(toqstr(buf.fileName().displayName()));
+ externalModificationLabel->setText(label);
+}
+
+
+void GuiWorkAreaContainer::dispatch(FuncRequest f) const
+{
+ lyx::dispatch(FuncRequest(LFUN_BUFFER_SWITCH,
+ wa_->bufferView().buffer().absFileName()));
+ lyx::dispatch(f);
+}
+
+
+void GuiWorkAreaContainer::reload() const
+{
+ dispatch(FuncRequest(LFUN_BUFFER_RELOAD));
+}
+
+
+void GuiWorkAreaContainer::ignore() const
+{
+ dispatch(FuncRequest(LFUN_BUFFER_EXTERNAL_MODIFICATION_CLEAR));
+}
+
+
+void GuiWorkAreaContainer::mouseDoubleClickEvent(QMouseEvent * event)
+{
+ // prevent TabWorkArea from opening a new buffer on double click
+ event->accept();
+}
+
+
} // namespace frontend
} // namespace lyx
projects / lyx.git / blobdiff