#include "ColorCache.h"
#include "FontLoader.h"
+#include "GuiApplication.h"
+#include "GuiCompleter.h"
+#include "GuiKeySymbol.h"
+#include "GuiPainter.h"
+#include "GuiView.h"
#include "Menus.h"
#include "Buffer.h"
#include "Cursor.h"
#include "Font.h"
#include "FuncRequest.h"
-#include "GuiApplication.h"
-#include "GuiCompleter.h"
-#include "GuiKeySymbol.h"
-#include "GuiPainter.h"
-#include "GuiView.h"
#include "KeySymbol.h"
#include "Language.h"
#include "LyX.h"
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::Private::Private(GuiWorkArea * parent)
-: p(parent), screen_(0), buffer_view_(0), lyx_view_(0),
+: p(parent), 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)
+ 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))
+: d(new Private(this))
{
}
d->cursor_timeout_.setInterval(500);
}
- 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.
d->buffer_view_->resize(viewport()->width(), viewport()->height());
setFrameStyle(QFrame::NoFrame);
updateWindowTitle();
- viewport()->setAutoFillBackground(false);
+ //viewport()->setAutoFillBackground(false);
// We don't need double-buffering nor SystemBackground on
// the viewport because we have our own backing pixmap.
- viewport()->setAttribute(Qt::WA_NoSystemBackground);
+ //viewport()->setAttribute(Qt::WA_NoSystemBackground);
+ viewport()->setAttribute(Qt::WA_OpaquePaintEvent);
setFocusPolicy(Qt::StrongFocus);
d->setCursorShape(Qt::IBeamCursor);
- d->synthetic_mouse_event_.timeout.timeout.connect(
- bind(&GuiWorkArea::generateSyntheticMouseEvent,
- this));
-
- // 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());
GuiWorkArea::~GuiWorkArea()
{
- d->buffer_view_->buffer().workAreaManager().remove(this);
- delete d->screen_;
+ // If something is wrong with the buffer, we can ignore it safely
+ try {
+ d->buffer_view_->buffer().workAreaManager().remove(this);
+ } catch(...) {}
delete d->buffer_view_;
delete d->cursor_;
// Completer has a QObject parent and is thus automatically destroyed.
void GuiWorkArea::Private::updateCursorShape()
{
- setCursorShape(buffer_view_->clickableInset()
+ setCursorShape(buffer_view_->clickableInset()
? Qt::PointingHandCursor : Qt::IBeamCursor);
}
}
LYXERR(Debug::WORKAREA, "WorkArea::redraw screen");
- d->updateScreen();
- update(0, 0, viewport()->width(), viewport()->height());
+ viewport()->update();
/// \warning: scrollbar updating *must* be done after the BufferView is drawn
/// because \c BufferView::updateScrollbar() is called in \c BufferView::draw().
buffer_view_->resize(p->viewport()->width(), p->viewport()->height());
if (cursor_in_view)
buffer_view_->scrollToCursor();
- updateScreen();
+ p->viewport()->update();
// Update scrollbars which might have changed due different
// BufferView dimension. This is especially important when the
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();
- // 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);
+ // Connect to the vertical scroll bar
+ QObject::connect(p->verticalScrollBar(), SIGNAL(valueChanged(int)),
+ p, SLOT(scrollTo(int)));
}
}
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
bool const keyboard = (e->reason() == QContextMenuEvent::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.
// in the first place.
return;
}
-
+
d->synthetic_mouse_event_.restart_timeout = true;
d->synthetic_mouse_event_.timeout.start();
// Fall through to handle this event...
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;
// In which paragraph do we have to set the cursor ?
Cursor & cur = d->buffer_view_->cursor();
- // FIXME: we don't know howto handle math.
+ // FIXME: we don't know how to handle math.
Text * text = cur.text();
if (!text)
return;
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 *> pp = up ? tm.first() : tm.last();
ParagraphMetrics const & pm = *pp.second;
pit_type const pit = pp.first;
}
-void GuiWorkArea::Private::update(int x, int y, int w, int h)
-{
- p->viewport()->update(x, y, w, h);
-}
-
-
void GuiWorkArea::paintEvent(QPaintEvent * ev)
{
- QRectF const rc = ev->rect();
// LYXERR(Debug::PAINTING, "paintEvent begin: x: " << rc.x()
// << " y: " << rc.y() << " w: " << rc.width() << " h: " << rc.height());
if (d->needResize()) {
- d->resetScreen();
d->resizeBufferView();
if (d->cursor_visible_) {
d->hideCursor();
}
}
- QPainter pain(viewport());
- double const pr = pixelRatio();
- QRectF const rcs = QRectF(rc.x() * pr, rc.y() * pr, rc.width() * pr, rc.height() * pr);
+ GuiPainter pain(viewport(), pixelRatio());
+ d->buffer_view_->draw(pain);
- 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::Private::updateScreen()
-{
- GuiPainter pain(screen_, p->pixelRatio());
- buffer_view_->draw(pain);
-}
-
-
void GuiWorkArea::Private::showCursor(int x, int y, int h,
bool l_shape, bool rtl, bool completable)
{
// We can't use redraw() here because this would trigger a infinite
// recursive loop with showCursor().
buffer_view_->resize(p->viewport()->width(), p->viewport()->height());
- updateScreen();
+ p->viewport()->update();
updateScrollbar();
- p->viewport()->update(QRect(0, 0, p->viewport()->width(), p->viewport()->height()));
schedule_redraw_ = false;
// Show the cursor immediately after the update.
hideCursor();
void GuiWorkArea::inputMethodEvent(QInputMethodEvent * e)
{
+//FIXME Broken Feature !!
+// I do not think that we are supposed to paint inside this event. Shall we
+// just let TextMetrics::breakRow add this to the relevant Row object?
+#if 0
QString const & commit_string = e->commitString();
docstring const & preedit_string
= qstring_to_ucs4(e->preeditString());
return;
}
- GuiPainter pain(d->screen_, pixelRatio());
d->buffer_view_->updateMetrics();
- d->buffer_view_->draw(pain);
+ viewport()->update();
// FIXME: shall we use real_current_font here? (see #10478)
FontInfo font = d->buffer_view_->cursor().getFont().fontInfo();
FontMetrics const & fm = theFontMetrics(font);
int cur_y = d->cursor_->rect().bottom();
// redraw area of preedit string.
- update(0, cur_y - height, viewport()->width(),
+ viewport()->update(0, cur_y - height, viewport()->width(),
(height + 1) * d->preedit_lines_);
if (preedit_string.empty()) {
ps = Painter::preedit_cursor;
// draw one character and update cur_x.
+ GuiPainter pain(d->screen_, pixelRatio());
cur_x += pain.preeditText(cur_x, cur_y, typed_char, font, ps);
}
// update the preedit string screen area.
- update(0, cur_y - d->preedit_lines_*height, viewport()->width(),
+ viewport()->update(0, cur_y - d->preedit_lines_*height, viewport()->width(),
(height + 1) * d->preedit_lines_);
+#endif
// Don't forget to accept the event!
e->accept();
void GuiWorkArea::updateWindowTitle()
{
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_) {
+ 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->read_only_ = buf.isReadonly();
+ 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);
}
}
if (tabBar()->isVisible()) {
QTabWidget::paintEvent(event);
} else {
- // Prevent the selected tab to influence the
+ // 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);
}
-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());
- LATTEST(wa);
- return wa;
+
+GuiWorkAreaContainer * TabWorkArea::currentWidget() const
+{
+ return widget(currentIndex());
+}
+
+
+GuiWorkArea * TabWorkArea::workArea(int index) const
+{
+ GuiWorkAreaContainer * w = widget(index);
+ if (!w)
+ return nullptr;
+ return w->workArea();
}
-GuiWorkArea * TabWorkArea::workArea(int index)
+GuiWorkArea * TabWorkArea::currentWorkArea() const
{
- return dynamic_cast<GuiWorkArea *>(widget(index));
+ return workArea(currentIndex());
}
-GuiWorkArea * TabWorkArea::workArea(Buffer & buffer)
+GuiWorkArea * TabWorkArea::workArea(Buffer & buffer) const
{
- // FIXME: this method doesn't work if we have more than work area
+ // 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, return);
+ 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, return false);
- int index = indexOf(work_area);
+ 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.
class DisplayPath {
public:
/// make vector happy
- // coverity[UNINIT_CTOR]
- DisplayPath() {}
+ DisplayPath() : tab_(-1), dottedPrefix_(false) {}
///
DisplayPath(int tab, FileName const & filename)
: tab_(tab)
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;
- // 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);
- ++sit;
bool moreUnique = false;
for (; sit != next; ++sit) {
if (sit->forecastPathString() != dspString) {
if (!buf.fileName().empty() && !buf.isClean())
tab_text += "*";
QString tab_tooltip = it->abs();
- if (buf.isReadonly()) {
+ if (buf.hasReadonlyFlag()) {
setTabIcon(tab_index, QIcon(getPixmap("images/", "emblem-readonly", "svgz,png")));
- tab_tooltip = qt_("%1 (read only)").arg(it->abs());
+ 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, tab_tooltip);
}
}
+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