#include <config.h>
-#include "Bidi.h"
#include "Buffer.h"
#include "BufferView.h"
#include "CoordCache.h"
// Get an iterator after the last paragraph in the cache
DocIterator et(inset);
et.push_back(CursorSlice(inset));
- et.pit() = boost::prior(cache.end())->first;
+ et.pit() = prev(cache.end(), 1)->first;
if (et.pit() >= et.lastpit())
et = doc_iterator_end(inset);
else
CursorData::CursorData()
: DocIterator(), anchor_(),
selection_(false), mark_(false), word_selection_(false),
- logicalpos_(false), current_font(inherit_font)
+ logicalpos_(false), current_font(inherit_font),
+ autocorrect_(false), macromode_(false)
{}
CursorData::CursorData(Buffer * buffer)
: DocIterator(buffer), anchor_(),
selection_(false), mark_(false), word_selection_(false),
- logicalpos_(false), current_font(inherit_font)
+ logicalpos_(false), current_font(inherit_font),
+ autocorrect_(false), macromode_(false)
{}
CursorData::CursorData(DocIterator const & dit)
: DocIterator(dit), anchor_(),
selection_(false), mark_(false), word_selection_(false),
- logicalpos_(false), current_font(inherit_font)
+ logicalpos_(false), current_font(inherit_font),
+ autocorrect_(false), macromode_(false)
{}
+
+
+ostream & operator<<(ostream & os, CursorData const & cur)
+{
+ os << "\n cursor: | anchor:\n";
+ for (size_t i = 0, n = cur.depth(); i != n; ++i) {
+ os << " " << cur[i] << " | ";
+ if (i < cur.anchor_.depth())
+ os << cur.anchor_[i];
+ else
+ os << "-------------------------------";
+ os << "\n";
+ }
+ for (size_t i = cur.depth(), n = cur.anchor_.depth(); i < n; ++i) {
+ os << "------------------------------- | " << cur.anchor_[i] << "\n";
+ }
+ os << " selection: " << cur.selection_
+// << " x_target: " << cur.x_target_
+ << " boundary: " << cur.boundary() << endl;
+ return os;
+}
+
+
+LyXErr & operator<<(LyXErr & os, CursorData const & cur)
+{
+ os.stream() << cur;
+ return os;
+}
+
+
// be careful: this is called from the bv's constructor, too, so
// bv functions are not yet available!
Cursor::Cursor(BufferView & bv)
: CursorData(&bv.buffer()), bv_(&bv),
- x_target_(-1), textTargetOffset_(0)
+ x_target_(-1), textTargetOffset_(0),
+ beforeDispatchPosX_(0), beforeDispatchPosY_(0)
{}
void Cursor::dispatch(FuncRequest const & cmd0)
{
- LYXERR(Debug::DEBUG, "cmd: " << cmd0 << '\n' << *this);
+ LYXERR(Debug::ACTION, "Cursor::dispatch: cmd: " << cmd0 << '\n' << *this);
if (empty())
return;
}
endUndoGroup();
+ // NOTE: The code below has been copied to BufferView::dispatch.
+ // If you need to modify this, please update the other one too.
+
// notify insets we just left
if (*this != old) {
old.beginUndoGroup();
}
+bool Cursor::inCoordCache() const
+{
+ CoordCache::Insets const & icache = bv_->coordCache().getInsets();
+ for (size_t i = 0 ; i < depth() ; ++i)
+ if (!icache.has(&(*this)[i].inset()))
+ return false;
+ return true;
+}
+
+
void Cursor::getPos(int & x, int & y) const
{
Point p = bv().getPos(*this);
}
- bool moved = (new_cur.pos() != pos()
- || new_cur.pit() != pit()
- || new_cur.boundary() != boundary()
- || &new_cur.inset() != &inset());
+ bool const moved = new_cur != *this || new_cur.boundary() != boundary();
if (moved) {
LYXERR(Debug::RTL, "moving to: " << new_cur.pos()
}
- bool moved = (new_cur.pos() != pos()
- || new_cur.pit() != pit()
- || new_cur.boundary() != boundary());
+ bool const moved = new_cur != *this || new_cur.boundary() != boundary();
if (moved) {
LYXERR(Debug::RTL, "moving to: " << new_cur.pos()
}
-void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos)
+namespace {
+
+// Return true on success
+bool findNonVirtual(Row const & row, Row::const_iterator & cit, bool onleft)
{
- // preparing bidi tables
- Paragraph const & par = paragraph();
- Buffer const & buf = *buffer();
+ if (onleft) {
+ while (cit != row.begin() && cit->isVirtual())
+ --cit;
+ } else {
+ while (cit != row.end() && cit->isVirtual())
+ ++cit;
+ }
+ return cit != row.end() && !cit->isVirtual();
+}
+
+}
+
+void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos) const
+{
+ // by default, we know nothing.
+ left_pos = -1;
+ right_pos = -1;
+
Row const & row = textRow();
- Bidi bidi;
- bidi.computeTables(par, buf, row);
-
- 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:
- 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).
- if (known_pos == lastpos()) {
- if (par.isRTL(buf.params())) {
- left_pos = -1;
- right_pos = bidi.vis2log(row.pos());
- } else {
- // LTR paragraph
- right_pos = -1;
- left_pos = bidi.vis2log(row.endpos() - 1);
- }
+ TextMetrics const & tm = bv_->textMetrics(text());
+ double dummy = 0;
+ Row::const_iterator cit = tm.findRowElement(row, pos(), boundary(), dummy);
+ // Handle the case of empty row
+ if (cit == row.end()) {
+ if (paragraph().isRTL(buffer()->params()))
+ right_pos = row.pos();
+ else
+ left_pos = row.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...
- 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):
- 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:
- 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 (bidi.inRange(v_left_pos)
- && bidi.vis2log(v_left_pos) + 1 == row.endpos()
- && row.endpos() < lastpos()
- && par.isSeparator(bidi.vis2log(v_left_pos)))
- --v_left_pos;
-
- // calculate the logical position of 'left_pos', if in row
- if (!bidi.inRange(v_left_pos))
- 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 (right_pos + 1 == row.endpos() && row.endpos() < lastpos()
- && par.isSeparator(right_pos)) {
- pos_type const v_right_pos = bidi.log2vis(right_pos) + 1;
- if (!bidi.inRange(v_right_pos))
- right_pos = -1;
- else
- right_pos = bidi.vis2log(v_right_pos);
- }
- } else {
- // known_pos is on the left
- 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 (bidi.inRange(v_right_pos)
- && bidi.vis2log(v_right_pos) + 1 == row.endpos()
- && row.endpos() < lastpos()
- && par.isSeparator(bidi.vis2log(v_right_pos)))
- ++v_right_pos;
-
- // calculate the logical position of 'right_pos', if in row
- if (!bidi.inRange(v_right_pos))
- 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 (left_pos + 1 == row.endpos() && row.endpos() < lastpos()
- && par.isSeparator(left_pos)) {
- pos_type const v_left_pos = bidi.log2vis(left_pos) - 1;
- if (!bidi.inRange(v_left_pos))
- left_pos = -1;
- else
- left_pos = bidi.vis2log(v_left_pos);
+ // skip virtual elements and exit if no non-virtual one exists
+ if (!findNonVirtual(row, cit, !cit->isRTL()))
+ return;
+
+ // if the position is at the left side of the element, we have to
+ // look at the previous element
+ if (pos() == cit->left_pos()) {
+ LYXERR(Debug::RTL, "getSurroundingPos(" << pos() << (boundary() ? "b" : "")
+ << "), AT LEFT of *cit=" << *cit);
+ // this one is easy (see common case below)
+ right_pos = pos() - (cit->isRTL() ? 1 : 0);
+ // at the left of the row
+ if (cit == row.begin())
+ return;
+ --cit;
+ if (!findNonVirtual(row, cit, true))
+ return;
+ // [...[ is the row element, | is cursor position (! with boundary)
+ // [ 1 2 [ is a ltr row element with pos=1 and endpos=3
+ // ] 2 1] is an rtl row element with pos=1 and endpos=3
+ // [ 1 2 [ [|3 4 [ => (2, 3)
+ // or [ 1 2 [ ]!4 3 ] => (2, 4)
+ // or ] 2 1 ] [|3 4 [ => (1, 3)
+ // or ] 4 3 ] ]!2 1 ] => (3, 2)
+ left_pos = cit->right_pos() - (cit->isRTL() ? 0 : 1);
+ // happens with consecutive row of same direction
+ if (left_pos == right_pos) {
+ left_pos += cit->isRTL() ? 1 : -1;
}
}
- return;
+ // same code but with the element at the right
+ else if (pos() == cit->right_pos()) {
+ LYXERR(Debug::RTL, "getSurroundingPos(" << pos() << (boundary() ? "b" : "")
+ << "), AT RIGHT of *cit=" << *cit);
+ // this one is easy (see common case below)
+ left_pos = pos() - (cit->isRTL() ? 0 : 1);
+ // at the right of the row
+ if (cit + 1 == row.end())
+ return;
+ ++cit;
+ if (!findNonVirtual(row, cit, false))
+ return;
+ // [ 1 2![ [ 3 4 [ => (2, 3)
+ // or [ 1 2![ ] 4 3 ] => (2, 4)
+ // or ] 2 1|] [ 3 4 [ => (1, 3)
+ // or ] 4 3|] ] 2 1 ] => (3, 2)
+ right_pos = cit->left_pos() - (cit->isRTL() ? 1 : 0);
+ // happens with consecutive row of same direction
+ if (right_pos == left_pos)
+ right_pos += cit->isRTL() ? -1 : 1;
+ }
+ // common case: both positions are inside the row element
+ else {
+ // [ 1 2|3 [ => (2, 3)
+ // or ] 3|2 1 ] => (3, 2)
+ left_pos = pos() - (cit->isRTL() ? 0 : 1);
+ right_pos = pos() - (cit->isRTL() ? 1 : 0);
+ }
+
+ // Note that debug message does not catch all early returns above
+ LYXERR(Debug::RTL,"getSurroundingPos(" << pos() << (boundary() ? "b" : "")
+ << ") => (" << left_pos << ", " << right_pos <<")");
}
// 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);
+ if (inset().asInsetTabular()) {
+ par_is_LTR = !inset().asInsetTabular()->isRightToLeft(*this);
LYXERR(Debug::RTL, "Inside table! par_is_LTR=" << (par_is_LTR ? 1 : 0));
}
void Cursor::posVisToRowExtremity(bool left)
{
- // prepare bidi tables
- Paragraph const & par = paragraph();
- Buffer const & buf = *buffer();
- Row const & row = textRow();
- Bidi bidi;
- bidi.computeTables(par, buf, row);
-
LYXERR(Debug::RTL, "entering extremity: " << pit() << "," << pos() << ","
<< (boundary() ? 1 : 0));
- if (left) { // move to leftmost position
- // if this is an RTL paragraph, and we're at the last row in the
- // paragraph, move to lastpos
- if (par.isRTL(buf.params()) && row.endpos() == lastpos())
- pos() = lastpos();
- 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
- // "boundary" which we simulate at insets.
-
- // 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
- bool const right_of_pos = row.endpos() > 0
- && pos() == row.endpos() - 1 && !par.isInset(pos());
-
- // Now we know if we want to be to the left or to the right of pos,
- // let's make sure we are where we want to be.
- bool const new_pos_is_RTL =
- par.getFontSettings(buf.params(), pos()).isVisibleRightToLeft();
-
- if (new_pos_is_RTL != right_of_pos) {
- ++pos();
- boundary(true);
- }
- }
- } else {
- // move to rightmost position
- // if this is an LTR paragraph, and we're at the last row in the
- // paragraph, move to lastpos
- if (!par.isRTL(buf.params()) && row.endpos() == lastpos())
- pos() = lastpos();
- 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.
-
- // do we want to be to the left of pos?
- // as explained above, if at last pos in row, stay to the left,
- // unless the last position is the same as the first.
- bool const left_of_pos = row.endpos() > 0
- && pos() == row.endpos() - 1 && !par.isInset(pos());
-
- // Now we know if we want to be to the left or to the right of pos,
- // let's make sure we are where we want to be.
- bool const new_pos_is_RTL =
- par.getFontSettings(buf.params(), pos()).isVisibleRightToLeft();
-
- if (new_pos_is_RTL == left_of_pos) {
- ++pos();
- boundary(true);
- }
- }
- }
+ TextMetrics const & tm = bv_->textMetrics(text());
+ // Looking for extremities is like clicking on the left or the
+ // right of the row.
+ int x = tm.origin().x_ + (left ? 0 : textRow().width());
+ bool b = false;
+ pos() = tm.getPosNearX(textRow(), x, b);
+ boundary(b);
+
LYXERR(Debug::RTL, "leaving extremity: " << pit() << "," << pos() << ","
<< (boundary() ? 1 : 0));
}
+bool Cursor::reverseDirectionNeeded() const
+{
+ /*
+ * We determine the directions based on the direction of the
+ * bottom() --- i.e., outermost --- paragraph, because that is
+ * the only way to achieve consistency of the arrow's movements
+ * within a paragraph, and thus avoid situations in which the
+ * cursor gets stuck.
+ */
+ return bottom().paragraph().isRTL(bv().buffer().params());
+}
+
+
CursorSlice Cursor::normalAnchor() const
{
if (!selection())
if (inset)
prevInset()->infoize2(os);
}
- // overwite old message
- os << " ";
}
setSelection(sel);
return true;
}
-
-
-ostream & operator<<(ostream & os, Cursor const & cur)
-{
- os << "\n cursor: | anchor:\n";
- for (size_t i = 0, n = cur.depth(); i != n; ++i) {
- os << " " << cur[i] << " | ";
- if (i < cur.anchor_.depth())
- os << cur.anchor_[i];
- else
- os << "-------------------------------";
- os << "\n";
- }
- for (size_t i = cur.depth(), n = cur.anchor_.depth(); i < n; ++i) {
- os << "------------------------------- | " << cur.anchor_[i] << "\n";
- }
- os << " selection: " << cur.selection_
- << " x_target: " << cur.x_target_
- << " boundary: " << cur.boundary() << endl;
- return os;
-}
-
-
-LyXErr & operator<<(LyXErr & os, Cursor const & cur)
-{
- os.stream() << cur;
- return os;
-}
-
-
} // namespace lyx
++pos();
inset().setBuffer(bv_->buffer());
inset().initView();
- forceBufferUpdate();
+ checkBufferStructure();
}
<< pos() << ' ' << lastpos() << " in idx: " << idx()
<< " in atom: '";
odocstringstream os;
- WriteStream wi(os, false, true, WriteStream::wsDefault);
+ TexRow texrow(false);
+ otexrowstream ots(os,texrow);
+ WriteStream wi(ots, false, true, WriteStream::wsDefault);
inset().asInsetMath()->write(wi);
lyxerr << to_utf8(os.str()) << endl;
pos() = lastpos();
// 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 inRTL = innerParagraph().isRTL(bv().buffer().params());
bool left;
bool right;
if (inRTL) {
// 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 inRTL = innerParagraph().isRTL(bv().buffer().params());
bool left;
bool right;
if (inRTL) {
// Make sure that cur gets back whatever happened to dummy (Lgb)
operator=(dummy);
}
+ if (pos() && paragraph().isEnvSeparator(pos() - 1))
+ posBackward();
} else {
// if there is a selection, we stay out of any inset,
// and just jump to the right position:
if (inMathed()) {
odocstringstream os;
info(os);
+#ifdef DEVEL_VERSION
+ InsetMath * math = inset().asInsetMath();
+ if (math)
+ os << _(", Inset: ") << math->id();
+ os << _(", Cell: ") << idx();
+ os << _(", Position: ") << pos();
+#endif
return os.str();
}
{
setBuffer(&bv_->buffer());
DocIterator::sanitize();
- anchor_.sanitize();
+ if (selection())
+ anchor_.sanitize();
+ else
+ resetAnchor();
}
void Cursor::beginUndoGroup() const
{
- buffer()->undo().beginUndoGroup();
+ buffer()->undo().beginUndoGroup(*this);
}
}
-void Cursor::recordUndo(UndoKind kind, pit_type from, pit_type to) const
+void Cursor::recordUndo(pit_type from, pit_type to) const
{
- buffer()->undo().recordUndo(*this, kind, from, to);
+ buffer()->undo().recordUndo(*this, from, to);
}
-void Cursor::recordUndo(UndoKind kind, pit_type from) const
+void Cursor::recordUndo(pit_type from) const
{
- buffer()->undo().recordUndo(*this, kind, from);
+ buffer()->undo().recordUndo(*this, from, pit());
}
}
-void Cursor::recordUndoInset(UndoKind kind, Inset const * inset) const
+void Cursor::recordUndoInset(Inset const * in) const
{
- buffer()->undo().recordUndoInset(*this, kind, inset);
+ buffer()->undo().recordUndoInset(*this, in);
}
else
recordUndo();
} else {
- buffer()->undo().recordUndo(*this, ATOMIC_UNDO,
+ buffer()->undo().recordUndo(*this,
selBegin().pit(), selEnd().pit());
}
}
projects / lyx.git / blobdiff