#include "FuncCode.h"
#include "FuncRequest.h"
#include "Language.h"
+#include "Layout.h"
#include "LyXAction.h"
#include "LyXRC.h"
#include "Paragraph.h"
#include "TextMetrics.h"
#include "TocBackend.h"
-#include "support/lassert.h"
#include "support/debug.h"
#include "support/docstream.h"
+#include "support/ExceptionMessage.h"
+#include "support/gettext.h"
+#include "support/lassert.h"
#include "insets/InsetTabular.h"
#include "insets/InsetText.h"
#include "mathed/MathData.h"
#include "mathed/MathMacro.h"
-#include <boost/bind.hpp>
+#include "support/bind.h"
#include <sstream>
#include <limits>
#include <map>
+#include <algorithm>
using namespace std;
int xo;
int yo;
Inset const * inset = &it.inset();
- map<Inset const *, Geometry> const & data =
- c.bv().coordCache().getInsets().getData();
- map<Inset const *, Geometry>::const_iterator I = data.find(inset);
+ CoordCache const & cache = c.bv().coordCache();
// FIXME: in the case where the inset is not in the cache, this
// means that no part of it is visible on screen. In this case
// we don't do elaborate search and we just return the forwarded
// DocIterator at its beginning.
- if (I == data.end()) {
+ if (!cache.getInsets().has(inset)) {
it.top().pos() = 0;
return it;
}
- Point o = I->second.pos;
+ Point const o = cache.getInsets().xy(inset);
inset->cursorPos(c.bv(), it.top(), c.boundary(), xo, yo);
// Convert to absolute
xo += o.x_;
else
++et.pit();
- double best_dist = numeric_limits<double>::max();;
+ double best_dist = numeric_limits<double>::max();
DocIterator best_cursor = et;
for ( ; it != et; it.forwardPos(true)) {
}
*/
-
+/*
/// moves position closest to (x, y) in given box
bool bruteFind3(Cursor & cur, int x, int y, bool up)
{
for ( ; it != et; it.forwardPos()) {
// avoid invalid nesting when selecting
if (bv.cursorStatus(it) == CUR_INSIDE
- && (!cur.selection() || positionable(it, cur.anchor_))) {
- Point p = bv.getPos(it, false);
+ && (!cur.selection() || positionable(it, cur.realAnchor()))) {
+ // If this function is ever used again, check
+ // whether this is the same as "bv.getPos(it,
+ // false)" with boundary = false.
+ Point p = bv.getPos(it);
int xo = p.x_;
int yo = p.y_;
if (xlow <= xo && xo <= xhigh && ylow <= yo && yo <= yhigh) {
cur.setCursor(best_cursor);
return true;
}
-
+*/
} // namespace anon
+CursorData::CursorData()
+ : DocIterator(), anchor_(),
+ selection_(false), mark_(false), word_selection_(false),
+ logicalpos_(false), current_font(inherit_font)
+{}
+
+
+CursorData::CursorData(Buffer * buffer)
+ : DocIterator(buffer), anchor_(),
+ selection_(false), mark_(false), word_selection_(false),
+ logicalpos_(false), current_font(inherit_font)
+{}
+
+
+CursorData::CursorData(DocIterator const & dit)
+ : DocIterator(dit), anchor_(),
+ selection_(false), mark_(false), word_selection_(false),
+ logicalpos_(false), current_font(inherit_font)
+{}
+
+
// be careful: this is called from the bv's constructor, too, so
// bv functions are not yet available!
Cursor::Cursor(BufferView & bv)
- : DocIterator(&bv.buffer()), bv_(&bv), anchor_(),
- x_target_(-1), textTargetOffset_(0),
- selection_(false), mark_(false), word_selection_(false),
- logicalpos_(false), current_font(inherit_font)
+ : CursorData(&bv.buffer()), bv_(&bv),
+ x_target_(-1), textTargetOffset_(0)
{}
push_back(CursorSlice(buffer()->inset()));
anchor_ = doc_iterator_begin(buffer());
anchor_.clear();
+ new_word_ = doc_iterator_begin(buffer());
+ new_word_.clear();
clearTargetX();
selection_ = false;
mark_ = false;
}
+void Cursor::setCursorToAnchor()
+{
+ if (selection()) {
+ DocIterator normal = anchor_;
+ while (depth() < normal.depth())
+ normal.pop_back();
+ if (depth() < anchor_.depth() && top() <= anchor_[depth() - 1])
+ ++normal.pos();
+ setCursor(normal);
+ }
+}
+
+
+void Cursor::setCursorData(CursorData const & data)
+{
+ CursorData::operator=(data);
+}
+
+
bool Cursor::getStatus(FuncRequest const & cmd, FuncStatus & status) const
{
Cursor cur = *this;
// Is this a function that acts on inset at point?
Inset * inset = cur.nextInset();
- if (lyxaction.funcHasFlag(cmd.action, LyXAction::AtPoint)
+ if (lyxaction.funcHasFlag(cmd.action(), LyXAction::AtPoint)
&& inset && inset->getStatus(cur, cmd, status))
return true;
bool res = false;
for ( ; cur.depth(); cur.pop()) {
//lyxerr << "\nCursor::getStatus: cmd: " << cmd << endl << *this << endl;
+ // LASSERT: Is it safe to continue here, or should we return?
LASSERT(cur.idx() <= cur.lastidx(), /**/);
LASSERT(cur.pit() <= cur.lastpit(), /**/);
LASSERT(cur.pos() <= cur.lastpos(), /**/);
fixIfBroken();
FuncRequest cmd = cmd0;
Cursor safe = *this;
+ Cursor old = *this;
+ disp_ = DispatchResult();
+
+ beginUndoGroup();
- buffer()->undo().beginUndoGroup();
-
// Is this a function that acts on inset at point?
- if (lyxaction.funcHasFlag(cmd.action, LyXAction::AtPoint)
+ if (lyxaction.funcHasFlag(cmd.action(), LyXAction::AtPoint)
&& nextInset()) {
- result().dispatched(true);
- result().update(Update::FitCursor | Update::Force);
+ disp_.dispatched(true);
+ disp_.screenUpdate(Update::FitCursor | Update::Force);
FuncRequest tmpcmd = cmd;
LYXERR(Debug::DEBUG, "Cursor::dispatch: (AtPoint) cmd: "
<< cmd0 << endl << *this);
nextInset()->dispatch(*this, tmpcmd);
- if (result().dispatched()) {
- buffer()->undo().endUndoGroup();
+ if (disp_.dispatched()) {
+ endUndoGroup();
return;
}
}
for (; depth(); pop(), boundary(false)) {
LYXERR(Debug::DEBUG, "Cursor::dispatch: cmd: "
<< cmd0 << endl << *this);
+ // LASSERT: Is it safe to continue here, or should we return?
LASSERT(pos() <= lastpos(), /**/);
LASSERT(idx() <= lastidx(), /**/);
LASSERT(pit() <= lastpit(), /**/);
// The common case is 'LFUN handled, need update', so make the
// LFUN handler's life easier by assuming this as default value.
// The handler can reset the update and val flags if necessary.
- disp_.update(Update::FitCursor | Update::Force);
+ disp_.screenUpdate(Update::FitCursor | Update::Force);
disp_.dispatched(true);
inset().dispatch(*this, cmd);
if (disp_.dispatched())
safe.pos() = safe.lastpos();
}
operator=(safe);
- disp_.update(Update::None);
+ disp_.screenUpdate(Update::None);
disp_.dispatched(false);
} else {
// restore the previous one because nested Cursor::dispatch calls
// are possible which would change it
beforeDispatchCursor_ = safe.beforeDispatchCursor_;
}
- buffer()->undo().endUndoGroup();
+ endUndoGroup();
+
+ // notify insets we just left
+ if (*this != old) {
+ old.beginUndoGroup();
+ old.fixIfBroken();
+ bool badcursor = notifyCursorLeavesOrEnters(old, *this);
+ if (badcursor) {
+ fixIfBroken();
+ bv().resetInlineCompletionPos();
+ }
+ old.endUndoGroup();
+ }
}
-DispatchResult Cursor::result() const
+DispatchResult const & Cursor::result() const
{
return disp_;
}
BufferView & Cursor::bv() const
{
- LASSERT(bv_, /**/);
+ LBUFERR(bv_);
return *bv_;
}
void Cursor::pop()
{
- LASSERT(depth() >= 1, /**/);
+ LBUFERR(depth() >= 1);
pop_back();
}
int Cursor::currentMode()
{
- LASSERT(!empty(), /**/);
+ LASSERT(!empty(), return Inset::UNDECIDED_MODE);
for (int i = depth() - 1; i >= 0; --i) {
int res = operator[](i).inset().currentMode();
bool locked_mode = operator[](i).inset().lockedMode();
void Cursor::getPos(int & x, int & y) const
{
- Point p = bv().getPos(*this, boundary());
+ Point p = bv().getPos(*this);
x = p.x_;
y = p.y_;
}
{
CursorSlice const & cs = innerTextSlice();
ParagraphMetrics const & pm = bv().parMetrics(cs.text(), cs.pit());
- LASSERT(!pm.rows().empty(), /**/);
return pm.getRow(pos(), boundary());
}
void Cursor::resetAnchor()
{
anchor_ = *this;
+ checkNewWordPosition();
}
-void Cursor::setCursorToAnchor()
+void Cursor::markNewWordPosition()
{
- if (selection()) {
- DocIterator normal = anchor_;
- while (depth() < normal.depth())
- normal.pop_back();
- if (depth() < anchor_.depth() && top() <= anchor_[depth() - 1])
- ++normal.pos();
- setCursor(normal);
+ if (lyxrc.spellcheck_continuously && inTexted() && new_word_.empty()) {
+ FontSpan nw = locateWord(WHOLE_WORD);
+ if (nw.size() == 1) {
+ LYXERR(Debug::DEBUG, "start new word: "
+ << " par: " << pit()
+ << " pos: " << nw.first);
+ new_word_ = *this;
+ }
+ }
+}
+
+
+void Cursor::clearNewWordPosition()
+{
+ if (!new_word_.empty()) {
+ LYXERR(Debug::DEBUG, "clear new word: "
+ << " par: " << pit()
+ << " pos: " << pos());
+ new_word_.resize(0);
+ }
+}
+
+
+void Cursor::checkNewWordPosition()
+{
+ if (!lyxrc.spellcheck_continuously || new_word_.empty())
+ return ;
+ if (!inTexted())
+ clearNewWordPosition();
+ else {
+ // forget the position of the current new word if
+ // 1) the paragraph changes or
+ // 2) the count of nested insets changes or
+ // 3) the cursor pos is out of paragraph bound
+ if (pit() != new_word_.pit() ||
+ depth() != new_word_.depth() ||
+ new_word_.pos() > new_word_.lastpos()) {
+ clearNewWordPosition();
+ } else if (new_word_.fixIfBroken())
+ // 4) or the remembered position was "broken"
+ clearNewWordPosition();
+ else {
+ FontSpan nw = locateWord(WHOLE_WORD);
+ if (!nw.empty()) {
+ FontSpan ow = new_word_.locateWord(WHOLE_WORD);
+ if (nw.intersect(ow).empty())
+ clearNewWordPosition();
+ else
+ LYXERR(Debug::DEBUG, "new word: "
+ << " par: " << pit()
+ << " pos: " << nw.first << ".." << nw.last);
+ } else {
+ clearNewWordPosition();
+ }
+ }
}
}
new_cur.boundary(false);
if (!skip_inset &&
text()->checkAndActivateInsetVisual(new_cur, right_pos >= pos(), false)) {
- // we actually move the cursor at the end of this function, for now
- // we just keep track of the new position in new_cur...
+ // we actually move the cursor at the end of this
+ // function, for now we just keep track of the new
+ // position in new_cur...
LYXERR(Debug::RTL, "entering inset at: " << new_cur.pos());
}
return false;
}
- // we actually move the cursor at the end of this function, for now
- // just keep track of the new position in new_cur...
+ // we actually move the cursor at the end of this
+ // function, for now just keep track of the new
+ // position in new_cur...
LYXERR(Debug::RTL, "right edge, moving: " << int(new_cur.pit()) << ","
<< int(new_cur.pos()) << "," << (new_cur.boundary() ? 1 : 0));
// normal movement to the right
else {
new_cur = *this;
- // Recall, if the cursor is at position 'x', that means *before*
- // the character at position 'x'. In RTL, "before" means "to the
- // right of", in LTR, "to the left of". So currently our situation
- // is this: the position to our right is 'right_pos' (i.e., we're
- // currently to the left of 'right_pos'). In order to move to the
- // right, it depends whether or not the character at 'right_pos' is RTL.
+ // Recall, if the cursor is at position 'x', that
+ // means *before* the character at position 'x'. In
+ // RTL, "before" means "to the right of", in LTR, "to
+ // the left of". So currently our situation is this:
+ // the position to our right is 'right_pos' (i.e.,
+ // we're currently to the left of 'right_pos'). In
+ // order to move to the right, it depends whether or
+ // not the character at 'right_pos' is RTL.
new_pos_is_RTL = paragraph().getFontSettings(
buffer()->params(), right_pos).isVisibleRightToLeft();
- // If the character at 'right_pos' *is* LTR, then in order to move to
- // the right of it, we need to be *after* 'right_pos', i.e., move to
- // position 'right_pos' + 1.
+ // If the character at 'right_pos' *is* LTR, then in
+ // order to move to the right of it, we need to be
+ // *after* 'right_pos', i.e., move to position
+ // 'right_pos' + 1.
if (!new_pos_is_RTL) {
new_cur.pos() = right_pos + 1;
// set the boundary to true in two situations:
if (
- // 1. if new_pos is now lastpos, and we're in an RTL paragraph
- // (this means that we're moving right to the end of an LTR chunk
+ // 1. if new_pos is now lastpos, and we're in
+ // an RTL paragraph (this means that we're
+ // moving right to the end of an LTR chunk
// which is at the end of an RTL paragraph);
(new_cur.pos() == lastpos()
&& paragraph().isRTL(buffer()->params()))
- // 2. if the position *after* right_pos is RTL (we want to be
- // *after* right_pos, not before right_pos + 1!)
+ // 2. if the position *after* right_pos is RTL
+ // (we want to be *after* right_pos, not
+ // before right_pos + 1!)
|| paragraph().getFontSettings(buffer()->params(),
new_cur.pos()).isVisibleRightToLeft()
)
else // set the boundary to false
new_cur.boundary(false);
}
- // Otherwise (if the character at position 'right_pos' is RTL), then
- // moving to the right of it is as easy as setting the new position
- // to 'right_pos'.
+ // Otherwise (if the character at position 'right_pos'
+ // is RTL), then moving to the right of it is as easy
+ // as setting the new position to 'right_pos'.
else {
new_cur.pos() = right_pos;
new_cur.boundary(false);
new_cur.boundary(false);
if (!skip_inset &&
text()->checkAndActivateInsetVisual(new_cur, left_pos >= pos(), true)) {
- // we actually move the cursor at the end of this function, for now
- // we just keep track of the new position in new_cur...
+ // we actually move the cursor at the end of this
+ // function, for now we just keep track of the new
+ // position in new_cur...
LYXERR(Debug::RTL, "entering inset at: " << new_cur.pos());
}
return false;
}
- // we actually move the cursor at the end of this function, for now
- // just keep track of the new position in new_cur...
+ // we actually move the cursor at the end of this
+ // function, for now just keep track of the new
+ // position in new_cur...
LYXERR(Debug::RTL, "left edge, moving: " << int(new_cur.pit()) << ","
<< int(new_cur.pos()) << "," << (new_cur.boundary() ? 1 : 0));
// normal movement to the left
else {
new_cur = *this;
- // Recall, if the cursor is at position 'x', that means *before*
- // the character at position 'x'. In RTL, "before" means "to the
- // right of", in LTR, "to the left of". So currently our situation
- // is this: the position to our left is 'left_pos' (i.e., we're
- // currently to the right of 'left_pos'). In order to move to the
- // left, it depends whether or not the character at 'left_pos' is RTL.
+ // Recall, if the cursor is at position 'x', that
+ // means *before* the character at position 'x'. In
+ // RTL, "before" means "to the right of", in LTR, "to
+ // the left of". So currently our situation is this:
+ // the position to our left is 'left_pos' (i.e., we're
+ // currently to the right of 'left_pos'). In order to
+ // move to the left, it depends whether or not the
+ // character at 'left_pos' is RTL.
new_pos_is_RTL = paragraph().getFontSettings(
buffer()->params(), left_pos).isVisibleRightToLeft();
- // If the character at 'left_pos' *is* RTL, then in order to move to
- // the left of it, we need to be *after* 'left_pos', i.e., move to
- // position 'left_pos' + 1.
+ // If the character at 'left_pos' *is* RTL, then in
+ // order to move to the left of it, we need to be
+ // *after* 'left_pos', i.e., move to position
+ // 'left_pos' + 1.
if (new_pos_is_RTL) {
new_cur.pos() = left_pos + 1;
// set the boundary to true in two situations:
if (
- // 1. if new_pos is now lastpos and we're in an LTR paragraph
- // (this means that we're moving left to the end of an RTL chunk
+ // 1. if new_pos is now lastpos and we're in
+ // an LTR paragraph (this means that we're
+ // moving left to the end of an RTL chunk
// which is at the end of an LTR paragraph);
(new_cur.pos() == lastpos()
&& !paragraph().isRTL(buffer()->params()))
- // 2. if the position *after* left_pos is not RTL (we want to be
- // *after* left_pos, not before left_pos + 1!)
+ // 2. if the position *after* left_pos is not
+ // RTL (we want to be *after* left_pos, not
+ // before left_pos + 1!)
|| !paragraph().getFontSettings(buffer()->params(),
new_cur.pos()).isVisibleRightToLeft()
)
else // set the boundary to false
new_cur.boundary(false);
}
- // Otherwise (if the character at position 'left_pos' is LTR), then
- // moving to the left of it is as easy as setting the new position
- // to 'left_pos'.
+ // Otherwise (if the character at position 'left_pos'
+ // is LTR), then moving to the left of it is as easy
+ // as setting the new position to 'left_pos'.
else {
new_cur.pos() = left_pos;
new_cur.boundary(false);
LYXERR(Debug::RTL, "bidi: " << row.pos() << "--" << row.endpos());
- // The cursor is painted *before* the character at pos(), or, if 'boundary'
- // is true, *after* the character at (pos() - 1). So we already have one
- // known position around the cursor:
+ // The cursor is painted *before* the character at pos(), or,
+ // if 'boundary' is true, *after* the character at (pos() -
+ // 1). So we already have one known position around the
+ // cursor:
pos_type const known_pos = boundary() && pos() > 0 ? pos() - 1 : pos();
- // edge case: if we're at the end of the paragraph, things are a little
- // different (because lastpos is a position which does not really "exist"
- // --- there's no character there yet).
+ // edge case: if we're at the end of the paragraph, things are
+ // a little different (because lastpos is a position which
+ // does not really "exist" --- there's no character there
+ // yet).
if (known_pos == lastpos()) {
if (par.isRTL(buf.params())) {
left_pos = -1;
return;
}
- // Whether 'known_pos' is to the left or to the right of the cursor depends
- // on whether it is an RTL or LTR character...
+ // Whether 'known_pos' is to the left or to the right of the
+ // cursor depends on whether it is an RTL or LTR character...
bool const cur_is_RTL =
par.getFontSettings(buf.params(), known_pos).isVisibleRightToLeft();
// ... in the following manner:
- // For an RTL character, "before" means "to the right" and "after" means
- // "to the left"; and for LTR, it's the reverse. So, 'known_pos' is to the
- // right of the cursor if (RTL && boundary) or (!RTL && !boundary):
+ // For an RTL character, "before"
+ // means "to the right" and "after" means "to the left"; and
+ // for LTR, it's the reverse. So, 'known_pos' is to the right
+ // of the cursor if (RTL && boundary) or (!RTL && !boundary):
bool const known_pos_on_right = cur_is_RTL == boundary();
- // So we now know one of the positions surrounding the cursor. Let's
- // determine the other one:
+ // So we now know one of the positions surrounding the cursor.
+ // Let's determine the other one:
if (known_pos_on_right) {
right_pos = known_pos;
// *visual* position of 'left_pos':
pos_type v_left_pos = bidi.log2vis(right_pos) - 1;
- // If the position we just identified as 'left_pos' is a "skipped
- // separator" (a separator which is at the logical end of a row,
- // except for the last row in a paragraph; such separators are not
- // painted, so they "are not really there"; note that in bidi text,
- // such a separator could appear visually in the middle of a row),
- // set 'left_pos' to the *next* position to the left.
+ // If the position we just identified as 'left_pos' is
+ // a "skipped separator" (a separator which is at the
+ // logical end of a row, except for the last row in a
+ // paragraph; such separators are not painted, so they
+ // "are not really there"; note that in bidi text,
+ // such a separator could appear visually in the
+ // middle of a row), set 'left_pos' to the *next*
+ // position to the left.
if (bidi.inRange(v_left_pos)
&& bidi.vis2log(v_left_pos) + 1 == row.endpos()
&& row.endpos() < lastpos()
left_pos = -1;
else
left_pos = bidi.vis2log(v_left_pos);
- // If the position we identified as 'right_pos' is a "skipped
- // separator", set 'right_pos' to the *next* position to the right.
+ // If the position we identified as 'right_pos' is a
+ // "skipped separator", set 'right_pos' to the *next*
+ // position to the right.
if (right_pos + 1 == row.endpos() && row.endpos() < lastpos()
&& par.isSeparator(right_pos)) {
pos_type const v_right_pos = bidi.log2vis(right_pos) + 1;
left_pos = known_pos;
// *visual* position of 'right_pos'
pos_type v_right_pos = bidi.log2vis(left_pos) + 1;
- // If the position we just identified as 'right_pos' is a "skipped
- // separator", set 'right_pos' to the *next* position to the right.
+ // If the position we just identified as 'right_pos'
+ // is a "skipped separator", set 'right_pos' to the
+ // *next* position to the right.
if (bidi.inRange(v_right_pos)
&& bidi.vis2log(v_right_pos) + 1 == row.endpos()
&& row.endpos() < lastpos()
right_pos = -1;
else
right_pos = bidi.vis2log(v_right_pos);
- // If the position we identified as 'left_pos' is a "skipped
- // separator", set 'left_pos' to the *next* position to the left.
+ // If the position we identified as 'left_pos' is a
+ // "skipped separator", set 'left_pos' to the *next*
+ // position to the left.
if (left_pos + 1 == row.endpos() && row.endpos() < lastpos()
&& par.isSeparator(left_pos)) {
pos_type const v_left_pos = bidi.log2vis(left_pos) - 1;
Row const & row = textRow();
bool par_is_LTR = !par.isRTL(buf.params());
- // Inside a table, determining whether to move to the next or previous row
- // should be done based on the table's direction.
+ // Inside a table, determining whether to move to the next or
+ // previous row should be done based on the table's direction.
int s = depth() - 1;
if (s >= 1 && (*this)[s].inset().asInsetTabular()) {
par_is_LTR = !(*this)[s].inset().asInsetTabular()->isRightToLeft(*this);
LYXERR(Debug::RTL, "Inside table! par_is_LTR=" << (par_is_LTR ? 1 : 0));
}
- // if moving left in an LTR paragraph or moving right in an RTL one,
- // move to previous row
+ // if moving left in an LTR paragraph or moving right in an
+ // RTL one, move to previous row
if (par_is_LTR == movingLeft) {
if (row.pos() == 0) { // we're at first row in paragraph
if (pit() == 0) // no previous paragraph! don't move
boundary(false);
}
}
- // if moving left in an RTL paragraph or moving right in an LTR one,
- // move to next row
+ // if moving left in an RTL paragraph or moving right in an
+ // LTR one, move to next row
else {
if (row.endpos() == lastpos()) { // we're at last row in paragraph
if (pit() == lastpit()) // last paragraph! don't move
else {
pos() = bidi.vis2log(row.pos());
- // Moving to the leftmost position in the row, the cursor should
- // normally be placed to the *left* of the leftmost position.
- // A very common exception, though, is if the leftmost character
- // also happens to be the separator at the (logical) end of the row
- // --- in this case, the separator is positioned beyond the left
- // margin, and we don't want to move the cursor there (moving to
- // the left of the separator is equivalent to moving to the next
- // line). So, in this case we actually want to place the cursor
- // to the *right* of the leftmost position (the separator).
- // Another exception is if we're moving to the logically last
- // position in the row, which is *not* a separator: this means
- // that the entire row has no separators (if there were any, the
- // row would have been broken there); and therefore in this case
- // we also move to the *right* of the last position (this indicates
- // to the user that there is no space after this position, and is
- // consistent with the behavior in the middle of a row --- moving
- // right or left moves to the next/previous character; if we were
- // to move to the *left* of this position, that would simulate
- // a separator which is not really there!).
- // Finally, there is an exception to the previous exception: if
- // this non-separator-but-last-position-in-row is an inset, then
- // we *do* want to stay to the left of it anyway: this is the
+ // Moving to the leftmost position in the row,
+ // the cursor should normally be placed to the
+ // *left* of the leftmost position. A very
+ // common exception, though, is if the
+ // leftmost character also happens to be the
+ // separator at the (logical) end of the row
+ // --- in this case, the separator is
+ // positioned beyond the left margin, and we
+ // don't want to move the cursor there (moving
+ // to the left of the separator is equivalent
+ // to moving to the next line). So, in this
+ // case we actually want to place the cursor
+ // to the *right* of the leftmost position
+ // (the separator). Another exception is if
+ // we're moving to the logically last position
+ // in the row, which is *not* a separator:
+ // this means that the entire row has no
+ // separators (if there were any, the row
+ // would have been broken there); and
+ // therefore in this case we also move to the
+ // *right* of the last position (this
+ // indicates to the user that there is no
+ // space after this position, and is
+ // consistent with the behavior in the middle
+ // of a row --- moving right or left moves to
+ // the next/previous character; if we were to
+ // move to the *left* of this position, that
+ // would simulate a separator which is not
+ // really there!). Finally, there is an
+ // exception to the previous exception: if
+ // this non-separator-but-last-position-in-row
+ // is an inset, then we *do* want to stay to
+ // the left of it anyway: this is the
// "boundary" which we simulate at insets.
- // Another exception is when row.endpos() is 0.
+
+ // Another exception is when row.endpos() is
+ // 0.
// do we want to be to the right of pos?
// as explained above, if at last pos in row, stay to the right
else {
pos() = row.endpos() > 0 ? bidi.vis2log(row.endpos() - 1) : 0;
- // Moving to the rightmost position in the row, the cursor should
- // normally be placed to the *right* of the rightmost position.
- // A very common exception, though, is if the rightmost character
- // also happens to be the separator at the (logical) end of the row
- // --- in this case, the separator is positioned beyond the right
- // margin, and we don't want to move the cursor there (moving to
- // the right of the separator is equivalent to moving to the next
- // line). So, in this case we actually want to place the cursor
- // to the *left* of the rightmost position (the separator).
- // Another exception is if we're moving to the logically last
- // position in the row, which is *not* a separator: this means
- // that the entire row has no separators (if there were any, the
- // row would have been broken there); and therefore in this case
- // we also move to the *left* of the last position (this indicates
- // to the user that there is no space after this position, and is
- // consistent with the behavior in the middle of a row --- moving
- // right or left moves to the next/previous character; if we were
- // to move to the *right* of this position, that would simulate
- // a separator which is not really there!).
- // Finally, there is an exception to the previous exception: if
- // this non-separator-but-last-position-in-row is an inset, then
- // we *do* want to stay to the right of it anyway: this is the
- // "boundary" which we simulate at insets.
- // Another exception is when row.endpos() is 0.
+ // Moving to the rightmost position in the
+ // row, the cursor should normally be placed
+ // to the *right* of the rightmost position. A
+ // very common exception, though, is if the
+ // rightmost character also happens to be the
+ // separator at the (logical) end of the row
+ // --- in this case, the separator is
+ // positioned beyond the right margin, and we
+ // don't want to move the cursor there (moving
+ // to the right of the separator is equivalent
+ // to moving to the next line). So, in this
+ // case we actually want to place the cursor
+ // to the *left* of the rightmost position
+ // (the separator). Another exception is if
+ // we're moving to the logically last position
+ // in the row, which is *not* a separator:
+ // this means that the entire row has no
+ // separators (if there were any, the row
+ // would have been broken there); and
+ // therefore in this case we also move to the
+ // *left* of the last position (this indicates
+ // to the user that there is no space after
+ // this position, and is consistent with the
+ // behavior in the middle of a row --- moving
+ // right or left moves to the next/previous
+ // character; if we were to move to the
+ // *right* of this position, that would
+ // simulate a separator which is not really
+ // there!). Finally, there is an exception to
+ // the previous exception: if this
+ // non-separator-but-last-position-in-row is
+ // an inset, then we *do* want to stay to the
+ // right of it anyway: this is the "boundary"
+ // which we simulate at insets. Another
+ // exception is when row.endpos() is 0.
// do we want to be to the left of pos?
// as explained above, if at last pos in row, stay to the left,
}
-CursorSlice Cursor::anchor() const
+CursorSlice Cursor::normalAnchor() const
{
if (!selection())
return top();
- LASSERT(anchor_.depth() >= depth(), /**/);
+ // LASSERT: There have been several bugs around this code, that seem
+ // to involve failures to reset the anchor. We can at least not crash
+ // in release mode by resetting it ourselves.
+ LASSERT(anchor_.depth() >= depth(),
+ const_cast<DocIterator &>(anchor_) = *this);
+
CursorSlice normal = anchor_[depth() - 1];
if (depth() < anchor_.depth() && top() <= normal) {
// anchor is behind cursor -> move anchor behind the inset
}
+DocIterator & Cursor::realAnchor()
+{
+ return anchor_;
+}
+
+
CursorSlice Cursor::selBegin() const
{
if (!selection())
return top();
- return anchor() < top() ? anchor() : top();
+ return normalAnchor() < top() ? normalAnchor() : top();
}
{
if (!selection())
return top();
- return anchor() > top() ? anchor() : top();
+ return normalAnchor() > top() ? normalAnchor() : top();
}
DocIterator di;
// FIXME: This is a work-around for the problem that
// CursorSlice doesn't keep track of the boundary.
- if (anchor() == top())
+ if (normalAnchor() == top())
di = anchor_.boundary() > boundary() ? anchor_ : *this;
else
- di = anchor() < top() ? anchor_ : *this;
+ di = normalAnchor() < top() ? anchor_ : *this;
di.resize(depth());
return di;
}
DocIterator di;
// FIXME: This is a work-around for the problem that
// CursorSlice doesn't keep track of the boundary.
- if (anchor() == top())
+ if (normalAnchor() == top())
di = anchor_.boundary() < boundary() ? anchor_ : *this;
else
- di = anchor() > top() ? anchor_ : *this;
+ di = normalAnchor() > top() ? anchor_ : *this;
if (di.depth() > depth()) {
di.resize(depth());
setSelection(true);
// A selection with no contents is not a selection
// FIXME: doesnt look ok
- if (idx() == anchor().idx() &&
- pit() == anchor().pit() &&
- pos() == anchor().pos())
+ if (idx() == normalAnchor().idx() &&
+ pit() == normalAnchor().pit() &&
+ pos() == normalAnchor().pos())
setSelection(false);
}
namespace lyx {
-//#define FILEDEBUG 1
-
-
bool Cursor::isInside(Inset const * p) const
{
for (size_t i = 0; i != depth(); ++i)
++pos();
inset().setBuffer(bv_->buffer());
inset().initView();
+ forceBufferUpdate();
}
void Cursor::insert(docstring const & str)
{
for_each(str.begin(), str.end(),
- boost::bind(static_cast<void(Cursor::*)(char_type)>
+ bind(static_cast<void(Cursor::*)(char_type)>
(&Cursor::insert), this, _1));
}
void Cursor::insert(char_type c)
{
//lyxerr << "Cursor::insert char '" << c << "'" << endl;
- LASSERT(!empty(), /**/);
+ LASSERT(!empty(), return);
if (inMathed()) {
cap::selClearOrDel(*this);
insert(new InsetMathChar(c));
void Cursor::insert(Inset * inset0)
{
- LASSERT(inset0, /**/);
+ LASSERT(inset0, return);
if (inMathed())
- insert(MathAtom(inset0));
+ insert(MathAtom(inset0->asInsetMath()));
else {
text()->insertInset(*this, inset0);
inset0->setBuffer(bv_->buffer());
inset0->initView();
+ if (inset0->isLabeled())
+ forceBufferUpdate();
}
}
-void Cursor::niceInsert(docstring const & t, Parse::flags f, bool enter)
+int Cursor::niceInsert(docstring const & t, Parse::flags f, bool enter)
{
MathData ar(buffer());
asArray(t, ar, f);
niceInsert(ar[0]);
else
insert(ar);
+ return ar.size();
}
MathData ar(buffer());
asArray(safe, ar);
insert(ar);
+ } else if (t->asMacro() && !safe.empty()) {
+ MathData ar(buffer());
+ asArray(safe, ar);
+ docstring const name = t->asMacro()->name();
+ MacroData const * data = buffer()->getMacro(name);
+ if (data && data->numargs() - data->optionals() > 0) {
+ plainInsert(MathAtom(new InsetMathBrace(ar)));
+ posBackward();
+ }
}
}
cap::eraseSelection(*this);
cell().insert(pos(), ar);
pos() += ar.size();
- // FIXME audit setBuffer/updateLabels calls
+ // FIXME audit setBuffer calls
inset().setBuffer(bv_->buffer());
}
bool Cursor::backspace()
{
- autocorrect() = false;
-
if (selection()) {
cap::eraseSelection(*this);
return true;
bool Cursor::erase()
{
- autocorrect() = false;
if (inMacroMode())
return true;
if (disp_.dispatched())
return true;
setCursor(save);
- autocorrect() = false;
return false;
}
if (disp_.dispatched())
return true;
setCursor(save);
- autocorrect() = false;
return false;
}
// trigger updates of macros, at least, if no full
// updates take place anyway
- updateFlags(Update::Force);
+ screenUpdateFlags(Update::Force);
docstring const name = s.substr(1);
InsetMathNest * const in = inset().asInsetMath()->asNestInset();
// we have to resolve the macro here manually and check its arity
// to put the selection behind it if arity > 0.
MacroData const * data = buffer()->getMacro(atomAsMacro->name());
- if (selection.size() > 0 && data && data->numargs() - data->optionals() > 0) {
+ if (!selection.empty() && data && data->numargs() - data->optionals() > 0) {
macroArg = true;
atomAsMacro->setDisplayMode(MathMacro::DISPLAY_INTERACTIVE_INIT, 1);
} else
{
if (!inMathed())
return false;
- if (pos() == 0)
+ if (pos() == 0 || cell().empty())
return false;
InsetMathUnknown const * p = prevAtom()->asUnknownInset();
return p && !p->final();
return false;
}
+
bool Cursor::upDownInText(bool up, bool & updateNeeded)
{
- LASSERT(text(), /**/);
+ LASSERT(text(), return false);
// where are we?
int xo = 0;
setTargetX(xo);
else if (xo - textTargetOffset() != x_target() &&
depth() == beforeDispatchCursor_.depth()) {
- // In text mode inside the line (not left or right) possibly set a new target_x,
- // but only if we are somewhere else than the previous target-offset.
+ // In text mode inside the line (not left or right)
+ // possibly set a new target_x, but only if we are
+ // somewhere else than the previous target-offset.
- // We want to keep the x-target on subsequent up/down movements
- // that cross beyond the end of short lines. Thus a special
- // handling when the cursor is at the end of line: Use the new
- // x-target only if the old one was before the end of line
- // or the old one was after the beginning of the line
+ // We want to keep the x-target on subsequent up/down
+ // movements that cross beyond the end of short lines.
+ // Thus a special handling when the cursor is at the
+ // end of line: Use the new x-target only if the old
+ // one was before the end of line or the old one was
+ // after the beginning of the line
bool inRTL = isWithinRtlParagraph(*this);
bool left;
bool right;
updateNeeded |= bv().checkDepm(dummy, *this);
updateTextTargetOffset();
+ if (updateNeeded) {
+ forceBufferUpdate();
+ // DEPM may have requested a screen update
+ this->screenUpdateFlags(
+ this->screenUpdate() | dummy.screenUpdate());
+ }
}
return false;
}
// with and without selection are handled differently
if (!selection()) {
- int yo = bv().getPos(*this, boundary()).y_;
+ int yo = bv().getPos(*this).y_;
Cursor old = *this;
// To next/previous row
if (up)
++dummy.pos();
if (bv().checkDepm(dummy, old)) {
updateNeeded = true;
- // Make sure that cur gets back whatever happened to dummy(Lgb)
+ // Make sure that cur gets back whatever happened to dummy (Lgb)
+ // This will include any screen update requested by DEPM
operator=(dummy);
}
} else {
updateNeeded |= bv().checkDepm(*this, old);
}
+ if (updateNeeded)
+ forceBufferUpdate();
updateTextTargetOffset();
return true;
}
}
-static docstring parbreak(InsetCode code)
+namespace {
+
+docstring parbreak(Cursor const * cur)
{
odocstringstream os;
os << '\n';
- // only add blank line if we're not in an ERT or Listings inset
- if (code != ERT_CODE && code != LISTINGS_CODE)
+ // only add blank line if we're not in a ParbreakIsNewline situation
+ if (!cur->inset().getLayout().parbreakIsNewline()
+ && !cur->paragraph().layout().parbreak_is_newline)
os << '\n';
return os.str();
}
+}
+
docstring Cursor::selectionAsString(bool with_label) const
{
// First paragraph in selection
docstring result = pars[startpit].
asString(startpos, pars[startpit].size(), label)
- + parbreak(inset().lyxCode());
+ + parbreak(this);
// The paragraphs in between (if any)
for (pit_type pit = startpit + 1; pit != endpit; ++pit) {
Paragraph const & par = pars[pit];
result += par.asString(0, par.size(), label)
- + parbreak(inset().lyxCode());
+ + parbreak(this);
}
// Last paragraph in selection
}
-void Cursor::undispatched()
+void Cursor::undispatched() const
{
disp_.dispatched(false);
}
-void Cursor::dispatched()
+void Cursor::dispatched() const
{
disp_.dispatched(true);
}
-void Cursor::updateFlags(Update::flags f)
+void Cursor::screenUpdateFlags(Update::flags f) const
+{
+ disp_.screenUpdate(f);
+}
+
+
+void Cursor::forceBufferUpdate() const
+{
+ disp_.forceBufferUpdate();
+}
+
+
+void Cursor::clearBufferUpdate() const
{
- disp_.update(f);
+ disp_.clearBufferUpdate();
}
-void Cursor::noUpdate()
+bool Cursor::needBufferUpdate() const
{
- disp_.update(Update::None);
+ return disp_.needBufferUpdate();
+}
+
+
+void Cursor::noScreenUpdate() const
+{
+ disp_.screenUpdate(Update::None);
}
Font Cursor::getFont() const
{
- // The logic here should more or less match to the Cursor::setCurrentFont
- // logic, i.e. the cursor height should give a hint what will happen
- // if a character is entered.
+ // The logic here should more or less match to the
+ // Cursor::setCurrentFont logic, i.e. the cursor height should
+ // give a hint what will happen if a character is entered.
// HACK. far from being perfect...
bool const broken_anchor = anchor_.fixIfBroken();
if (broken_cursor || broken_anchor) {
+ clearNewWordPosition();
clearSelection();
return true;
}
}
+void Cursor::sanitize()
+{
+ setBuffer(&bv_->buffer());
+ DocIterator::sanitize();
+ anchor_.sanitize();
+}
+
+
bool notifyCursorLeavesOrEnters(Cursor const & old, Cursor & cur)
{
// find inset in common
bool Cursor::textUndo()
{
- DocIterator dit = *this;
- // Undo::textUndo() will modify dit.
- if (!buffer()->undo().textUndo(dit))
+ if (!buffer()->undo().textUndo(*this))
return false;
- // Set cursor
- setCursor(dit);
- clearSelection();
- fixIfBroken();
+ sanitize();
return true;
}
bool Cursor::textRedo()
{
- DocIterator dit = *this;
- // Undo::textRedo() will modify dit.
- if (!buffer()->undo().textRedo(dit))
+ if (!buffer()->undo().textRedo(*this))
return false;
- // Set cursor
- setCursor(dit);
- clearSelection();
- fixIfBroken();
+ sanitize();
return true;
}
void Cursor::endUndoGroup() const
{
- buffer()->undo().endUndoGroup();
+ buffer()->undo().endUndoGroup(*this);
}
}
-void Cursor::recordUndoInset(UndoKind kind) const
+void Cursor::recordUndoInset(UndoKind kind, Inset const * inset) const
{
- buffer()->undo().recordUndoInset(*this, kind);
+ buffer()->undo().recordUndoInset(*this, kind, inset);
}
projects / lyx.git / blobdiff