X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ffrontends%2Fqt4%2FGuiWorkArea.cpp;h=ef79b02fe3e1c7b0f76ef3e8b53cbf8866bbe2af;hb=8b7584846c4e1a9c87a004fab479722fee7e3013;hp=0b6659a77c5c9bad4ee1ca9ec1399660d82d2faa;hpb=ab5a4d4f0f2a25a3e9c3c4fa883f53f3ea3602d4;p=lyx.git diff --git a/src/frontends/qt4/GuiWorkArea.cpp b/src/frontends/qt4/GuiWorkArea.cpp index 0b6659a77c..ef79b02fe3 100644 --- a/src/frontends/qt4/GuiWorkArea.cpp +++ b/src/frontends/qt4/GuiWorkArea.cpp @@ -18,6 +18,7 @@ #include "Menus.h" #include "Buffer.h" +#include "BufferList.h" #include "BufferParams.h" #include "BufferView.h" #include "CoordCache.h" @@ -31,16 +32,18 @@ #include "GuiView.h" #include "KeySymbol.h" #include "Language.h" -#include "LyXFunc.h" +#include "LyX.h" #include "LyXRC.h" -#include "MetricsInfo.h" +#include "LyXVC.h" #include "qt_helpers.h" #include "Text.h" +#include "TextMetrics.h" #include "version.h" #include "graphics/GraphicsImage.h" #include "graphics/GraphicsLoader.h" +#include "support/convert.h" #include "support/debug.h" #include "support/gettext.h" #include "support/FileName.h" @@ -66,15 +69,10 @@ #include #include -#include +#include "support/bind.h" #include -#ifdef Q_WS_X11 -#include -extern "C" int XEventsQueued(Display *display, int mode); -#endif - #ifdef Q_WS_WIN int const CursorWidth = 2; #else @@ -83,7 +81,7 @@ int const CursorWidth = 1; int const TabIndicatorWidth = 3; #undef KeyPress -#undef NoModifier +#undef NoModifier using namespace std; using namespace lyx::support; @@ -136,7 +134,7 @@ public: { if (!show_ || !rect_.isValid()) return; - + int y = rect_.top(); int l = x_ - rect_.left(); int r = rect_.right() - x_; @@ -144,7 +142,7 @@ public: // draw vertica linel painter.fillRect(x_, y, CursorWidth, rect_.height(), color_); - + // draw RTL/LTR indication painter.setPen(color_); if (l_shape_) { @@ -153,7 +151,7 @@ public: else painter.drawLine(x_, bot, x_ + CursorWidth + r, bot); } - + // draw completion triangle if (completable_) { int m = y + rect_.height() / 2; @@ -176,7 +174,7 @@ public: rtl_ = rtl; completable_ = completable; x_ = x; - + // extension to left and right int l = 0; int r = 0; @@ -188,7 +186,7 @@ public: else r += h / 3; } - + // completion triangle if (completable_) { if (rtl) @@ -227,23 +225,39 @@ private: // This is a 'heartbeat' generating synthetic mouse move events when the // cursor is at the top or bottom edge of the viewport. One scroll per 0.2 s SyntheticMouseEvent::SyntheticMouseEvent() - : timeout(200), restart_timeout(true), - x_old(-1), y_old(-1), scrollbar_value_old(-1.0) + : timeout(200), restart_timeout(true) {} +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::GuiWorkArea(Buffer & buffer, GuiView & lv) - : buffer_view_(new BufferView(buffer)), lyx_view_(&lv), +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)) + preedit_lines_(1), completer_(new GuiCompleter(this, this)), + context_target_pos_() +{ + setGuiView(gv); + setBuffer(buffer); + init(); +} + + +void GuiWorkArea::init() { - buffer.workAreaManager().add(this); // Setup the signals connect(&cursor_timeout_, SIGNAL(timeout()), this, SLOT(toggleCursor())); - + int const time = QApplication::cursorFlashTime() / 2; if (time > 0) { cursor_timeout_.setInterval(time); @@ -254,29 +268,17 @@ GuiWorkArea::GuiWorkArea(Buffer & buffer, GuiView & lv) } screen_ = QPixmap(viewport()->width(), viewport()->height()); + // 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(); - // HACK: Prevents an additional redraw when the scrollbar pops up - // which regularily happens on documents with more than one page. - // The policy should be set to "Qt::ScrollBarAsNeeded" soon. - // Since we have no geometry information yet, we assume that - // a document needs a scrollbar if there is more then four - // paragraph in the outermost text. - if (buffer.text().paragraphs().size() > 4) - setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn); - QTimer::singleShot(50, this, SLOT(fixVerticalScrollBar())); - - setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); setAcceptDrops(true); setMouseTracking(true); setMinimumSize(100, 70); -#ifdef Q_WS_MACX - setFrameStyle(QFrame::NoFrame); -#else - setFrameStyle(QFrame::Box); -#endif + setFrameStyle(QFrame::NoFrame); updateWindowTitle(); viewport()->setAutoFillBackground(false); @@ -284,12 +286,12 @@ GuiWorkArea::GuiWorkArea(Buffer & buffer, GuiView & lv) // the viewport because we have our own backing pixmap. viewport()->setAttribute(Qt::WA_NoSystemBackground); - setFocusPolicy(Qt::WheelFocus); + setFocusPolicy(Qt::StrongFocus); - viewport()->setCursor(Qt::IBeamCursor); + setCursorShape(Qt::IBeamCursor); synthetic_mouse_event_.timeout.timeout.connect( - boost::bind(&GuiWorkArea::generateSyntheticMouseEvent, + bind(&GuiWorkArea::generateSyntheticMouseEvent, this)); // Initialize the vertical Scroll Bar @@ -302,6 +304,8 @@ GuiWorkArea::GuiWorkArea(Buffer & buffer, GuiView & lv) // Enables input methods for asian languages. // Must be set when creating custom text editing widgets. setAttribute(Qt::WA_InputMethodEnabled, true); + + dialog_mode_ = false; } @@ -310,6 +314,52 @@ GuiWorkArea::~GuiWorkArea() buffer_view_->buffer().workAreaManager().remove(this); delete buffer_view_; delete cursor_; + // Completer has a QObject parent and is thus automatically destroyed. + // See #4758. + // delete completer_; +} + + +Qt::CursorShape GuiWorkArea::cursorShape() const +{ + return viewport()->cursor().shape(); +} + + +void GuiWorkArea::setCursorShape(Qt::CursorShape shape) +{ + viewport()->setCursor(shape); +} + + +void GuiWorkArea::updateCursorShape() +{ + setCursorShape(buffer_view_->clickableInset() + ? Qt::PointingHandCursor : Qt::IBeamCursor); +} + + +void GuiWorkArea::setGuiView(GuiView & gv) +{ + lyx_view_ = &gv; +} + + +void GuiWorkArea::setBuffer(Buffer & buffer) +{ + delete buffer_view_; + buffer_view_ = new BufferView(buffer); + buffer.workAreaManager().add(this); + + // HACK: Prevents an additional redraw when the scrollbar pops up + // which regularily happens on documents with more than one page. + // The policy should be set to "Qt::ScrollBarAsNeeded" soon. + // Since we have no geometry information yet, we assume that + // a document needs a scrollbar if there is more then four + // paragraph in the outermost text. + if (buffer.text().paragraphs().size() > 4) + setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn); + QTimer::singleShot(50, this, SLOT(fixVerticalScrollBar())); } @@ -329,18 +379,13 @@ void GuiWorkArea::close() void GuiWorkArea::setFullScreen(bool full_screen) { buffer_view_->setFullScreen(full_screen); + setFrameStyle(QFrame::NoFrame); if (full_screen) { setFrameStyle(QFrame::NoFrame); if (lyxrc.full_screen_scrollbar) setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); - } else { -#ifdef Q_WS_MACX - setFrameStyle(QFrame::NoFrame); -#else - setFrameStyle(QFrame::Box); -#endif + } else setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded); - } } @@ -365,7 +410,19 @@ void GuiWorkArea::stopBlinkingCursor() void GuiWorkArea::startBlinkingCursor() { + // do not show the cursor if the view is busy + if (view().busy()) + return; + + Point p; + int h = 0; + buffer_view_->cursorPosAndHeight(p, h); + // Don't start blinking if the cursor isn't on screen. + if (!buffer_view_->cursorInView(p, h)) + return; + showCursor(); + //we're not supposed to cache this value. int const time = QApplication::cursorFlashTime() / 2; if (time <= 0) @@ -375,7 +432,7 @@ void GuiWorkArea::startBlinkingCursor() } -void GuiWorkArea::redraw() +void GuiWorkArea::redraw(bool update_metrics) { if (!isVisible()) // No need to redraw in this case. @@ -383,9 +440,10 @@ void GuiWorkArea::redraw() // No need to do anything if this is the current view. The BufferView // metrics are already up to date. - if (lyx_view_ != guiApp->currentView() + if (update_metrics || lyx_view_ != guiApp->currentView() || 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(); } @@ -396,7 +454,7 @@ void GuiWorkArea::redraw() hideCursor(); showCursor(); } - + LYXERR(Debug::WORKAREA, "WorkArea::redraw screen"); updateScreen(); update(0, 0, viewport()->width(), viewport()->height()); @@ -408,12 +466,17 @@ void GuiWorkArea::redraw() if (lyxerr.debugging(Debug::WORKAREA)) buffer_view_->coordCache().dump(); + + setReadOnly(buffer_view_->buffer().isReadonly()); + + updateCursorShape(); } void GuiWorkArea::processKeySym(KeySymbol const & key, KeyModifier mod) { - if (lyx_view_->isFullScreen() && lyx_view_->menuBar()->isVisible()) { + if (lyx_view_->isFullScreen() && 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(); @@ -423,25 +486,22 @@ void GuiWorkArea::processKeySym(KeySymbol const & key, KeyModifier mod) // we better stop the blinking cursor... // the cursor gets restarted in GuiView::restartCursor() stopBlinkingCursor(); - - theLyXFunc().setLyXView(lyx_view_); - theLyXFunc().processKeySym(key, mod); + guiApp->processKeySym(key, mod); } void GuiWorkArea::dispatch(FuncRequest const & cmd0, KeyModifier mod) { // Handle drag&drop - if (cmd0.action == LFUN_FILE_OPEN) { - lyx_view_->dispatch(cmd0); + if (cmd0.action() == LFUN_FILE_OPEN) { + DispatchResult dr; + lyx_view_->dispatch(cmd0, dr); return; } - theLyXFunc().setLyXView(lyx_view_); - FuncRequest cmd; - if (cmd0.action == LFUN_MOUSE_PRESS) { + if (cmd0.action() == LFUN_MOUSE_PRESS) { if (mod == ShiftModifier) cmd = FuncRequest(cmd0, "region-select"); else if (mod == ControlModifier) @@ -452,9 +512,9 @@ void GuiWorkArea::dispatch(FuncRequest const & cmd0, KeyModifier mod) else cmd = cmd0; - bool const notJustMovingTheMouse = - cmd.action != LFUN_MOUSE_MOTION || cmd.button() != mouse_button::none; - + 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) @@ -463,7 +523,7 @@ void GuiWorkArea::dispatch(FuncRequest const & cmd0, KeyModifier mod) buffer_view_->mouseEventDispatch(cmd); // Skip these when selecting - if (cmd.action != LFUN_MOUSE_MOTION) { + if (cmd.action() != LFUN_MOUSE_MOTION) { completer_->updateVisibility(false, false); lyx_view_->updateDialogs(); lyx_view_->updateStatusBar(); @@ -479,6 +539,8 @@ void GuiWorkArea::dispatch(FuncRequest const & cmd0, KeyModifier mod) // Show the cursor immediately after any operation startBlinkingCursor(); } + + updateCursorShape(); } @@ -487,15 +549,21 @@ void GuiWorkArea::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; + 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()); + if (cursor_in_view) + buffer_view_->scrollToCursor(); updateScreen(); // Update scrollbars which might have changed due different - // BufferView dimension. This is especially important when the + // BufferView dimension. This is especially important when the // BufferView goes from zero-size to the real-size for the first time, // as the scrollbar paramters are then set for the first time. updateScrollbar(); - + lyx_view_->updateLayoutList(); lyx_view_->setBusy(false); need_resize_ = false; @@ -507,6 +575,12 @@ void GuiWorkArea::showCursor() if (cursor_visible_) return; + Point p; + int h = 0; + buffer_view_->cursorPosAndHeight(p, h); + if (!buffer_view_->cursorInView(p, h)) + return; + // RTL or not RTL bool l_shape = false; Font const & realfont = buffer_view_->cursor().real_current_font; @@ -521,31 +595,14 @@ void GuiWorkArea::showCursor() if (realfont.language() == latex_language) l_shape = false; - Font const font = buffer_view_->cursor().getFont(); - FontMetrics const & fm = theFontMetrics(font); - int const asc = fm.maxAscent(); - int const des = fm.maxDescent(); - int h = asc + des; - int x = 0; - int y = 0; - Cursor & cur = buffer_view_->cursor(); - cur.getPos(x, y); - y -= asc; - - // if it doesn't touch the screen, don't try to show it - bool cursorInView = true; - if (y + h < 0 || y >= viewport()->height()) - cursorInView = false; - // show cursor on screen + Cursor & cur = buffer_view_->cursor(); bool completable = cur.inset().showCompletionCursor() && completer_->completionAvailable() && !completer_->popupVisible() && !completer_->inlineVisible(); - if (cursorInView) { - cursor_visible_ = true; - showCursor(x, y, h, l_shape, isrtl, completable); - } + cursor_visible_ = true; + showCursor(p.x_, p.y_, h, l_shape, isrtl, completable); } @@ -585,7 +642,7 @@ void GuiWorkArea::updateScrollbar() void GuiWorkArea::scrollTo(int value) { stopBlinkingCursor(); - buffer_view_->scrollDocView(value); + buffer_view_->scrollDocView(value, true); if (lyxrc.cursor_follows_scrollbar) { buffer_view_->setCursorFromScrollbar(); @@ -621,11 +678,14 @@ bool GuiWorkArea::event(QEvent * e) // which are otherwise reserved to focus switching between controls // within a dialog. QKeyEvent * ke = static_cast(e); - if ((ke->key() != Qt::Key_Tab && ke->key() != Qt::Key_Backtab) - || ke->modifiers() & Qt::ControlModifier) - return QAbstractScrollArea::event(e); - keyPressEvent(ke); - return true; + if ((ke->key() == Qt::Key_Tab && ke->modifiers() == Qt::NoModifier) + || (ke->key() == Qt::Key_Backtab && ( + ke->modifiers() == Qt::ShiftModifier + || ke->modifiers() == Qt::NoModifier))) { + keyPressEvent(ke); + return true; + } + return QAbstractScrollArea::event(e); } default: @@ -637,7 +697,25 @@ bool GuiWorkArea::event(QEvent * e) void GuiWorkArea::contextMenuEvent(QContextMenuEvent * e) { - QPoint pos = e->pos(); + QPoint pos; + 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(); + } + } docstring name = buffer_view_->contextMenu(pos.x(), pos.y()); if (name.empty()) { QAbstractScrollArea::contextMenuEvent(e); @@ -657,6 +735,7 @@ 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); @@ -667,6 +746,7 @@ void GuiWorkArea::focusInEvent(QFocusEvent * e) void GuiWorkArea::focusOutEvent(QFocusEvent * e) { + LYXERR(Debug::DEBUG, "GuiWorkArea::focusOutEvent(): " << this << endl); stopBlinkingCursor(); QAbstractScrollArea::focusOutEvent(e); } @@ -683,6 +763,9 @@ void GuiWorkArea::mousePressEvent(QMouseEvent * e) return; } + if (e->button() == Qt::RightButton) + context_target_pos_ = e->pos(); + inputContext()->reset(); FuncRequest const cmd(LFUN_MOUSE_PRESS, e->x(), e->y(), @@ -714,18 +797,19 @@ void GuiWorkArea::mouseMoveEvent(QMouseEvent * e) e->accept(); // If we're above or below the work area... - if (e->y() <= 20 || e->y() >= viewport()->height() - 20) { + if ((e->y() <= 20 || e->y() >= viewport()->height() - 20) + && e->buttons() == mouse_button::button1) { // Make sure only a synthetic event can cause a page scroll, // so they come at a steady rate: if (e->y() <= 20) // _Force_ a scroll up: - cmd.y = -40; + cmd.set_y(e->y() - 21); else - cmd.y = viewport()->height(); + cmd.set_y(e->y() + 21); // Store the event, to be handled when the timeout expires. synthetic_mouse_event_.cmd = cmd; - if (synthetic_mouse_event_.timeout.running()) + if (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. @@ -734,7 +818,8 @@ void GuiWorkArea::mouseMoveEvent(QMouseEvent * e) // occurred after the one used to start the timeout // in the first place. return; - + } + synthetic_mouse_event_.restart_timeout = true; synthetic_mouse_event_.timeout.start(); // Fall through to handle this event... @@ -750,23 +835,6 @@ void GuiWorkArea::mouseMoveEvent(QMouseEvent * e) synthetic_mouse_event_.restart_timeout = false; return; } - - // Has anything changed on-screen since the last QMouseEvent - // was received? - double const scrollbar_value = verticalScrollBar()->value(); - if (e->x() == synthetic_mouse_event_.x_old - && e->y() == synthetic_mouse_event_.y_old - && scrollbar_value == synthetic_mouse_event_.scrollbar_value_old) { - // Nothing changed on-screen since the last QMouseEvent. - return; - } - - // Yes something has changed. Store the params used to check this. - synthetic_mouse_event_.x_old = e->x(); - synthetic_mouse_event_.y_old = e->y(); - synthetic_mouse_event_.scrollbar_value_old = scrollbar_value; - - // ... and dispatch the event to the LyX core. dispatch(cmd); } @@ -775,17 +843,27 @@ void GuiWorkArea::wheelEvent(QWheelEvent * ev) { // Wheel rotation by one notch results in a delta() of 120 (see // documentation of QWheelEvent) - int const delta = ev->delta() / 120; - if (ev->modifiers() & Qt::ControlModifier) { - lyxrc.zoom -= 5 * delta; - if (lyxrc.zoom < 10) - lyxrc.zoom = 10; - // The global QPixmapCache is used in GuiPainter to cache text - // painting so we must reset it. - QPixmapCache::clear(); - guiApp->fontLoader().update(); - ev->accept(); - lyx::dispatch(FuncRequest(LFUN_SCREEN_FONT_UPDATE)); + double const delta = ev->delta() / 120.0; + bool zoom = false; + switch (lyxrc.scroll_wheel_zoom) { + case LyXRC::SCROLL_WHEEL_ZOOM_CTRL: + zoom = ev->modifiers() & Qt::ControlModifier; + zoom &= !(ev->modifiers() & (Qt::ShiftModifier | Qt::AltModifier)); + break; + case LyXRC::SCROLL_WHEEL_ZOOM_SHIFT: + zoom = ev->modifiers() & Qt::ShiftModifier; + zoom &= !(ev->modifiers() & (Qt::ControlModifier | Qt::AltModifier)); + break; + case LyXRC::SCROLL_WHEEL_ZOOM_ALT: + zoom = ev->modifiers() & Qt::AltModifier; + zoom &= !(ev->modifiers() & (Qt::ShiftModifier | Qt::ControlModifier)); + break; + case LyXRC::SCROLL_WHEEL_ZOOM_OFF: + break; + } + if (zoom) { + docstring arg = convert(int(5 * delta)); + lyx::dispatch(FuncRequest(LFUN_BUFFER_ZOOM_IN, arg)); return; } @@ -796,11 +874,8 @@ void GuiWorkArea::wheelEvent(QWheelEvent * ev) int scroll_value = lines > page_step ? page_step : lines * verticalScrollBar()->singleStep(); - // Take into account the rotation. - scroll_value *= delta; - - // Take into account user preference. - scroll_value *= lyxrc.mouse_wheel_speed; + // Take into account the rotation and the user preferences. + scroll_value = int(scroll_value * delta * lyxrc.mouse_wheel_speed); LYXERR(Debug::SCROLLING, "wheelScrollLines = " << lines << " delta = " << delta << " scroll_value = " << scroll_value << " page_step = " << page_step); @@ -813,25 +888,98 @@ void GuiWorkArea::wheelEvent(QWheelEvent * ev) void GuiWorkArea::generateSyntheticMouseEvent() { + int const e_y = synthetic_mouse_event_.cmd.y(); + int const wh = buffer_view_->workHeight(); + bool const up = e_y < 0; + bool const down = e_y > wh; + // Set things off to generate the _next_ 'pseudo' event. - if (synthetic_mouse_event_.restart_timeout) + int step = 50; + if (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(); + } - // Has anything changed on-screen since the last timeout signal - // was received? - double const scrollbar_value = verticalScrollBar()->value(); - if (scrollbar_value != synthetic_mouse_event_.scrollbar_value_old) { - // Yes it has. Store the params used to check this. - synthetic_mouse_event_.scrollbar_value_old = scrollbar_value; + // Can we scroll further ? + int const value = verticalScrollBar()->value(); + if (value == verticalScrollBar()->maximum() + || value == verticalScrollBar()->minimum()) { + synthetic_mouse_event_.timeout.stop(); + return; + } - // ... and dispatch the event to the LyX core. - dispatch(synthetic_mouse_event_.cmd); + // Scroll + if (step <= 2 * wh) { + buffer_view_->scroll(up ? -step : step); + buffer_view_->updateMetrics(); + } else { + 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()); + + pair p = up ? tm.first() : tm.last(); + ParagraphMetrics const & pm = *p.second; + pit_type const pit = p.first; + + if (pm.rows().empty()) + return; + + // Find the row at which we set the cursor. + RowList::const_iterator rit = pm.rows().begin(); + RowList::const_iterator rlast = pm.rows().end(); + int yy = pm.position() - pm.ascent(); + for (--rlast; rit != rlast; ++rit) { + int h = rit->height(); + if ((up && yy + h > 0) + || (!up && yy + h > wh - defaultRowHeight())) + 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); + + // Set the cursor + cur.pit() = pit; + cur.pos() = pos; + cur.boundary(bound); + + buffer_view_->buffer().changed(false); + return; } void GuiWorkArea::keyPressEvent(QKeyEvent * ev) { + // Do not process here some keys if dialog_mode_ is set + if (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->ignore(); + return; + } + // intercept some keys if completion popup is visible if (completer_->popupVisible()) { switch (ev->key()) { @@ -842,33 +990,13 @@ void GuiWorkArea::keyPressEvent(QKeyEvent * ev) return; } } - - // intercept keys for the completion - if (ev->key() == Qt::Key_Tab) { - completer_->tab(); - ev->accept(); - return; - } - - if (completer_->popupVisible() && ev->key() == Qt::Key_Escape) { - completer_->hidePopup(); - ev->accept(); - return; - } - - if (completer_->inlineVisible() && ev->key() == Qt::Key_Escape) { - completer_->hideInline(); - ev->accept(); - return; - } // do nothing if there are other events // (the auto repeated events come too fast) - // \todo FIXME: remove hard coded Qt keys, process the key binding + // it looks like this is only needed on X11 #ifdef Q_WS_X11 - if (XEventsQueued(QX11Info::display(), 0) > 1 && ev->isAutoRepeat() - && (Qt::Key_PageDown || Qt::Key_PageUp)) { - LYXERR(Debug::KEY, "system is busy: scroll key event ignored"); + if (qApp->hasPendingEvents() && ev->isAutoRepeat()) { + LYXERR(Debug::KEY, "system is busy: keyPress event ignored"); ev->ignore(); return; } @@ -879,8 +1007,12 @@ void GuiWorkArea::keyPressEvent(QKeyEvent * ev) KeySymbol sym; setKeySymbol(&sym, ev); - processKeySym(sym, q_key_state(ev->modifiers())); - ev->accept(); + if (sym.isOK()) { + processKeySym(sym, q_key_state(ev->modifiers())); + ev->accept(); + } else { + ev->ignore(); + } } @@ -926,8 +1058,10 @@ void GuiWorkArea::paintEvent(QPaintEvent * ev) if (need_resize_) { screen_ = QPixmap(viewport()->width(), viewport()->height()); resizeBufferView(); - hideCursor(); - showCursor(); + if (cursor_visible_) { + hideCursor(); + showCursor(); + } } QPainter pain(viewport()); @@ -1118,14 +1252,16 @@ void GuiWorkArea::inputMethodEvent(QInputMethodEvent * e) QVariant GuiWorkArea::inputMethodQuery(Qt::InputMethodQuery query) const { - QRect cur_r(0,0,0,0); + QRect cur_r(0, 0, 0, 0); switch (query) { - // this is the CJK-specific composition window position. + // 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.moveLeft(10); - cur_r.moveBottom(cur_r.bottom() + cur_r.height() * preedit_lines_); + cur_r.moveBottom(cur_r.bottom() + + cur_r.height() * (preedit_lines_ - 1)); // return lower right of cursor in LyX. return cur_r; default: @@ -1144,6 +1280,12 @@ void GuiWorkArea::updateWindowTitle() 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('*'); @@ -1163,8 +1305,11 @@ void GuiWorkArea::updateWindowTitle() } -void GuiWorkArea::setReadOnly(bool) +void GuiWorkArea::setReadOnly(bool read_only) { + if (read_only_ == read_only) + return; + read_only_ = read_only; updateWindowTitle(); if (this == lyx_view_->currentWorkArea()) lyx_view_->updateDialogs(); @@ -1179,7 +1324,69 @@ bool GuiWorkArea::isFullScreen() //////////////////////////////////////////////////////////////////// // -// TabWorkArea +// EmbeddedWorkArea +// +//////////////////////////////////////////////////////////////////// + + +EmbeddedWorkArea::EmbeddedWorkArea(QWidget * w): GuiWorkArea(w) +{ + buffer_ = theBufferList().newBuffer( + support::FileName::tempName().absFileName() + "_embedded.internal"); + buffer_->setUnnamed(true); + buffer_->setFullyLoaded(true); + setBuffer(*buffer_); + setDialogMode(true); +} + + +EmbeddedWorkArea::~EmbeddedWorkArea() +{ + // No need to destroy buffer and bufferview here, because it is done + // in theBufferList() destruction loop at application exit +} + + +void EmbeddedWorkArea::closeEvent(QCloseEvent * ev) +{ + disable(); + GuiWorkArea::closeEvent(ev); +} + + +void EmbeddedWorkArea::hideEvent(QHideEvent * ev) +{ + disable(); + GuiWorkArea::hideEvent(ev); +} + + +QSize EmbeddedWorkArea::sizeHint () const +{ + // FIXME(?): + // GuiWorkArea sets the size to the screen's viewport + // by returning a value this gets overridden + // EmbeddedWorkArea is now sized to fit in the layout + // of the parent, and has a minimum size set in GuiWorkArea + // which is what we return here + return QSize(100, 70); +} + + +void EmbeddedWorkArea::disable() +{ + stopBlinkingCursor(); + if (view().currentWorkArea() != this) + return; + // No problem if currentMainWorkArea() is 0 (setCurrentWorkArea() + // tolerates it and shows the background logo), what happens if + // an EmbeddedWorkArea is closed after closing all document WAs + view().setCurrentWorkArea(view().currentMainWorkArea()); +} + +//////////////////////////////////////////////////////////////////// +// +// TabWorkArea // //////////////////////////////////////////////////////////////////// @@ -1192,7 +1399,7 @@ public: { QRect rect = QMacStyle::subElementRect(element, option, widget); bool noBar = static_cast(widget)->count() <= 1; - + // The Qt Mac style puts the contents into a 3 pixel wide box // which looks very ugly and not like other Mac applications. // Hence we remove this here, and moreover the 16 pixel round @@ -1217,6 +1424,9 @@ TabWorkArea::TabWorkArea(QWidget * parent) #ifdef Q_WS_MACX setStyle(&noTabFrameMacStyle); #endif +#if QT_VERSION < 0x040500 + lyxrc.single_close_tab_button = true; +#endif QPalette pal = palette(); pal.setColor(QPalette::Active, QPalette::Button, @@ -1229,10 +1439,10 @@ TabWorkArea::TabWorkArea(QWidget * parent) QObject::connect(this, SIGNAL(currentChanged(int)), this, SLOT(on_currentTabChanged(int))); - QToolButton * closeBufferButton = new QToolButton(this); + closeBufferButton = new QToolButton(this); closeBufferButton->setPalette(pal); // FIXME: rename the icon to closebuffer.png - closeBufferButton->setIcon(QIcon(":/images/closetab.png")); + closeBufferButton->setIcon(QIcon(getPixmap("images/", "closetab", "png"))); closeBufferButton->setText("Close File"); closeBufferButton->setAutoRaise(true); closeBufferButton->setCursor(Qt::ArrowCursor); @@ -1241,7 +1451,7 @@ TabWorkArea::TabWorkArea(QWidget * parent) QObject::connect(closeBufferButton, SIGNAL(clicked()), this, SLOT(closeCurrentBuffer())); setCornerWidget(closeBufferButton, Qt::TopRightCorner); - + // setup drag'n'drop QTabBar* tb = new DragTabBar; connect(tb, SIGNAL(tabMoveRequested(int, int)), @@ -1253,20 +1463,38 @@ 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::mouseDoubleClickEvent(QMouseEvent * event) +{ + if (event->button() != Qt::LeftButton) + return; + + // return early if double click on existing tabs + for (int i = 0; i < count(); ++i) + if (tabBar()->tabRect(i).contains(event->pos())) + return; + + dispatch(FuncRequest(LFUN_BUFFER_NEW)); +} + + void TabWorkArea::setFullScreen(bool full_screen) { for (int i = 0; i != count(); ++i) { - if (GuiWorkArea * wa = dynamic_cast(widget(i))) + if (GuiWorkArea * wa = workArea(i)) wa->setFullScreen(full_screen); } if (lyxrc.full_screen_tabbar) - showBar(!full_screen && count()>1); + showBar(!full_screen && count() > 1); } @@ -1274,6 +1502,10 @@ 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 } @@ -1282,16 +1514,24 @@ GuiWorkArea * TabWorkArea::currentWorkArea() if (count() == 0) return 0; - GuiWorkArea * wa = dynamic_cast(currentWidget()); + GuiWorkArea * wa = dynamic_cast(currentWidget()); LASSERT(wa, /**/); return wa; } +GuiWorkArea * TabWorkArea::workArea(int index) +{ + return dynamic_cast(widget(index)); +} + + GuiWorkArea * TabWorkArea::workArea(Buffer & buffer) { + // FIXME: this method doesn't work if we have more than work area + // showing the same buffer. for (int i = 0; i != count(); ++i) { - GuiWorkArea * wa = dynamic_cast(widget(i)); + GuiWorkArea * wa = workArea(i); LASSERT(wa, return 0); if (&wa->bufferView().buffer() == &buffer) return wa; @@ -1303,7 +1543,7 @@ GuiWorkArea * TabWorkArea::workArea(Buffer & buffer) void TabWorkArea::closeAll() { while (count()) { - GuiWorkArea * wa = dynamic_cast(widget(0)); + GuiWorkArea * wa = workArea(0); LASSERT(wa, /**/); removeTab(0); delete wa; @@ -1348,7 +1588,7 @@ GuiWorkArea * TabWorkArea::addWorkArea(Buffer & buffer, GuiView & view) showBar(count() > 1); updateTabTexts(); - + return wa; } @@ -1370,11 +1610,10 @@ bool TabWorkArea::removeWorkArea(GuiWorkArea * work_area) if (currentWorkArea() && currentWorkArea()->isFullScreen()) setFullScreen(true); else - // Hide tabbar if there's only one tab. + // Show tabbar only if there's more than one tab. showBar(count() > 1); - } else { + } else lastWorkAreaRemoved(); - } updateTabTexts(); @@ -1387,42 +1626,59 @@ void TabWorkArea::on_currentTabChanged(int i) // returns e.g. on application destruction if (i == -1) return; - GuiWorkArea * wa = dynamic_cast(widget(i)); + GuiWorkArea * wa = workArea(i); LASSERT(wa, return); - BufferView & bv = wa->bufferView(); - bv.cursor().fixIfBroken(); - bv.updateMetrics(); wa->setUpdatesEnabled(true); - wa->redraw(); + wa->redraw(true); wa->setFocus(); /// currentWorkAreaChanged(wa); LYXERR(Debug::GUI, "currentTabChanged " << i - << "File" << bv.buffer().absFileName()); + << " File: " << wa->bufferView().buffer().absFileName()); } void TabWorkArea::closeCurrentBuffer() { - if (clicked_tab_ != -1) - setCurrentIndex(clicked_tab_); - - lyx::dispatch(FuncRequest(LFUN_BUFFER_CLOSE)); + GuiWorkArea * wa; + if (clicked_tab_ == -1) + wa = currentWorkArea(); + else { + wa = workArea(clicked_tab_); + LASSERT(wa, /**/); + } + wa->view().closeWorkArea(wa); } -void TabWorkArea::closeCurrentTab() +void TabWorkArea::hideCurrentTab() { + GuiWorkArea * wa; if (clicked_tab_ == -1) - removeWorkArea(currentWorkArea()); + wa = currentWorkArea(); else { - GuiWorkArea * wa = dynamic_cast(widget(clicked_tab_)); + wa = workArea(clicked_tab_); LASSERT(wa, /**/); - removeWorkArea(wa); } + wa->view().hideWorkArea(wa); } + +void TabWorkArea::closeTab(int index) +{ + on_currentTabChanged(index); + GuiWorkArea * wa; + if (index == -1) + wa = currentWorkArea(); + else { + wa = workArea(index); + LASSERT(wa, /**/); + } + wa->view().closeWorkArea(wa); +} + + /// class DisplayPath { public: @@ -1432,14 +1688,16 @@ public: DisplayPath(int tab, FileName const & filename) : tab_(tab) { - filename_ = toqstr(filename.onlyFileNameWithoutExt()); + filename_ = (filename.extension() == "lyx") ? + toqstr(filename.onlyFileNameWithoutExt()) + : toqstr(filename.onlyFileName()); postfix_ = toqstr(filename.absoluteFilePath()). split("/", QString::SkipEmptyParts); postfix_.pop_back(); abs_ = toqstr(filename.absoluteFilePath()); dottedPrefix_ = false; } - + /// Absolute path for debugging. QString abs() const { @@ -1475,7 +1733,7 @@ public: { if (postfix_.count() == 0) return displayString(); - + return prefix_ + (dottedPrefix_ ? ".../" : "") + postfix_.front() + "/"; @@ -1484,7 +1742,7 @@ public: bool final() const { return postfix_.empty(); } /// int tab() const { return tab_; } - + private: /// QString prefix_; @@ -1521,26 +1779,26 @@ void TabWorkArea::updateTabTexts() return; std::list paths; typedef std::list::iterator It; - - // collect full names first: path into postfix, empty prefix and + + // collect full names first: path into postfix, empty prefix and // filename without extension for (size_t i = 0; i < n; ++i) { - GuiWorkArea * i_wa = dynamic_cast(widget(i)); + GuiWorkArea * i_wa = workArea(i); FileName const fn = i_wa->bufferView().buffer().fileName(); paths.push_back(DisplayPath(i, fn)); } - + // go through path segments and see if it helps to make the path more unique bool somethingChanged = true; bool allFinal = false; while (somethingChanged && !allFinal) { // adding path segments changes order paths.sort(); - + LYXERR(Debug::GUI, "updateTabTexts() iteration start"); somethingChanged = false; allFinal = true; - + // find segments which are not unique (i.e. non-atomic) It it = paths.begin(); It segStart = it; @@ -1549,20 +1807,20 @@ void TabWorkArea::updateTabTexts() // look to the next item It next = it; ++next; - + // final? allFinal = allFinal && it->final(); - + LYXERR(Debug::GUI, "it = " << it->abs() << " => " << it->displayString()); - + // still the same segment? QString nextString; if ((next != paths.end() && (nextString = next->displayString()) == segString)) continue; LYXERR(Debug::GUI, "segment ended"); - + // only a trivial one with one element? if (it == segStart) { // start new segment @@ -1570,7 +1828,7 @@ void TabWorkArea::updateTabTexts() segString = nextString; continue; } - + // we found a non-atomic segment segStart <= sit <= it < next. // Shift path segments and hope for the best // that it makes the path more unique. @@ -1591,7 +1849,7 @@ void TabWorkArea::updateTabTexts() LYXERR(Debug::GUI, "same forecast found for " << sit->abs() << " => " << dspString); } - + // if the path segment helped, add it. Otherwise add dots bool dots = !moreUnique; LYXERR(Debug::GUI, "using dots = " << dots); @@ -1606,10 +1864,10 @@ void TabWorkArea::updateTabTexts() segString = nextString; } } - + // set new tab titles for (It it = paths.begin(); it != paths.end(); ++it) { - GuiWorkArea * i_wa = dynamic_cast(widget(it->tab())); + GuiWorkArea * i_wa = workArea(it->tab()); Buffer & buf = i_wa->bufferView().buffer(); if (!buf.fileName().empty() && !buf.isClean()) setTabText(it->tab(), it->displayString() + "*"); @@ -1625,12 +1883,12 @@ void TabWorkArea::showContextMenu(const QPoint & pos) clicked_tab_ = static_cast(tabBar())->tabAt(pos); if (clicked_tab_ == -1) return; - + // show tab popup QMenu popup; - popup.addAction(QIcon(":/images/hidetab.png"), - qt_("Hide tab"), this, SLOT(closeCurrentTab())); - popup.addAction(QIcon(":/images/closetab.png"), + popup.addAction(QIcon(getPixmap("images/", "hidetab", "png")), + qt_("Hide tab"), this, SLOT(hideCurrentTab())); + popup.addAction(QIcon(getPixmap("images/", "closetab", "png")), qt_("Close tab"), this, SLOT(closeCurrentBuffer())); popup.exec(tabBar()->mapToGlobal(pos)); @@ -1649,12 +1907,15 @@ void TabWorkArea::moveTab(int fromIndex, int toIndex) insertTab(toIndex, w, icon, text); setCurrentIndex(toIndex); } - + DragTabBar::DragTabBar(QWidget* parent) : QTabBar(parent) { setAcceptDrops(true); +#if QT_VERSION >= 0x040500 + setTabsClosable(!lyxrc.single_close_tab_button); +#endif } @@ -1684,7 +1945,7 @@ void DragTabBar::mouseMoveEvent(QMouseEvent * event) // If the left button isn't pressed anymore then return if (!(event->buttons() & Qt::LeftButton)) return; - + // If the distance is too small then return if ((event->pos() - dragStartPos_).manhattanLength() < QApplication::startDragDistance()) @@ -1694,21 +1955,21 @@ void DragTabBar::mouseMoveEvent(QMouseEvent * event) int tab = tabAt(dragStartPos_); if (tab == -1) return; - + // simulate button release to remove highlight from button int i = currentIndex(); QMouseEvent me(QEvent::MouseButtonRelease, dragStartPos_, event->button(), event->buttons(), 0); QTabBar::mouseReleaseEvent(&me); setCurrentIndex(i); - + // initiate Drag QDrag * drag = new QDrag(this); QMimeData * mimeData = new QMimeData; // a crude way to distinguish tab-reodering drops from other ones mimeData->setData("action", "tab-reordering") ; drag->setMimeData(mimeData); - + #if QT_VERSION >= 0x040300 // get tab pixmap as cursor QRect r = tabRect(tab); @@ -1719,7 +1980,7 @@ void DragTabBar::mouseMoveEvent(QMouseEvent * event) #else drag->start(Qt::MoveAction); #endif - + } @@ -1728,7 +1989,7 @@ void DragTabBar::dragEnterEvent(QDragEnterEvent * event) // Only accept if it's an tab-reordering request QMimeData const * m = event->mimeData(); QStringList formats = m->formats(); - if (formats.contains("action") + if (formats.contains("action") && m->data("action") == "tab-reordering") event->acceptProposedAction(); } @@ -1738,8 +1999,8 @@ void DragTabBar::dropEvent(QDropEvent * event) { int fromIndex = tabAt(dragStartPos_); int toIndex = tabAt(event->pos()); - - // Tell interested objects that + + // Tell interested objects that if (fromIndex != toIndex) tabMoveRequested(fromIndex, toIndex); event->acceptProposedAction(); @@ -1749,4 +2010,4 @@ void DragTabBar::dropEvent(QDropEvent * event) } // namespace frontend } // namespace lyx -#include "GuiWorkArea_moc.cpp" +#include "moc_GuiWorkArea.cpp"