#include "Menus.h"
#include "Buffer.h"
+#include "BufferList.h"
#include "BufferParams.h"
#include "BufferView.h"
#include "CoordCache.h"
#include "GuiView.h"
#include "KeySymbol.h"
#include "Language.h"
-#include "LyXFunc.h"
+#include "LyX.h"
#include "LyXRC.h"
#include "LyXVC.h"
-#include "MetricsInfo.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"
#include <QToolTip>
#include <QMenuBar>
-#include <boost/bind.hpp>
+#include "support/bind.h"
#include <cmath>
-#ifdef Q_WS_X11
-#include <QX11Info>
-extern "C" int XEventsQueued(Display *display, int mode);
-#endif
-
#ifdef Q_WS_WIN
int const CursorWidth = 2;
#else
int const TabIndicatorWidth = 3;
#undef KeyPress
-#undef NoModifier
+#undef NoModifier
using namespace std;
using namespace lyx::support;
{
if (!show_ || !rect_.isValid())
return;
-
+
int y = rect_.top();
int l = x_ - rect_.left();
int r = rect_.right() - x_;
int bot = rect_.bottom();
- // draw vertica linel
+ // draw vertical line
painter.fillRect(x_, y, CursorWidth, rect_.height(), color_);
-
+
// draw RTL/LTR indication
painter.setPen(color_);
if (l_shape_) {
else
painter.drawLine(x_, bot, x_ + CursorWidth + r, bot);
}
-
+
// draw completion triangle
if (completable_) {
int m = y + rect_.height() / 2;
rtl_ = rtl;
completable_ = completable;
x_ = x;
-
+
// extension to left and right
int l = 0;
int r = 0;
else
r += h / 3;
}
-
+
// completion triangle
if (completable_) {
if (rtl)
// 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))
+{
+}
+
-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))
+{
+ 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);
}
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);
// 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
// Enables input methods for asian languages.
// Must be set when creating custom text editing widgets.
setAttribute(Qt::WA_InputMethodEnabled, true);
+
+ dialog_mode_ = false;
}
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()));
+}
+
+
void GuiWorkArea::fixVerticalScrollBar()
{
if (!isFullScreen())
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);
- }
}
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)
}
-void GuiWorkArea::redraw()
+void GuiWorkArea::redraw(bool update_metrics)
{
if (!isVisible())
// No need to redraw in this case.
// 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();
}
hideCursor();
showCursor();
}
-
+
LYXERR(Debug::WORKAREA, "WorkArea::redraw screen");
updateScreen();
update(0, 0, viewport()->width(), viewport()->height());
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();
// 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)
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)
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();
// Show the cursor immediately after any operation
startBlinkingCursor();
}
+
+ updateCursorShape();
}
// 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;
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;
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);
}
void GuiWorkArea::scrollTo(int value)
{
stopBlinkingCursor();
- buffer_view_->scrollDocView(value);
+ buffer_view_->scrollDocView(value, true);
if (lyxrc.cursor_follows_scrollbar) {
buffer_view_->setCursorFromScrollbar();
// which are otherwise reserved to focus switching between controls
// within a dialog.
QKeyEvent * ke = static_cast<QKeyEvent*>(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:
void GuiWorkArea::contextMenuEvent(QContextMenuEvent * e)
{
- QPoint pos = e->pos();
- docstring name = buffer_view_->contextMenu(pos.x(), pos.y());
+ docstring name;
+ if (e->reason() == QContextMenuEvent::Mouse)
+ // the menu name is set on mouse press
+ name = context_menu_name_;
+ else {
+ QPoint 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();
+ }
+ }
+ name = buffer_view_->contextMenu(pos.x(), pos.y());
+ }
+
if (name.empty()) {
QAbstractScrollArea::contextMenuEvent(e);
return;
}
- QMenu * menu = guiApp->menus().menu(toqstr(name), *lyx_view_);
+ // always show mnemonics when the keyboard is used to show the context menu
+ // FIXME: This should be fixed in Qt itself
+ bool const keyboard = (e->reason() == QContextMenuEvent::Keyboard);
+ QMenu * menu = guiApp->menus().menu(toqstr(name), *lyx_view_, keyboard);
if (!menu) {
QAbstractScrollArea::contextMenuEvent(e);
return;
void GuiWorkArea::focusInEvent(QFocusEvent * e)
{
+ LYXERR(Debug::DEBUG, "GuiWorkArea::focusInEvent(): " << this << endl);
if (lyx_view_->currentWorkArea() != this)
lyx_view_->setCurrentWorkArea(this);
void GuiWorkArea::focusOutEvent(QFocusEvent * e)
{
+ LYXERR(Debug::DEBUG, "GuiWorkArea::focusOutEvent(): " << this << endl);
stopBlinkingCursor();
QAbstractScrollArea::focusOutEvent(e);
}
return;
}
+ // 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.
+ if (e->button() == Qt::RightButton)
+ context_menu_name_ = buffer_view_->contextMenu(e->x(), e->y());
+
inputContext()->reset();
FuncRequest const cmd(LFUN_MOUSE_PRESS, e->x(), e->y(),
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.
// 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...
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);
}
{
// 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<docstring>(int(5 * delta));
+ lyx::dispatch(FuncRequest(LFUN_BUFFER_ZOOM_IN, arg));
return;
}
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);
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<pit_type, const ParagraphMetrics *> 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()) {
// 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;
}
#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());
+ << " isAutoRepeat: " << ev->isAutoRepeat() << " key: " << ev->key()
+ << " keyState: " << str);
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();
+ }
}
if (need_resize_) {
screen_ = QPixmap(viewport()->width(), viewport()->height());
resizeBufferView();
- hideCursor();
- showCursor();
+ if (cursor_visible_) {
+ hideCursor();
+ showCursor();
+ }
}
QPainter pain(viewport());
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:
docstring maximize_title;
docstring minimize_title;
- Buffer & buf = buffer_view_->buffer();
- FileName const fileName = buf.fileName();
- if (!fileName.empty()) {
- maximize_title = fileName.displayName(30);
- minimize_title = from_utf8(fileName.onlyFileName());
- if (buf.lyxvc().inUse())
- maximize_title += _(" (version control)");
+ 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('*');
maximize_title += _(" (read only)");
}
- QString title = windowTitle();
- QString new_title = toqstr(maximize_title);
- if (title == new_title)
- return;
-
- QWidget::setWindowTitle(new_title);
- QWidget::setWindowIconText(toqstr(minimize_title));
- titleChanged(this);
+ QString const new_title = toqstr(maximize_title);
+ if (new_title != windowTitle()) {
+ QWidget::setWindowTitle(new_title);
+ QWidget::setWindowIconText(toqstr(minimize_title));
+ titleChanged(this);
+ }
}
-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();
////////////////////////////////////////////////////////////////////
//
-// 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
//
////////////////////////////////////////////////////////////////////
{
QRect rect = QMacStyle::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
// which looks very ugly and not like other Mac applications.
// Hence we remove this here, and moreover the 16 pixel round
#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,
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);
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)),
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<GuiWorkArea *>(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);
}
{
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
}
if (count() == 0)
return 0;
- GuiWorkArea * wa = dynamic_cast<GuiWorkArea *>(currentWidget());
+ GuiWorkArea * wa = dynamic_cast<GuiWorkArea *>(currentWidget());
LASSERT(wa, /**/);
return wa;
}
+GuiWorkArea * TabWorkArea::workArea(int index)
+{
+ return dynamic_cast<GuiWorkArea *>(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<GuiWorkArea *>(widget(i));
+ GuiWorkArea * wa = workArea(i);
LASSERT(wa, return 0);
if (&wa->bufferView().buffer() == &buffer)
return wa;
void TabWorkArea::closeAll()
{
while (count()) {
- GuiWorkArea * wa = dynamic_cast<GuiWorkArea *>(widget(0));
+ GuiWorkArea * wa = workArea(0);
LASSERT(wa, /**/);
removeTab(0);
delete wa;
showBar(count() > 1);
updateTabTexts();
-
+
return wa;
}
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();
// returns e.g. on application destruction
if (i == -1)
return;
- GuiWorkArea * wa = dynamic_cast<GuiWorkArea *>(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<GuiWorkArea *>(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:
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
{
{
if (postfix_.count() == 0)
return displayString();
-
+
return prefix_
+ (dottedPrefix_ ? ".../" : "")
+ postfix_.front() + "/";
bool final() const { return postfix_.empty(); }
///
int tab() const { return tab_; }
-
+
private:
///
QString prefix_;
return;
std::list<DisplayPath> paths;
typedef std::list<DisplayPath>::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<GuiWorkArea *>(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;
// 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
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.
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);
segString = nextString;
}
}
-
+
// set new tab titles
for (It it = paths.begin(); it != paths.end(); ++it) {
- GuiWorkArea * i_wa = dynamic_cast<GuiWorkArea *>(widget(it->tab()));
- Buffer & buf = i_wa->bufferView().buffer();
+ int const tab_index = it->tab();
+ Buffer const & buf = workArea(tab_index)->bufferView().buffer();
+ QString tab_text = it->displayString();
if (!buf.fileName().empty() && !buf.isClean())
- setTabText(it->tab(), it->displayString() + "*");
- else
- setTabText(it->tab(), it->displayString());
+ tab_text += "*";
+ setTabText(tab_index, tab_text);
+ setTabToolTip(tab_index, it->abs());
}
}
clicked_tab_ = static_cast<DragTabBar *>(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));
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
}
// 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())
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);
#else
drag->start(Qt::MoveAction);
#endif
-
+
}
// 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();
}
{
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();
} // namespace frontend
} // namespace lyx
-#include "GuiWorkArea_moc.cpp"
+#include "moc_GuiWorkArea.cpp"