#include "paragraph_funcs.h"
#include "ParagraphParameters.h"
#include "pariterator.h"
-#include "rowpainter.h"
#include "toc.h"
#include "undo.h"
#include "vspace.h"
#include "frontends/font_metrics.h"
#include "frontends/Gui.h"
#include "frontends/LyXView.h"
-#include "frontends/WorkArea.h"
#include "graphics/Previews.h"
#include "support/convert.h"
#include "support/filefilterlist.h"
#include "support/filetools.h"
-#include "support/forkedcontr.h"
#include "support/package.h"
#include "support/types.h"
#include <functional>
#include <vector>
-using lyx::frontend::WorkArea;
using lyx::frontend::Clipboard;
using lyx::frontend::Gui;
using lyx::support::bformat;
using lyx::support::FileFilterList;
using lyx::support::fileSearch;
-using lyx::support::ForkedcallsController;
using lyx::support::isDirWriteable;
using lyx::support::makeDisplayPath;
using lyx::support::makeAbsPath;
unsigned int const saved_positions_num = 20;
-// All the below connection objects are needed because of a bug in some
-// versions of GCC (<=2.96 are on the suspects list.) By having and assigning
-// to these connections we avoid a segfault upon startup, and also at exit.
-// (Lgb)
-
-boost::signals::connection timecon;
-
/// Return an inset of this class if it exists at the current cursor position
template <class T>
T * getInsetByCode(LCursor & cur, InsetBase::Code code)
BufferView::Pimpl::Pimpl(BufferView & bv, LyXView * owner)
- : bv_(&bv), owner_(owner), buffer_(0), wh_(0), cursor_timeout(400),
+ : bv_(&bv), owner_(owner), buffer_(0), wh_(0),
cursor_(bv),
multiparsel_cache_(false), anchor_ref_(0), offset_ref_(0), needs_redraw_(false)
{
xsel_cache_.set = false;
- // Setup the signals
- timecon = cursor_timeout.timeout
- .connect(boost::bind(&BufferView::Pimpl::cursorToggle, this));
-
- cursor_timeout.start();
-
saved_positions.resize(saved_positions_num);
// load saved bookmarks
lyx::Session::BookmarkList & bmList = LyX::ref().session().loadBookmarks();
if (!buffer_)
return;
- owner_->gui().guiCursor().hide();
-
LyXText & t = *bv_->text();
float const bar = value / float(wh_ * t.paragraphs().size());
key_modifier::state state)
{
owner_->getLyXFunc().processKeySym(key, state);
-
- /* This is perhaps a bit of a hack. When we move
- * around, or type, it's nice to be able to see
- * the cursor immediately after the keypress. So
- * we reset the toggle timeout and force the visibility
- * of the cursor. Note we cannot do this inside
- * dispatch() itself, because that's called recursively.
- */
- if (available())
- owner_->gui().guiCursor().show(*bv_);
}
void BufferView::Pimpl::selectionLost()
{
if (available()) {
- owner_->gui().guiCursor().hide();
cursor_.clearSelection();
xsel_cache_.set = false;
}
}
-// Callback for cursor timer
-void BufferView::Pimpl::cursorToggle()
-{
- if (buffer_) {
- owner_->gui().guiCursor().toggle(*bv_);
-
- // Use this opportunity to deal with any child processes that
- // have finished but are waiting to communicate this fact
- // to the rest of LyX.
- ForkedcallsController & fcc = ForkedcallsController::get();
- fcc.handleCompletedProcesses();
- }
-
- cursor_timeout.restart();
-}
-
-
bool BufferView::Pimpl::available() const
{
return buffer_ && bv_->text();
if (!available())
return false;
- owner_->gui().guiCursor().hide();
-
// Either the inset under the cursor or the
// surrounding LyXText will handle this event.
update(Update::FitCursor | Update::MultiParSel);
}
- // See workAreaKeyPress
- cursor_timeout.restart();
- owner_->gui().guiCursor().show(*bv_);
-
// Skip these when selecting
if (cmd.action != LFUN_MOUSE_MOTION) {
owner_->updateLayoutChoice();
#include "metricsinfo.h"
#include "frontends/LyXKeySym.h"
-#include "frontends/Timeout.h"
#include "support/types.h"
///
void selectionLost();
///
- void cursorToggle();
- ///
bool available() const;
/// get the change at the cursor position
Change const getCurrentChange();
/// Estimated average par height for scrollbar
int wh_;
///
- Timeout cursor_timeout;
- ///
class Position {
public:
/// Filename
#include "graphics/GraphicsLoader.h"
#include "support/filetools.h" // LibFileSearch
+#include "support/forkedcontr.h"
#include <boost/utility.hpp>
#include <boost/bind.hpp>
#include <boost/signals/trackable.hpp>
using lyx::support::libFileSearch;
+using lyx::support::ForkedcallsController;
using std::endl;
using std::min;
using std::string;
+namespace {
+
+// All the below connection objects are needed because of a bug in some
+// versions of GCC (<=2.96 are on the suspects list.) By having and assigning
+// to these connections we avoid a segfault upon startup, and also at exit.
+// (Lgb)
+
+boost::signals::connection timecon;
+
+} // anon namespace
+
namespace lyx {
namespace frontend {
}
WorkArea::WorkArea(BufferView * buffer_view)
- : buffer_view_(buffer_view), greyed_out_(true)
+ : buffer_view_(buffer_view), greyed_out_(true),
+ cursor_visible_(false), cursor_timeout_(400)
{
// Start loading the pixmap as soon as possible
if (lyxrc.show_banner) {
splash.connect(boost::bind(&WorkArea::checkAndGreyOut, this));
splash.startLoading();
}
+
+ // Setup the signals
+ timecon = cursor_timeout_.timeout
+ .connect(boost::bind(&WorkArea::toggleCursor, this));
+
+ cursor_timeout_.start();
}
void WorkArea::processKeySym(LyXKeySymPtr key, key_modifier::state state)
{
+ hideCursor();
+
buffer_view_->workAreaKeyPress(key, state);
+ /* This is perhaps a bit of a hack. When we move
+ * around, or type, it's nice to be able to see
+ * the cursor immediately after the keypress. So
+ * we reset the toggle timeout and force the visibility
+ * of the cursor. Note we cannot do this inside
+ * dispatch() itself, because that's called recursively.
+ */
+ // if (buffer_view_->available())
+ toggleCursor();
+
}
getPainter().end();
}
+
+void WorkArea::showCursor()
+{
+ if (cursor_visible_)
+ return;
+
+ if (!buffer_view_->available())
+ return;
+
+ CursorShape shape = BAR_SHAPE;
+
+ LyXText const & text = *buffer_view_->getLyXText();
+ LyXFont const & realfont = text.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;
+
+ LyXFont const font = buffer_view_->cursor().getFont();
+ int const asc = font_metrics::maxAscent(font);
+ int const des = font_metrics::maxDescent(font);
+ 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 >= height())
+ return;
+
+ cursor_visible_ = true;
+ showCursor(x, y, h, shape);
+}
+
+
+void WorkArea::hideCursor()
+{
+ if (!cursor_visible_)
+ return;
+
+ cursor_visible_ = false;
+ removeCursor();
+}
+
+
+void WorkArea::toggleCursor()
+{
+ if (buffer_view_->buffer()) {
+
+ 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.
+ ForkedcallsController & fcc = ForkedcallsController::get();
+ fcc.handleCompletedProcesses();
+ }
+
+ cursor_timeout_.restart();
+}
+
+
} // namespace frontend
} // namespace lyx
#include "frontends/key_state.h"
#include "frontends/LyXKeySym.h"
+#include "frontends/Timeout.h"
class BufferView;
/// hide the cursor
virtual void removeCursor() = 0;
+ /// Show the cursor
+ void showCursor();
+ /// Hide the cursor
+ void hideCursor();
+ /// toggle the cursor's visibility
+ void toggleCursor();
+
protected:
/// cause the display of the given area of the work area
virtual void expose(int x, int y, int w, int h) = 0;
///
bool greyed_out_;
+
+ ///
+ bool cursor_visible_;
+
+ ///
+ Timeout cursor_timeout_;
};
} // namespace frontend
<< endl;
setErrorMessage(flag.message());
} else {
-
- if (view()->available())
- view()->hideCursor();
-
switch (action) {
case LFUN_WORD_FIND_FORWARD:
projects / lyx.git / commitdiff