#include <config.h>
-#include "Bidi.h"
#include "Buffer.h"
+#include "BufferParams.h"
#include "BufferView.h"
#include "CoordCache.h"
#include "Cursor.h"
#include "CutAndPaste.h"
#include "DispatchResult.h"
-#include "Encoding.h"
#include "Font.h"
#include "FuncCode.h"
#include "FuncRequest.h"
#include "Paragraph.h"
#include "ParIterator.h"
#include "Row.h"
+#include "texstream.h"
#include "Text.h"
#include "TextMetrics.h"
#include "TocBackend.h"
#include "mathed/InsetMath.h"
#include "mathed/InsetMathBrace.h"
+#include "mathed/InsetMathEnsureMath.h"
#include "mathed/InsetMathScript.h"
#include "mathed/MacroTable.h"
#include "mathed/MathData.h"
-#include "mathed/MathMacro.h"
-
-#include "support/bind.h"
+#include "mathed/MathFactory.h"
+#include "mathed/InsetMathMacro.h"
#include <sstream>
#include <limits>
namespace {
-bool positionable(DocIterator const & cursor, DocIterator const & anchor)
-{
- // avoid deeper nested insets when selecting
- if (cursor.depth() > anchor.depth())
- return false;
-
- // anchor might be deeper, should have same path then
- for (size_t i = 0; i < cursor.depth(); ++i)
- if (&cursor[i].inset() != &anchor[i].inset())
- return false;
-
- // position should be ok.
- return true;
-}
-
-
// Find position closest to (x, y) in cell given by iter.
// Used only in mathed
-DocIterator bruteFind2(Cursor const & c, int x, int y)
+DocIterator bruteFind(Cursor const & c, int x, int y)
{
double best_dist = numeric_limits<double>::max();
DocIterator result;
DocIterator it = c;
- it.top().pos() = 0;
+ it.pos() = 0;
DocIterator et = c;
- et.top().pos() = et.top().asInsetMath()->cell(et.top().idx()).size();
+ et.pos() = et.lastpos();
for (size_t i = 0;; ++i) {
int xo;
int yo;
Inset const * inset = &it.inset();
- CoordCache const & cache = c.bv().coordCache();
+ CoordCache::Insets const & insetCache = c.bv().coordCache().getInsets();
// 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 (!cache.getInsets().has(inset)) {
+ if (!insetCache.has(inset)) {
it.top().pos() = 0;
return it;
}
- Point const o = cache.getInsets().xy(inset);
+ Point const o = insetCache.xy(inset);
inset->cursorPos(c.bv(), it.top(), c.boundary(), xo, yo);
// Convert to absolute
xo += o.x_;
}
-/*
-/// moves position closest to (x, y) in given box
-bool bruteFind(Cursor & cursor,
- int x, int y, int xlow, int xhigh, int ylow, int yhigh)
-{
- LASSERT(!cursor.empty(), return false);
- Inset & inset = cursor[0].inset();
- BufferView & bv = cursor.bv();
-
- CoordCache::InnerParPosCache const & cache =
- bv.coordCache().getParPos().find(cursor.bottom().text())->second;
- // Get an iterator on the first paragraph in the cache
- DocIterator it(inset);
- it.push_back(CursorSlice(inset));
- it.pit() = cache.begin()->first;
- // 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;
- if (et.pit() >= et.lastpit())
- et = doc_iterator_end(inset);
- else
- ++et.pit();
-
- double best_dist = numeric_limits<double>::max();
- DocIterator best_cursor = et;
-
- for ( ; it != et; it.forwardPos(true)) {
- // avoid invalid nesting when selecting
- if (!cursor.selection() || positionable(it, cursor.anchor_)) {
- Point p = bv.getPos(it, false);
- int xo = p.x_;
- int yo = p.y_;
- if (xlow <= xo && xo <= xhigh && ylow <= yo && yo <= yhigh) {
- double const dx = xo - x;
- double const dy = yo - y;
- double const d = dx * dx + dy * dy;
- // '<=' in order to take the last possible position
- // this is important for clicking behind \sum in e.g. '\sum_i a'
- if (d <= best_dist) {
- // lyxerr << "*" << endl;
- best_dist = d;
- best_cursor = it;
- }
- }
- }
- }
-
- if (best_cursor != et) {
- cursor.setCursor(best_cursor);
- return true;
- }
-
- return false;
-}
-*/
-
-/*
-/// moves position closest to (x, y) in given box
-bool bruteFind3(Cursor & cur, int x, int y, bool up)
-{
- BufferView & bv = cur.bv();
- int ylow = up ? 0 : y + 1;
- int yhigh = up ? y - 1 : bv.workHeight();
- int xlow = 0;
- int xhigh = bv.workWidth();
-
-// FIXME: bit more work needed to get 'from' and 'to' right.
- pit_type from = cur.bottom().pit();
- //pit_type to = cur.bottom().pit();
- //lyxerr << "Pit start: " << from << endl;
-
- //lyxerr << "bruteFind3: x: " << x << " y: " << y
- // << " xlow: " << xlow << " xhigh: " << xhigh
- // << " ylow: " << ylow << " yhigh: " << yhigh
- // << endl;
- DocIterator it = doc_iterator_begin(cur.buffer());
- it.pit() = from;
- DocIterator et = doc_iterator_end(cur.buffer());
-
- double best_dist = numeric_limits<double>::max();
- DocIterator best_cursor = et;
-
- for ( ; it != et; it.forwardPos()) {
- // avoid invalid nesting when selecting
- if (bv.cursorStatus(it) == CUR_INSIDE
- && (!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) {
- double const dx = xo - x;
- double const dy = yo - y;
- double const d = dx * dx + dy * dy;
- //lyxerr << "itx: " << xo << " ity: " << yo << " d: " << d
- // << " dx: " << dx << " dy: " << dy
- // << " idx: " << it.idx() << " pos: " << it.pos()
- // << " it:\n" << it
- // << endl;
- // '<=' in order to take the last possible position
- // this is important for clicking behind \sum in e.g. '\sum_i a'
- if (d <= best_dist) {
- //lyxerr << "*" << endl;
- best_dist = d;
- best_cursor = it;
- }
- }
- }
- }
-
- //lyxerr << "best_dist: " << best_dist << " cur:\n" << best_cursor << endl;
- if (best_cursor == et)
- return false;
- cur.setCursor(best_cursor);
- return true;
-}
-*/
-} // namespace anon
+} // namespace
CursorData::CursorData()
: DocIterator(), anchor_(),
selection_(false), mark_(false), word_selection_(false),
- logicalpos_(false), current_font(inherit_font)
+ 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)
+ 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)
+ 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)
{}
}
-// this (intentionally) does neither touch anchor nor selection status
void Cursor::setCursor(DocIterator const & cur)
{
DocIterator::operator=(cur);
}
+void Cursor::setCursorSelectionTo(DocIterator dit)
+{
+ size_t i = 0;
+ // normalise dit
+ while (i < dit.depth() && i < anchor_.depth() && dit[i] == anchor_[i])
+ ++i;
+ if (i != dit.depth()) {
+ // otherwise the cursor is already normal
+ if (i == anchor_.depth())
+ // dit is a proper extension of the anchor_
+ dit.cutOff(i - 1);
+ else if (i + 1 < dit.depth()) {
+ // one has dit[i] != anchor_[i] but either dit[i-1] == anchor_[i-1]
+ // or i == 0. Remove excess.
+ dit.cutOff(i);
+ if (dit[i] > anchor_[i])
+ // place dit after the inset it was in
+ ++dit.pos();
+ }
+ }
+ setCursor(dit);
+ setSelection();
+}
+
+
void Cursor::setCursorToAnchor()
{
if (selection()) {
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
+{
+ // the root inset is not in cache, but we do not need it.
+ if (depth() == 1)
+ return true;
+ CoordCache::Insets const & icache = bv_->coordCache().getInsets();
+ for (size_t i = 1 ; 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 Cursor::posBackward()
-{
- if (pos() == 0)
- return false;
- --pos();
- return true;
-}
-
-
-bool Cursor::posForward()
-{
- if (pos() == lastpos())
- return false;
- ++pos();
- return true;
-}
-
-
bool Cursor::posVisRight(bool skip_inset)
{
Cursor new_cur = *this; // where we will move to
pos_type left_pos; // position visually left of current cursor
pos_type right_pos; // position visually right of current cursor
- bool new_pos_is_RTL; // is new position we're moving to RTL?
getSurroundingPos(left_pos, right_pos);
// 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(
+ bool const 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
}
- 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()
Cursor new_cur = *this; // where we will move to
pos_type left_pos; // position visually left of current cursor
pos_type right_pos; // position visually right of current cursor
- bool new_pos_is_RTL; // is new position we're moving to RTL?
getSurroundingPos(left_pos, right_pos);
// 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(
+ bool const 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
}
- 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();
+}
+
+} // namespace
+
+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);
- }
+ double dummy = 0;
+ Row::const_iterator cit = row.findElement(pos(), boundary(), dummy);
+ // Handle the case of empty row
+ if (cit == row.end()) {
+ if (row.isRTL())
+ 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 <<")");
}
bool Cursor::posVisToNewRow(bool movingLeft)
{
- Paragraph const & par = paragraph();
- Buffer const & buf = *buffer();
Row const & row = textRow();
- bool par_is_LTR = !par.isRTL(buf.params());
+ bool par_is_LTR = !row.isRTL();
// 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())
// 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);
+ if (anchor_.depth() < depth()) {
+ LYXERR0("Cursor is deeper than anchor. PLEASE REPORT.\nCursor is"
+ << *this);
+ const_cast<DocIterator &>(anchor_) = *this;
+ }
CursorSlice normal = anchor_[depth() - 1];
if (depth() < anchor_.depth() && top() <= normal) {
}
-DocIterator & Cursor::realAnchor()
-{
- return anchor_;
-}
-
-
CursorSlice Cursor::selBegin() const
{
if (!selection())
void Cursor::setSelection()
{
- setSelection(true);
- // A selection with no contents is not a selection
- // FIXME: doesnt look ok
+ selection(true);
if (idx() == normalAnchor().idx() &&
pit() == normalAnchor().pit() &&
pos() == normalAnchor().pos())
- setSelection(false);
+ selection(false);
}
void Cursor::setSelection(DocIterator const & where, int n)
{
setCursor(where);
- setSelection(true);
+ selection(true);
anchor_ = where;
pos() += n;
}
void Cursor::clearSelection()
{
- setSelection(false);
+ selection(false);
setWordSelection(false);
setMark(false);
resetAnchor();
}
-void Cursor::info(odocstream & os) const
+void Cursor::info(odocstream & os, bool devel_mode) const
{
for (int i = 1, n = depth(); i < n; ++i) {
operator[](i).inset().infoize(os);
if (inset)
prevInset()->infoize2(os);
}
- // overwite old message
- os << " ";
+ if (devel_mode) {
+ InsetMath * math = inset().asInsetMath();
+ if (math)
+ os << _(", Inset: ") << math->id();
+ os << _(", Cell: ") << idx();
+ os << _(", Position: ") << pos();
+ }
+
}
cap::saveSelection(*this);
resetAnchor();
- setSelection(sel);
+ selection(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_ << 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();
}
void Cursor::insert(docstring const & str)
{
- for_each(str.begin(), str.end(),
- bind(static_cast<void(Cursor::*)(char_type)>
- (&Cursor::insert), this, _1));
+ for (char_type c : str)
+ insert(c);
}
}
-bool Cursor::backspace()
+bool Cursor::backspace(bool const force)
{
if (selection()) {
cap::eraseSelection(*this);
}
}
- if (pos() != 0 && prevAtom()->nargs() > 0) {
+ if (pos() != 0 && !force && prevAtom()->confirmDeletion()) {
// let's require two backspaces for 'big stuff' and
// highlight on the first
resetAnchor();
- setSelection(true);
+ selection(true);
--pos();
} else {
--pos();
}
-bool Cursor::erase()
+bool Cursor::erase(bool const force)
{
if (inMacroMode())
return true;
}
// 'clever' UI hack: only erase large items if previously slected
- if (pos() != lastpos() && nextAtom()->nargs() > 0) {
+ if (pos() != lastpos() && !force && nextAtom()->confirmDeletion()) {
resetAnchor();
- setSelection(true);
+ selection(true);
++pos();
} else {
plainErase();
}
-bool Cursor::macroModeClose()
+bool Cursor::macroModeClose(bool cancel)
{
if (!inMacroMode())
return false;
cell().erase(pos());
// do nothing if the macro name is empty
- if (s == "\\")
+ if (s == "\\" || cancel)
return false;
// trigger updates of macros, at least, if no full
InsetMathNest * const in = inset().asInsetMath()->asNestInset();
if (in && in->interpretString(*this, s))
return true;
- MathAtom atom = buffer()->getMacro(name, *this, false) ?
- MathAtom(new MathMacro(buffer(), name)) : createInsetMath(name, buffer());
+ bool const user_macro = buffer()->getMacro(name, *this, false);
+ MathAtom atom = user_macro ? MathAtom(new InsetMathMacro(buffer(), name))
+ : createInsetMath(name, buffer());
// try to put argument into macro, if we just inserted a macro
bool macroArg = false;
- MathMacro * atomAsMacro = atom.nucleus()->asMacro();
+ InsetMathMacro * atomAsMacro = atom.nucleus()->asMacro();
if (atomAsMacro) {
// macros here are still unfolded (in init mode in fact). So
// we have to resolve the macro here manually and check its arity
MacroData const * data = buffer()->getMacro(atomAsMacro->name());
if (!selection.empty() && data && data->numargs() - data->optionals() > 0) {
macroArg = true;
- atomAsMacro->setDisplayMode(MathMacro::DISPLAY_INTERACTIVE_INIT, 1);
+ atomAsMacro->setDisplayMode(InsetMathMacro::DISPLAY_INTERACTIVE_INIT, 1);
} else
// non-greedy case. Do not touch the arguments behind
- atomAsMacro->setDisplayMode(MathMacro::DISPLAY_INTERACTIVE_INIT, 0);
+ atomAsMacro->setDisplayMode(InsetMathMacro::DISPLAY_INTERACTIVE_INIT, 0);
}
// insert remembered selection into first argument of a non-macro
else if (atom.nucleus()->nargs() > 0)
atom.nucleus()->cell(0).append(selection);
- plainInsert(atom);
+ MathWordList const & words = mathedWordList();
+ MathWordList::const_iterator it = words.find(name);
+ bool keep_mathmode = user_macro
+ || (it != words.end() && (it->second.inset == "font"
+ || it->second.inset == "oldfont"
+ || it->second.inset == "mbox"));
+ bool ert_macro = !user_macro && it == words.end() && atomAsMacro;
+
+ if (in && in->currentMode() == Inset::TEXT_MODE
+ && atom.nucleus()->currentMode() == Inset::MATH_MODE
+ && name != from_ascii("ensuremath") && !ert_macro) {
+ MathAtom at(new InsetMathEnsureMath(buffer()));
+ at.nucleus()->cell(0).push_back(atom);
+ niceInsert(at);
+ posForward();
+ } else if (in && in->currentMode() == Inset::MATH_MODE
+ && atom.nucleus()->currentMode() == Inset::TEXT_MODE
+ && !keep_mathmode) {
+ MathAtom at = createInsetMath("text", buffer());
+ at.nucleus()->cell(0).push_back(atom);
+ niceInsert(at);
+ posForward();
+ } else
+ plainInsert(atom);
// finally put the macro argument behind, if needed
if (macroArg) {
<< pos() << ' ' << lastpos() << " in idx: " << idx()
<< " in atom: '";
odocstringstream os;
- WriteStream wi(os, false, true, WriteStream::wsDefault);
+ otexrowstream ots(os);
+ 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) {
//lyxerr << "idxUpDown triggered" << endl;
// try to find best position within this inset
if (!selection())
- setCursor(bruteFind2(*this, xo, yo));
+ setCursor(bruteFind(*this, xo, yo));
return true;
}
}
+InsetMath & Cursor::nextMath()
+{
+ return *nextAtom().nucleus();
+}
+
+
+InsetMath & Cursor::prevMath()
+{
+ return *prevAtom().nucleus();
+}
+
+
+bool Cursor::mathForward(bool word)
+{
+ LASSERT(inMathed(), return false);
+ if (pos() < lastpos()) {
+ if (word) {
+ // word: skip a group of insets of the form X*(B*|R*|P*) (greedy
+ // match) where X is any math class, B is mathbin, R is mathrel, and
+ // P is mathpunct. Make sure that the following remains true:
+ // mathForward(true); mathBackward(true); mathForward(true)
+ // is the same as mathForward(true) and
+ // mathBackward(true); mathForward(true); mathBackward(true)
+ // is the same as mathBackward(true).
+ MathClass mc = nextMath().mathClass();
+ do
+ posForward();
+ while (pos() < lastpos() && mc == nextMath().mathClass());
+ if (pos() < lastpos() &&
+ ((mc = nextMath().mathClass()) == MC_BIN ||
+ mc == MC_REL || mc == MC_PUNCT))
+ do
+ posForward();
+ while (pos() < lastpos() && mc == nextMath().mathClass());
+ } else if (openable(nextAtom())) {
+ // single step: try to enter the next inset
+ pushBackward(nextMath());
+ inset().idxFirst(*this);
+ } else
+ posForward();
+ return true;
+ }
+ if (inset().idxForward(*this))
+ return true;
+ // try to pop forwards --- but don't pop out of math! leave that to
+ // the FINISH lfuns
+ int s = depth() - 2;
+ if (s >= 0 && operator[](s).inset().asInsetMath())
+ return popForward();
+ return false;
+}
+
+
+bool Cursor::mathBackward(bool word)
+{
+ LASSERT(inMathed(), return false);
+ if (pos() > 0) {
+ if (word) {
+ // word: skip a group of insets. See the comment in mathForward.
+ MathClass mc = prevMath().mathClass();
+ do
+ posBackward();
+ while (pos() > 0 && mc == prevMath().mathClass());
+ if (pos() > 0 && (mc == MC_BIN || mc == MC_REL || mc == MC_PUNCT)) {
+ mc = prevMath().mathClass();
+ do
+ posBackward();
+ while (pos() > 0 && mc == prevMath().mathClass());
+ }
+ } else if (openable(prevAtom())) {
+ // single step: try to enter the preceding inset
+ posBackward();
+ push(nextMath());
+ inset().idxLast(*this);
+ } else
+ posBackward();
+ return true;
+ }
+ if (inset().idxBackward(*this))
+ return true;
+ // try to pop backwards --- but don't pop out of math! leave that to
+ // the FINISH lfuns
+ int s = depth() - 2;
+ if (s >= 0 && operator[](s).inset().asInsetMath())
+ return popBackward();
+ return false;
+}
+
+
bool Cursor::atFirstOrLastRow(bool up)
{
TextMetrics const & tm = bv_->textMetrics(text());
// 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) {
int yo = bv().getPos(*this).y_;
Cursor old = *this;
// To next/previous row
+ // FIXME: the y position is often guessed wrongly across styles and
+ // insets, which leads to weird behaviour.
if (up)
tm.editXY(*this, xo, yo - textRow().ascent() - 1);
else
tm.editXY(*this, xo, yo + textRow().descent() + 1);
+ x_target_ = old.x_target_;
clearSelection();
// This happens when you move out of an inset.
// Make sure that cur gets back whatever happened to dummy (Lgb)
operator=(dummy);
}
+ if (inTexted() && 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:
next_row = 0;
}
}
- top().pos() = min(tm.x2pos(pit(), next_row, xo), top().lastpos());
-
- int const xpos = tm.x2pos(pit(), next_row, xo);
- bool const at_end_row = xpos == tm.x2pos(pit(), next_row, tm.width());
- bool const at_beg_row = xpos == tm.x2pos(pit(), next_row, 0);
- if (at_end_row && at_beg_row)
- // make sure the cursor ends up on this row
- boundary(false);
- else
- boundary(at_end_row);
+ Row const & real_next_row = tm.parMetrics(pit()).rows()[next_row];
+ bool bound = false;
+ top().pos() = tm.getPosNearX(real_next_row, xo, bound);
+ boundary(bound);
+ // When selection==false, this is done by TextMetrics::editXY
+ setCurrentFont();
updateNeeded |= bv().checkDepm(*this, old);
}
return os.str();
}
-}
+} // namespace
docstring Cursor::selectionAsString(bool with_label) const
}
-docstring Cursor::currentState() const
+docstring Cursor::currentState(bool devel_mode) const
{
if (inMathed()) {
odocstringstream os;
- info(os);
+ info(os, devel_mode);
return os.str();
}
if (inTexted())
- return text()->currentState(*this);
+ return text()->currentState(*this, devel_mode);
return docstring();
}
}
-Encoding const * Cursor::getEncoding() const
-{
- if (empty())
- return 0;
- CursorSlice const & sl = innerTextSlice();
- Text const & text = *sl.text();
- Font font = text.getPar(sl.pit()).getFont(
- bv().buffer().params(), sl.pos(), text.outerFont(sl.pit()));
- return font.language()->encoding();
-}
-
-
void Cursor::undispatched() const
{
disp_.dispatched(false);
// 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.
+ // FIXME: this is not the case, what about removing this method ? (see #10478).
// HACK. far from being perfect...
{
setBuffer(&bv_->buffer());
DocIterator::sanitize();
- anchor_.sanitize();
+ new_word_.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);
}
-void Cursor::recordUndoFullDocument() const
+void Cursor::recordUndoFullBuffer() const
{
- buffer()->undo().recordUndoFullDocument(*this);
+ buffer()->undo().recordUndoFullBuffer(*this);
+}
+
+
+void Cursor::recordUndoBufferParams() const
+{
+ buffer()->undo().recordUndoBufferParams(*this);
}
else
recordUndo();
} else {
- buffer()->undo().recordUndo(*this, ATOMIC_UNDO,
+ buffer()->undo().recordUndo(*this,
selBegin().pit(), selEnd().pit());
}
}
// In case the master has no gui associated with it,
// the TocItem is not updated (part of bug 5699).
buffer()->tocBackend().updateItem(*this);
+
+ // If the last tracked change of the paragraph has just been
+ // deleted, then we need to recompute the buffer flag
+ // tracked_changes_present_.
+ if (inTexted() && paragraph().isChangeUpdateRequired())
+ disp_.forceChangesUpdate();
+}
+
+
+bool Cursor::confirmDeletion(bool const before) const
+{
+ if (!selection()) {
+ if (Inset const * inset = before ? prevInset() : nextInset())
+ return inset->confirmDeletion();
+ } else {
+ DocIterator dit = selectionBegin();
+ CursorSlice const end = selectionEnd().top();
+ for (; dit.top() < end; dit.top().forwardPos())
+ if (Inset const * inset = dit.nextInset())
+ if (inset->confirmDeletion())
+ return true;
+ }
+ return false;
+}
+
+
+void Cursor::moveToClosestEdge(int const x, bool const edit)
+{
+ if (Inset const * inset = nextInset()) {
+ // stay in front of insets for which we want to open the dialog
+ // (e.g. InsetMathSpace).
+ if (edit && (inset->hasSettings() || !inset->contextMenuName().empty()))
+ return;
+ CoordCache::Insets const & insetCache = bv().coordCache().getInsets();
+ if (!insetCache.has(inset))
+ return;
+ int const wid = insetCache.dim(inset).wid;
+ Point p = insetCache.xy(inset);
+ if (x > p.x_ + (wid + 1) / 2)
+ posForward();
+ }
}
projects / lyx.git / blobdiff