#include "GuiWorkArea.h"
-#include "GuiApplication.h"
-#include "QLPainter.h"
-#include "QKeySymbol.h"
-#include "qt_helpers.h"
-
-#include "LyXView.h"
-
+#include "Buffer.h"
+#include "BufferParams.h"
#include "BufferView.h"
-#include "rowpainter.h"
-#include "debug.h"
+#include "CoordCache.h"
+#include "Cursor.h"
+#include "Font.h"
#include "FuncRequest.h"
-#include "Color.h"
-#include "version.h"
+#include "GuiApplication.h"
+#include "GuiKeySymbol.h"
+#include "GuiPainter.h"
+#include "GuiView.h"
+#include "KeySymbol.h"
+#include "Language.h"
+#include "LyXFunc.h"
#include "LyXRC.h"
-
-#include "support/filetools.h" // LibFileSearch
-#include "support/os.h"
-#include "support/convert.h"
+#include "MetricsInfo.h"
+#include "qt_helpers.h"
+#include "version.h"
#include "graphics/GraphicsImage.h"
#include "graphics/GraphicsLoader.h"
+#include "support/debug.h"
+#include "support/gettext.h"
+#include "support/FileName.h"
+#include "support/ForkedCalls.h"
+
+#include "frontends/Application.h"
+#include "frontends/FontMetrics.h"
+#include "frontends/WorkAreaManager.h"
+
+#include <QInputContext>
#include <QLayout>
#include <QMainWindow>
-#include <QMimeData>
-#include <QUrl>
-#include <QDragEnterEvent>
#include <QPainter>
+#include <QToolButton>
+#include <QPalette>
#include <QScrollBar>
+#include <QTabBar>
#include <QTimer>
-#include <QInputContext>
#include <boost/bind.hpp>
-#include <boost/current_function.hpp>
+
+#ifdef Q_WS_X11
+#include <QX11Info>
+extern "C" int XEventsQueued(Display *display, int mode);
+#endif
#ifdef Q_WS_WIN
int const CursorWidth = 2;
int const CursorWidth = 1;
#endif
+#undef KeyPress
+#undef NoModifier
using std::endl;
+using std::min;
+using std::max;
using std::string;
-namespace os = lyx::support::os;
-
-
namespace lyx {
using support::FileName;
-/// return the LyX key state from Qt's
-static key_modifier::state q_key_state(Qt::KeyboardModifiers state)
-{
- key_modifier::state k = key_modifier::none;
- if (state & Qt::ControlModifier)
- k |= key_modifier::ctrl;
- if (state & Qt::ShiftModifier)
- k |= key_modifier::shift;
- if (state & Qt::AltModifier || state & Qt::MetaModifier)
- k |= key_modifier::alt;
- return k;
-}
-
/// return the LyX mouse button state from Qt's
static mouse_button::state q_button_state(Qt::MouseButton button)
void draw(QPainter & painter)
{
- // FIXME: do something depending on the cursor shape.
- if (show_ && rect_.isValid())
- painter.fillRect(rect_, color_);
+ if (show_ && rect_.isValid()) {
+ switch (shape_) {
+ case L_SHAPE:
+ painter.fillRect(rect_.x(), rect_.y(), CursorWidth, rect_.height(), color_);
+ painter.setPen(color_);
+ painter.drawLine(rect_.bottomLeft().x() + CursorWidth, rect_.bottomLeft().y(),
+ rect_.bottomRight().x(), rect_.bottomLeft().y());
+ break;
+
+ case REVERSED_L_SHAPE:
+ painter.fillRect(rect_.x() + rect_.height() / 3, rect_.y(), CursorWidth, rect_.height(), color_);
+ painter.setPen(color_);
+ painter.drawLine(rect_.bottomRight().x() - CursorWidth, rect_.bottomLeft().y(),
+ rect_.bottomLeft().x(), rect_.bottomLeft().y());
+ break;
+
+ default:
+ painter.fillRect(rect_, color_);
+ break;
+ }
+ }
}
void update(int x, int y, int h, CursorShape shape)
{
- color_ = guiApp->colorCache().get(Color::cursor);
- rect_ = QRect(x, y, CursorWidth, h);
+ color_ = guiApp->colorCache().get(Color_cursor);
shape_ = shape;
+ switch (shape) {
+ case L_SHAPE:
+ rect_ = QRect(x, y, CursorWidth + h / 3, h);
+ break;
+ case REVERSED_L_SHAPE:
+ rect_ = QRect(x - h / 3, y, CursorWidth + h / 3, h);
+ break;
+ default:
+ rect_ = QRect(x, y, CursorWidth, h);
+ break;
+ }
}
void show(bool set_show = true) { show_ = set_show; }
{}
-GuiWorkArea::GuiWorkArea(int w, int h, int id, LyXView & lyx_view)
- : WorkArea(id, lyx_view), need_resize_(false), schedule_redraw_(false),
- preedit_lines_(1)
+
+GuiWorkArea::GuiWorkArea(Buffer & buffer, GuiView & lv)
+ : buffer_view_(new BufferView(buffer)), lyx_view_(&lv),
+ cursor_visible_(false),
+ need_resize_(false), schedule_redraw_(false),
+ preedit_lines_(1)
{
+ buffer.workAreaManager().add(this);
+ // Setup the signals
+ cursor_timeout_.setInterval(400);
+ connect(&cursor_timeout_, SIGNAL(timeout()),
+ this, SLOT(toggleCursor()));
+
+ cursor_timeout_.start();
+
screen_ = QPixmap(viewport()->width(), viewport()->height());
cursor_ = new frontend::CursorWidget();
cursor_->hide();
- setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
+ setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
setAcceptDrops(true);
setMouseTracking(true);
setMinimumSize(100, 70);
+ updateWindowTitle();
viewport()->setAutoFillBackground(false);
// We don't need double-buffering nor SystemBackground on
viewport()->setCursor(Qt::IBeamCursor);
- resize(w, h);
-
synthetic_mouse_event_.timeout.timeout.connect(
boost::bind(&GuiWorkArea::generateSyntheticMouseEvent,
- this));
+ this));
// Initialize the vertical Scroll Bar
QObject::connect(verticalScrollBar(), SIGNAL(actionTriggered(int)),
// PageStep only depends on the viewport height.
verticalScrollBar()->setPageStep(viewport()->height());
- LYXERR(Debug::GUI) << BOOST_CURRENT_FUNCTION
- << "\n Area width\t" << width()
- << "\n Area height\t" << height()
- << "\n viewport width\t" << viewport()->width()
- << "\n viewport height\t" << viewport()->height()
- << endl;
+ LYXERR(Debug::GUI, "viewport width: " << viewport()->width()
+ << " viewport height: " << viewport()->height());
// Enables input methods for asian languages.
// Must be set when creating custom text editing widgets.
}
-void GuiWorkArea::setScrollbarParams(int h, int scroll_pos, int scroll_line_step)
+
+GuiWorkArea::~GuiWorkArea()
{
- if (verticalScrollBarPolicy() != Qt::ScrollBarAlwaysOn)
- setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
+ buffer_view_->buffer().workAreaManager().remove(this);
+ delete buffer_view_;
+ delete cursor_;
+}
- verticalScrollBar()->setTracking(false);
- // do what cursor movement does (some grey)
- h += height() / 4;
- int scroll_max_ = std::max(0, h - height());
+void GuiWorkArea::close()
+{
+ lyx_view_->removeWorkArea(this);
+}
- verticalScrollBar()->setRange(0, scroll_max_);
- verticalScrollBar()->setSliderPosition(scroll_pos);
- verticalScrollBar()->setSingleStep(scroll_line_step);
- verticalScrollBar()->setValue(scroll_pos);
- verticalScrollBar()->setTracking(true);
+BufferView & GuiWorkArea::bufferView()
+{
+ return *buffer_view_;
}
-void GuiWorkArea::adjustViewWithScrollBar(int)
+BufferView const & GuiWorkArea::bufferView() const
{
- scrollBufferView(verticalScrollBar()->sliderPosition());
+ return *buffer_view_;
}
-void GuiWorkArea::dragEnterEvent(QDragEnterEvent * event)
+void GuiWorkArea::stopBlinkingCursor()
{
- if (event->mimeData()->hasUrls())
- event->accept();
- /// \todo Ask lyx-devel is this is enough:
- /// if (event->mimeData()->hasFormat("text/plain"))
- /// event->acceptProposedAction();
+ cursor_timeout_.stop();
+ hideCursor();
}
-void GuiWorkArea::dropEvent(QDropEvent* event)
+void GuiWorkArea::startBlinkingCursor()
{
- QList<QUrl> files = event->mimeData()->urls();
- if (files.isEmpty())
+ showCursor();
+ cursor_timeout_.start();
+}
+
+
+void GuiWorkArea::redraw()
+{
+ if (!isVisible())
+ // No need to redraw in this case.
return;
- LYXERR(Debug::GUI) << "GuiWorkArea::dropEvent: got URIs!" << endl;
- for (int i = 0; i!=files.size(); ++i) {
- string const file = os::internal_path(fromqstr(files.at(i).toLocalFile()));
- if (!file.empty())
- dispatch(FuncRequest(LFUN_FILE_OPEN, file));
+ // No need to do anything if this is the current view. The BufferView
+ // metrics are already up to date.
+ if (lyx_view_ != guiApp->currentView()) {
+ // FIXME: it would be nice to optimize for the off-screen case.
+ buffer_view_->updateMetrics();
+ buffer_view_->cursor().fixIfBroken();
}
+
+ updateScrollbar();
+
+ // update cursor position, because otherwise it has to wait until
+ // the blinking interval is over
+ if (cursor_visible_) {
+ hideCursor();
+ showCursor();
+ }
+
+ LYXERR(Debug::WORKAREA, "WorkArea::redraw screen");
+ updateScreen();
+ update(0, 0, viewport()->width(), viewport()->height());
+
+ lyx_view_->updateStatusBar();
+
+ if (lyxerr.debugging(Debug::WORKAREA))
+ buffer_view_->coordCache().dump();
}
-void GuiWorkArea::focusInEvent(QFocusEvent * /*event*/)
+void GuiWorkArea::processKeySym(KeySymbol const & key, KeyModifier mod)
+{
+ // In order to avoid bad surprise in the middle of an operation,
+ // we better stop the blinking cursor.
+ stopBlinkingCursor();
+
+ theLyXFunc().setLyXView(lyx_view_);
+ theLyXFunc().processKeySym(key, mod);
+}
+
+
+void GuiWorkArea::dispatch(FuncRequest const & cmd0, KeyModifier mod)
+{
+ // Handle drag&drop
+ if (cmd0.action == LFUN_FILE_OPEN) {
+ lyx_view_->dispatch(cmd0);
+ return;
+ }
+
+ theLyXFunc().setLyXView(lyx_view_);
+
+ FuncRequest cmd;
+
+ if (cmd0.action == LFUN_MOUSE_PRESS) {
+ if (mod == ShiftModifier)
+ cmd = FuncRequest(cmd0, "region-select");
+ else if (mod == ControlModifier)
+ cmd = FuncRequest(cmd0, "paragraph-select");
+ else
+ cmd = cmd0;
+ }
+ else
+ cmd = cmd0;
+
+ // In order to avoid bad surprise in the middle of an operation, we better stop
+ // the blinking cursor.
+ if (!(cmd.action == LFUN_MOUSE_MOTION
+ && cmd.button() == mouse_button::none))
+ stopBlinkingCursor();
+
+ buffer_view_->mouseEventDispatch(cmd);
+
+ // Skip these when selecting
+ if (cmd.action != LFUN_MOUSE_MOTION) {
+ lyx_view_->updateLayoutList();
+ lyx_view_->updateToolbars();
+ }
+
+ // GUI tweaks except with mouse motion with no button pressed.
+ if (!(cmd.action == LFUN_MOUSE_MOTION
+ && cmd.button() == mouse_button::none)) {
+ // Slight hack: this is only called currently when we
+ // clicked somewhere, so we force through the display
+ // of the new status here.
+ lyx_view_->clearMessage();
+
+ // Show the cursor immediately after any operation.
+ startBlinkingCursor();
+ }
+}
+
+
+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);
+ buffer_view_->resize(viewport()->width(), viewport()->height());
+ lyx_view_->updateLayoutList();
+ lyx_view_->setBusy(false);
+ need_resize_ = false;
+}
+
+
+void GuiWorkArea::showCursor()
+{
+ if (cursor_visible_)
+ return;
+
+ CursorShape shape = BAR_SHAPE;
+
+ Font const & realfont = buffer_view_->cursor().real_current_font;
+ BufferParams const & bp = buffer_view_->buffer().params();
+ bool const samelang = realfont.language() == bp.language;
+ bool const isrtl = realfont.isVisibleRightToLeft();
+
+ if (!samelang || isrtl != bp.language->rightToLeft()) {
+ shape = L_SHAPE;
+ if (isrtl)
+ shape = REVERSED_L_SHAPE;
+ }
+
+ // The ERT language hack needs fixing up
+ if (realfont.language() == latex_language)
+ shape = BAR_SHAPE;
+
+ 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;
+ buffer_view_->cursor().getPos(x, y);
+ y -= asc;
+
+ // if it doesn't touch the screen, don't try to show it
+ if (y + h < 0 || y >= viewport()->height())
+ return;
+
+ cursor_visible_ = true;
+ showCursor(x, y, h, shape);
+}
+
+
+void GuiWorkArea::hideCursor()
+{
+ if (!cursor_visible_)
+ return;
+
+ cursor_visible_ = false;
+ removeCursor();
+}
+
+
+void GuiWorkArea::toggleCursor()
+{
+ if (cursor_visible_)
+ hideCursor();
+ else
+ showCursor();
+
+ // Use this opportunity to deal with any child processes that
+ // have finished but are waiting to communicate this fact
+ // to the rest of LyX.
+ support::ForkedCallsController::handleCompletedProcesses();
+}
+
+
+void GuiWorkArea::updateScrollbar()
+{
+ verticalScrollBar()->setTracking(false);
+
+ buffer_view_->updateScrollbar();
+ ScrollbarParameters const & scroll_ = buffer_view_->scrollbarParameters();
+
+ // do what cursor movement does (some grey)
+ int const h = scroll_.height + viewport()->height() / 4;
+ int scroll_max_ = std::max(0, h - viewport()->height());
+
+ verticalScrollBar()->setRange(0, scroll_max_);
+ verticalScrollBar()->setSliderPosition(scroll_.position);
+ verticalScrollBar()->setSingleStep(scroll_.lineScrollHeight);
+ verticalScrollBar()->setValue(scroll_.position);
+
+ verticalScrollBar()->setTracking(true);
+}
+
+
+void GuiWorkArea::adjustViewWithScrollBar(int action)
{
- // No need to do anything if we didn't change views...
-// if (theApp() == 0 || &lyx_view_ == theApp()->currentView())
-// return;
+ stopBlinkingCursor();
+ if (action == QAbstractSlider::SliderPageStepAdd)
+ buffer_view_->scrollDown(viewport()->height());
+ else if (action == QAbstractSlider::SliderPageStepSub)
+ buffer_view_->scrollUp(viewport()->height());
+ else
+ buffer_view_->scrollDocView(verticalScrollBar()->sliderPosition());
+
+ if (lyxrc.cursor_follows_scrollbar) {
+ buffer_view_->setCursorFromScrollbar();
+ lyx_view_->updateLayoutList();
+ }
+ // Show the cursor immediately after any operation.
+ startBlinkingCursor();
+ QApplication::syncX();
+}
- theApp()->setCurrentView(lyx_view_);
+void GuiWorkArea::focusInEvent(QFocusEvent * /*event*/)
+{
// Repaint the whole screen.
// Note: this is different from redraw() as only the backing pixmap
// will be redrawn, which is cheap.
viewport()->repaint();
- // FIXME: it would be better to send a signal "newBuffer()"
- // in BufferList that could be connected to the different tabbars.
- lyx_view_.updateTab();
-
startBlinkingCursor();
}
{
if (dc_event_.active && dc_event_ == *e) {
dc_event_.active = false;
- FuncRequest cmd(LFUN_MOUSE_TRIPLE,
- e->x(), e->y(),
+ FuncRequest cmd(LFUN_MOUSE_TRIPLE, e->x(), e->y(),
q_button_state(e->button()));
dispatch(cmd);
return;
}
-void GuiWorkArea::keyPressEvent(QKeyEvent * e)
+void GuiWorkArea::keyPressEvent(QKeyEvent * ev)
{
+ // 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
+#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");
+ ev->ignore();
+ return;
+ }
+#endif
- LYXERR(Debug::KEY) << BOOST_CURRENT_FUNCTION
- << " count=" << e->count()
- << " text=" << fromqstr(e->text())
- << " isAutoRepeat=" << e->isAutoRepeat()
- << " key=" << e->key()
- << endl;
+ LYXERR(Debug::KEY, " count: " << ev->count()
+ << " text: " << fromqstr(ev->text())
+ << " isAutoRepeat: " << ev->isAutoRepeat() << " key: " << ev->key());
- boost::shared_ptr<QKeySymbol> sym(new QKeySymbol);
- sym->set(e);
- processKeySym(sym, q_key_state(e->modifiers()));
+ KeySymbol sym;
+ setKeySymbol(&sym, ev);
+ processKeySym(sym, q_key_state(ev->modifiers()));
}
-void GuiWorkArea::doubleClickTimeout() {
+
+void GuiWorkArea::doubleClickTimeout()
+{
dc_event_.active = false;
}
-void GuiWorkArea::mouseDoubleClickEvent(QMouseEvent * e)
+
+void GuiWorkArea::mouseDoubleClickEvent(QMouseEvent * ev)
{
- dc_event_ = double_click(e);
+ dc_event_ = DoubleClick(ev);
QTimer::singleShot(QApplication::doubleClickInterval(), this,
SLOT(doubleClickTimeout()));
FuncRequest cmd(LFUN_MOUSE_DOUBLE,
- e->x(), e->y(),
- q_button_state(e->button()));
+ ev->x(), ev->y(),
+ q_button_state(ev->button()));
dispatch(cmd);
}
}
-void GuiWorkArea::doGreyOut(QLPainter & pain)
-{
- pain.fillRectangle(0, 0, width(), height(),
- Color::bottomarea);
-
- //if (!lyxrc.show_banner)
- // return;
- LYXERR(Debug::GUI) << "show banner: " << lyxrc.show_banner << endl;
- /// The text to be written on top of the pixmap
- QString const text = lyx_version ? QString(lyx_version) : qt_("unknown version");
- FileName const file = support::libFileSearch("images", "banner", "png");
- if (file.empty())
- return;
-
- QPixmap pm(toqstr(file.absFilename()));
- if (!pm) {
- lyxerr << "could not load splash screen: '" << file << "'" << endl;
- return;
- }
-
- QFont font;
- // The font used to display the version info
- font.setStyleHint(QFont::SansSerif);
- font.setWeight(QFont::Bold);
- font.setPointSize(convert<int>(lyxrc.font_sizes[Font::SIZE_LARGE]));
-
- int const w = pm.width();
- int const h = pm.height();
-
- int x = (width() - w) / 2;
- int y = (height() - h) / 2;
-
- pain.drawPixmap(x, y, pm);
-
- x += 260;
- y += 270;
-
- pain.setPen(QColor(255, 255, 0));
- pain.setFont(font);
- pain.drawText(x, y, text);
-}
-
-
void GuiWorkArea::paintEvent(QPaintEvent * ev)
{
- QRect const rc = ev->rect();
- /*
- LYXERR(Debug::PAINTING) << "paintEvent begin: x: " << rc.x()
- << " y: " << rc.y()
- << " w: " << rc.width()
- << " h: " << rc.height() << endl;
- */
+ QRect const rc = ev->rect();
+ // LYXERR(Debug::PAINTING, "paintEvent begin: x: " << rc.x()
+ // << " y: " << rc.y() << " w: " << rc.width() << " h: " << rc.height());
if (need_resize_) {
verticalScrollBar()->setPageStep(viewport()->height());
screen_ = QPixmap(viewport()->width(), viewport()->height());
resizeBufferView();
updateScreen();
- need_resize_ = false;
+ hideCursor();
+ showCursor();
}
QPainter pain(viewport());
}
-void GuiWorkArea::expose(int x, int y, int w, int h)
-{
- updateScreen();
- update(x, y, w, h);
-}
-
-
void GuiWorkArea::updateScreen()
{
- QLPainter pain(&screen_);
-
- if (greyed_out_) {
- LYXERR(Debug::GUI) << "splash screen requested" << endl;
- verticalScrollBar()->hide();
- doGreyOut(pain);
- return;
- }
-
- verticalScrollBar()->show();
- paintText(*buffer_view_, pain);
+ GuiPainter pain(&screen_);
+ buffer_view_->draw(pain);
}
void GuiWorkArea::showCursor(int x, int y, int h, CursorShape shape)
{
if (schedule_redraw_) {
- if (buffer_view_ && buffer_view_->buffer()) {
- buffer_view_->update(Update::Force);
- updateScreen();
- viewport()->update(QRect(0, 0, viewport()->width(), viewport()->height()));
- }
+ buffer_view_->updateMetrics();
+ updateScreen();
+ viewport()->update(QRect(0, 0, viewport()->width(), viewport()->height()));
schedule_redraw_ = false;
// Show the cursor immediately after the update.
hideCursor();
docstring const & preedit_string
= qstring_to_ucs4(e->preeditString());
- if(greyed_out_) {
- e->ignore();
- return;
- }
-
if (!commit_string.isEmpty()) {
- LYXERR(Debug::KEY) << BOOST_CURRENT_FUNCTION
- << " preeditString =" << fromqstr(e->preeditString())
- << " commitString =" << fromqstr(e->commitString())
- << endl;
+ LYXERR(Debug::KEY, "preeditString: " << fromqstr(e->preeditString())
+ << " commitString: " << fromqstr(e->commitString()));
int key = 0;
// FIXME Iwami 04/01/07: we should take care also of UTF16 surrogates here.
- for (int i = 0; i < commit_string.size(); ++i) {
+ for (int i = 0; i != commit_string.size(); ++i) {
QKeyEvent ev(QEvent::KeyPress, key, Qt::NoModifier, commit_string[i]);
keyPressEvent(&ev);
}
}
- // Hide the cursor during the kana-kanji transformation.
+ // Hide the cursor during the kana-kanji transformation.
if (preedit_string.empty())
startBlinkingCursor();
else
// last_width : for checking if last preedit string was/wasn't empty.
static bool last_width = false;
if (!last_width && preedit_string.empty()) {
- // if last_width is last length of preedit string.
+ // if last_width is last length of preedit string.
e->accept();
return;
}
- QLPainter pain(&screen_);
- buffer_view_->updateMetrics(false);
- paintText(*buffer_view_, pain);
- Font font = buffer_view_->cursor().getFont();
+ GuiPainter pain(&screen_);
+ buffer_view_->updateMetrics();
+ buffer_view_->draw(pain);
+ FontInfo font = buffer_view_->cursor().getFont().fontInfo();
FontMetrics const & fm = theFontMetrics(font);
int height = fm.maxHeight();
int cur_x = cursor_->rect().left();
int cur_y = cursor_->rect().bottom();
// redraw area of preedit string.
- update(0, cur_y - height, GuiWorkArea::width(),
+ update(0, cur_y - height, viewport()->width(),
(height + 1) * preedit_lines_);
if (preedit_string.empty()) {
// cursor_pos : cursor position in preedit string.
size_t cursor_pos = 0;
bool cursor_is_visible = false;
- for (int i = 0; i < att.size(); ++i) {
+ for (int i = 0; i != att.size(); ++i) {
if (att.at(i).type == QInputMethodEvent::Cursor) {
cursor_pos = att.at(i).start;
cursor_is_visible = att.at(i).length != 0;
// rLength : selected string length in IM.
size_t rLength = 0;
if (cursor_pos < preedit_length) {
- for (int i = 0; i < att.size(); ++i) {
+ for (int i = 0; i != att.size(); ++i) {
if (att.at(i).type == QInputMethodEvent::TextFormat) {
if (att.at(i).start <= int(cursor_pos)
&& int(cursor_pos) < att.at(i).start + att.at(i).length) {
ps = Painter::preedit_default;
// if we reached the right extremity of the screen, go to next line.
- if (cur_x + fm.width(typed_char) > GuiWorkArea::width() - right_margin) {
+ if (cur_x + fm.width(typed_char) > viewport()->width() - right_margin) {
cur_x = right_margin;
cur_y += height + 1;
++preedit_lines_;
// that we are in selecting mode in the input method.
// FIXME: rLength == preedit_length is not a changing condition
// FIXME: should be put out of the loop.
- if (pos >= rStart
+ if (pos >= rStart
&& pos < rStart + rLength
&& !(cursor_pos < rLength && rLength == preedit_length))
ps = Painter::preedit_selecting;
}
// update the preedit string screen area.
- update(0, cur_y - preedit_lines_*height, GuiWorkArea::width(),
+ update(0, cur_y - preedit_lines_*height, viewport()->width(),
(height + 1) * preedit_lines_);
// Don't forget to accept the event!
}
}
+
+void GuiWorkArea::updateWindowTitle()
+{
+ docstring maximize_title;
+ docstring minimize_title;
+
+ Buffer & buf = buffer_view_->buffer();
+ FileName const fileName = buf.fileName();
+ if (!fileName.empty()) {
+ maximize_title = fileName.displayName(30);
+ minimize_title = from_utf8(fileName.onlyFileName());
+ if (!buf.isClean()) {
+ maximize_title += _(" (changed)");
+ minimize_title += char_type('*');
+ }
+ if (buf.isReadonly())
+ 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);
+}
+
+
+void GuiWorkArea::setReadOnly(bool)
+{
+ updateWindowTitle();
+ if (this == lyx_view_->currentWorkArea())
+ lyx_view_->updateBufferDependent(false);
+}
+
+
+////////////////////////////////////////////////////////////////////
+//
+// TabWorkArea
+//
+////////////////////////////////////////////////////////////////////
+
+TabWorkArea::TabWorkArea(QWidget * parent) : QTabWidget(parent)
+{
+ QPalette pal = palette();
+ pal.setColor(QPalette::Active, QPalette::Button,
+ pal.color(QPalette::Active, QPalette::Window));
+ pal.setColor(QPalette::Disabled, QPalette::Button,
+ pal.color(QPalette::Disabled, QPalette::Window));
+ pal.setColor(QPalette::Inactive, QPalette::Button,
+ pal.color(QPalette::Inactive, QPalette::Window));
+
+ QToolButton * closeTabButton = new QToolButton(this);
+ closeTabButton->setPalette(pal);
+ closeTabButton->setIcon(QIcon(":/images/closetab.png"));
+ closeTabButton->setText("Close");
+ closeTabButton->setAutoRaise(true);
+ closeTabButton->setCursor(Qt::ArrowCursor);
+ closeTabButton->setToolTip(tr("Close tab"));
+ closeTabButton->setEnabled(true);
+
+ QObject::connect(this, SIGNAL(currentChanged(int)),
+ this, SLOT(on_currentTabChanged(int)));
+ QObject::connect(closeTabButton, SIGNAL(clicked()),
+ this, SLOT(closeCurrentTab()));
+
+ setCornerWidget(closeTabButton);
+ setUsesScrollButtons(true);
+}
+
+
+void TabWorkArea::showBar(bool show)
+{
+ tabBar()->setEnabled(show);
+ tabBar()->setVisible(show);
+}
+
+
+GuiWorkArea * TabWorkArea::currentWorkArea()
+{
+ if (count() == 0)
+ return 0;
+
+ GuiWorkArea * wa = dynamic_cast<GuiWorkArea *>(currentWidget());
+ BOOST_ASSERT(wa);
+ return wa;
+}
+
+
+GuiWorkArea * TabWorkArea::workArea(Buffer & buffer)
+{
+ for (int i = 0; i != count(); ++i) {
+ GuiWorkArea * wa = dynamic_cast<GuiWorkArea *>(widget(i));
+ BOOST_ASSERT(wa);
+ if (&wa->bufferView().buffer() == &buffer)
+ return wa;
+ }
+ return 0;
+}
+
+
+void TabWorkArea::closeAll()
+{
+ while (count()) {
+ GuiWorkArea * wa = dynamic_cast<GuiWorkArea *>(widget(0));
+ BOOST_ASSERT(wa);
+ removeTab(0);
+ delete wa;
+ }
+}
+
+
+bool TabWorkArea::setCurrentWorkArea(GuiWorkArea * work_area)
+{
+ BOOST_ASSERT(work_area);
+ int index = indexOf(work_area);
+ if (index == -1)
+ return false;
+
+ if (index == currentIndex())
+ // Make sure the work area is up to date.
+ on_currentTabChanged(index);
+ else
+ // Switch to the work area.
+ setCurrentIndex(index);
+ work_area->setFocus();
+
+ return true;
+}
+
+
+GuiWorkArea * TabWorkArea::addWorkArea(Buffer & buffer, GuiView & view)
+{
+ GuiWorkArea * wa = new GuiWorkArea(buffer, view);
+ wa->setUpdatesEnabled(false);
+ // Hide tabbar if there's no tab (avoid a resize and a flashing tabbar
+ // when hiding it again below).
+ showBar(count() > 0);
+ addTab(wa, wa->windowTitle());
+ QObject::connect(wa, SIGNAL(titleChanged(GuiWorkArea *)),
+ this, SLOT(updateTabText(GuiWorkArea *)));
+ // Hide tabbar if there's only one tab.
+ showBar(count() > 1);
+ return wa;
+}
+
+
+bool TabWorkArea::removeWorkArea(GuiWorkArea * work_area)
+{
+ BOOST_ASSERT(work_area);
+ int index = indexOf(work_area);
+ if (index == -1)
+ return false;
+
+ work_area->setUpdatesEnabled(false);
+ removeTab(index);
+ delete work_area;
+
+ if (count()) {
+ // make sure the next work area is enabled.
+ currentWidget()->setUpdatesEnabled(true);
+ // Hide tabbar if there's only one tab.
+ showBar(count() > 1);
+ }
+ return true;
+}
+
+
+void TabWorkArea::on_currentTabChanged(int i)
+{
+ GuiWorkArea * wa = dynamic_cast<GuiWorkArea *>(widget(i));
+ BOOST_ASSERT(wa);
+ BufferView & bv = wa->bufferView();
+ bv.cursor().fixIfBroken();
+ bv.updateMetrics();
+ wa->setUpdatesEnabled(true);
+ wa->redraw();
+ wa->setFocus();
+ ///
+ currentWorkAreaChanged(wa);
+
+ LYXERR(Debug::GUI, "currentTabChanged " << i
+ << "File" << bv.buffer().absFileName());
+}
+
+
+void TabWorkArea::closeCurrentTab()
+{
+ lyx::dispatch(FuncRequest(LFUN_BUFFER_CLOSE));
+}
+
+
+void TabWorkArea::updateTabText(GuiWorkArea * wa)
+{
+ int const i = indexOf(wa);
+ if (i < 0)
+ return;
+ setTabText(i, wa->windowTitle());
+}
+
} // namespace frontend
} // namespace lyx
projects / lyx.git / blobdiff