#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"
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)
}
*/
-
+/*
/// moves position closest to (x, y) in given box
bool bruteFind3(Cursor & cur, int x, int y, bool up)
{
cur.setCursor(best_cursor);
return true;
}
-
+*/
} // namespace anon
// 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),
+ : CursorData(&bv.buffer()), bv_(&bv),
x_target_(-1), textTargetOffset_(0)
{}
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(), /**/);
for (; depth(); pop(), boundary(false)) {
LYXERR(Debug::DEBUG, "Cursor::dispatch: cmd: "
<< cmd0 << endl << *this);
- LASSERT(pos() <= lastpos(), /**/);
- LASSERT(idx() <= lastidx(), /**/);
- LASSERT(pit() <= lastpit(), /**/);
+
+ // In any of these cases, the cursor is invalid, and we should
+ // try to save this document rather than crash.
+ LBUFERR(pos() <= lastpos());
+ LBUFERR(idx() <= lastidx());
+ LBUFERR(pit() <= lastpit());
// The common case is 'LFUN handled, need update', so make the
// LFUN handler's life easier by assuming this as default value.
if (disp_.dispatched())
break;
}
-
+
// it completely to get a 'bomb early' behaviour in case this
// object will be used again.
if (!disp_.dispatched()) {
// We might have invalidated the cursor when removing an empty
// paragraph while the cursor could not be moved out the inset
// while we initially thought we could. This might happen when
- // a multiline inset becomes an inline inset when the second
+ // a multiline inset becomes an inline inset when the second
// paragraph is removed.
if (safe.pit() > safe.lastpit()) {
safe.pit() = safe.lastpit();
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();
{
CursorSlice const & cs = innerTextSlice();
ParagraphMetrics const & pm = bv().parMetrics(cs.text(), cs.pit());
- LASSERT(!pm.rows().empty(), /**/);
return pm.getRow(pos(), boundary());
}
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);
// Are we already at rightmost pos in row?
else if (text()->empty() || right_pos == -1) {
-
+
new_cur = *this;
if (!new_cur.posVisToNewRow(false)) {
LYXERR(Debug::RTL, "not moving!");
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...
- LYXERR(Debug::RTL, "right edge, moving: " << int(new_cur.pit()) << ","
+ LYXERR(Debug::RTL, "right edge, moving: " << int(new_cur.pit()) << ","
<< int(new_cur.pos()) << "," << (new_cur.boundary() ? 1 : 0));
}
// 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
new_cur.pos() = right_pos;
new_cur.boundary(false);
}
-
+
}
bool moved = (new_cur.pos() != pos()
|| new_cur.pit() != pit()
|| new_cur.boundary() != boundary()
|| &new_cur.inset() != &inset());
-
+
if (moved) {
- LYXERR(Debug::RTL, "moving to: " << new_cur.pos()
+ LYXERR(Debug::RTL, "moving to: " << new_cur.pos()
<< (new_cur.boundary() ? " (boundary)" : ""));
*this = new_cur;
}
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);
// Are we at an inset?
new_cur.pos() = left_pos;
new_cur.boundary(false);
- if (!skip_inset &&
+ 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
// Are we already at leftmost pos in row?
else if (text()->empty() || left_pos == -1) {
-
+
new_cur = *this;
if (!new_cur.posVisToNewRow(true)) {
LYXERR(Debug::RTL, "not moving!");
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...
- LYXERR(Debug::RTL, "left edge, moving: " << int(new_cur.pit()) << ","
+ LYXERR(Debug::RTL, "left edge, moving: " << int(new_cur.pit()) << ","
<< int(new_cur.pos()) << "," << (new_cur.boundary() ? 1 : 0));
}
// 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
new_cur.pos() = left_pos;
new_cur.boundary(false);
}
-
+
}
- bool moved = (new_cur.pos() != pos()
+ bool moved = (new_cur.pos() != pos()
|| new_cur.pit() != pit()
|| new_cur.boundary() != boundary());
if (moved) {
- LYXERR(Debug::RTL, "moving to: " << new_cur.pos()
+ LYXERR(Debug::RTL, "moving to: " << new_cur.pos()
<< (new_cur.boundary() ? " (boundary)" : ""));
*this = new_cur;
}
-
+
return moved;
}
// 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
if (par.isRTL(buf.params())) {
left_pos = -1;
right_pos = bidi.vis2log(row.pos());
- } else {
+ } else {
// LTR paragraph
right_pos = -1;
left_pos = bidi.vis2log(row.endpos() - 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 =
+ bool const cur_is_RTL =
par.getFontSettings(buf.params(), known_pos).isVisibleRightToLeft();
// ... in the following manner:
// For an RTL character, "before"
// 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()
+ 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;
// 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()
+ 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))
else
right_pos = bidi.vis2log(v_right_pos);
}
- } else {
+ } else {
// known_pos is on the left
left_pos = known_pos;
// *visual* position of 'right_pos'
// 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()
+ 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))
+ 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()
+ 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))
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 (par_is_LTR == movingLeft) {
boundary(false);
}
}
-
+
// make sure we're at left-/right-most pos in new row
posVisToRowExtremity(!movingLeft);
}
-void Cursor::posVisToRowExtremity(bool left)
+void Cursor::posVisToRowExtremity(bool left)
{
// prepare bidi tables
Paragraph const & par = paragraph();
// 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
// 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 =
+ bool const new_pos_is_RTL =
par.getFontSettings(buf.params(), pos()).isVisibleRightToLeft();
if (new_pos_is_RTL != right_of_pos) {
boundary(true);
}
}
- } else {
+ } else {
// move to rightmost position
// if this is an LTR paragraph, and we're at the last row in the
// paragraph, move to lastpos
// 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.
// 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 =
+ bool const new_pos_is_RTL =
par.getFontSettings(buf.params(), pos()).isVisibleRightToLeft();
if (new_pos_is_RTL == left_of_pos) {
{
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
setSelection(true);
// A selection with no contents is not a selection
// FIXME: doesnt look ok
- if (idx() == normalAnchor().idx() &&
- pit() == normalAnchor().pit() &&
+ if (idx() == normalAnchor().idx() &&
+ pit() == normalAnchor().pit() &&
pos() == normalAnchor().pos())
setSelection(false);
}
os << "------------------------------- | " << cur.anchor_[i] << "\n";
}
os << " selection: " << cur.selection_
- << " x_target: " << cur.x_target_ << endl;
+ << " x_target: " << cur.x_target_
+ << " boundary: " << cur.boundary() << endl;
return os;
}
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->asInsetMath()));
else {
// insert remembered selection into first argument of a non-macro
else if (atom.nucleus()->nargs() > 0)
atom.nucleus()->cell(0).append(selection);
-
+
plainInsert(atom);
// finally put the macro argument behind, if needed
else
insert(selection);
}
-
+
return true;
}
else if (inset().asInsetText() && xo - textTargetOffset() != x_target()) {
// 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
push(*const_cast<InsetMathScript*>(p));
idx() = p->idxOfScript(up);
pos() = lastpos();
-
+
// we went in the right direction? Otherwise don't jump into the script
int x;
int y;
return true;
}
}
-
+
// try right
if (pos() != lastpos()) {
InsetMathScript const * p = nextAtom()->asScriptInset();
push(*const_cast<InsetMathScript*>(p));
idx() = p->idxOfScript(up);
pos() = 0;
-
+
// we went in the right direction? Otherwise don't jump into the script
int x;
int y;
}
}
}
-
+
// try to find an inset that knows better then we,
if (inset().idxUpDown(*this, up)) {
//lyxerr << "idxUpDown triggered" << endl;
setCursor(bruteFind2(*this, xo, yo));
return true;
}
-
+
// any improvement going just out of inset?
if (popBackward() && inMathed()) {
//lyxerr << "updown: popBackward succeeded" << endl;
if (up ? ynew < yold : ynew > yold)
return true;
}
-
+
// no success, we are probably at the document top or bottom
operator=(old);
return false;
{
TextMetrics const & tm = bv_->textMetrics(text());
ParagraphMetrics const & pm = tm.parMetrics(pit());
-
+
int row;
if (pos() && boundary())
row = pm.pos2row(pos() - 1);
else
row = pm.pos2row(pos());
-
+
if (up) {
if (pit() == 0 && row == 0)
return true;
bool Cursor::upDownInText(bool up, bool & updateNeeded)
{
- LASSERT(text(), /**/);
+ LASSERT(text(), return false);
// where are we?
int xo = 0;
// 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
xo = targetX();
} else
xo = targetX();
-
+
// first get the current line
TextMetrics & tm = bv_->textMetrics(text());
ParagraphMetrics const & pm = tm.parMetrics(pit());
row = pm.pos2row(pos() - 1);
else
row = pm.pos2row(pos());
-
+
if (atFirstOrLastRow(up)) {
// Is there a place for the cursor to go ? If yes, we
// can execute the DEPM, otherwise we should keep the
break;
}
- // will a next dispatch follow and if there is a new
+ // will a next dispatch follow and if there is a new
// dispatch will it move the cursor out ?
if (depth() > 1 && valid_destination) {
// The cursor hasn't changed yet. This happens when
- // you e.g. move out of an inset. And to give the
+ // you e.g. move out of an inset. And to give the
// DEPM the possibility of doing something we must
// provide it with two different cursors. (Lgb, vfr)
dummy = *this;
updateNeeded |= bv().checkDepm(dummy, *this);
updateTextTargetOffset();
- if (updateNeeded) {
+ if (updateNeeded)
forceBufferUpdate();
- // DEPM may have requested a screen update
- this->screenUpdateFlags(
- this->screenUpdate() | dummy.screenUpdate());
- }
}
return false;
}
else
tm.editXY(*this, xo, yo + textRow().descent() + 1);
clearSelection();
-
- // This happens when you move out of an inset.
- // And to give the DEPM the possibility of doing
- // something we must provide it with two different
- // cursors. (Lgb)
+
+ // This happens when you move out of an inset.
+ // And to give the DEPM the possibility of doing
+ // something we must provide it with two different
+ // cursors. (Lgb)
Cursor dummy = *this;
if (dummy == old)
++dummy.pos();
if (bv().checkDepm(dummy, old)) {
updateNeeded = true;
// Make sure that cur gets back whatever happened to dummy (Lgb)
- // This will include any screen update requested by DEPM
operator=(dummy);
}
} else {
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;
+ pos_type const col = tm.getColumnNearX(pit(), real_next_row,
+ xo, bound);
+ top().pos() = real_next_row.pos() + col;
+ boundary(bound);
updateNeeded |= bv().checkDepm(*this, old);
}
forceBufferUpdate();
updateTextTargetOffset();
return true;
-}
+}
void Cursor::handleFont(string const & font)
odocstringstream os;
os << '\n';
// only add blank line if we're not in a ParbreakIsNewline situation
- if (!cur->inset().getLayout().parbreakIsNewline()
+ if (!cur->inset().getLayout().parbreakIsNewline()
&& !cur->paragraph().layout().parbreak_is_newline)
os << '\n';
return os.str();
// 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...
CursorSlice const & sl = innerTextSlice();
Text const & text = *sl.text();
Paragraph const & par = text.getPar(sl.pit());
-
+
// on boundary, so we are really at the character before
pos_type pos = sl.pos();
if (pos > 0 && boundary())
--pos;
-
+
// on space? Take the font before (only for RTL boundary stay)
if (pos > 0) {
TextMetrics const & tm = bv().textMetrics(&text);
if (pos == sl.lastpos()
- || (par.isSeparator(pos)
+ || (par.isSeparator(pos)
&& !tm.isRTLBoundary(sl.pit(), pos)))
--pos;
}
-
+
// get font at the position
Font font = par.getFont(buffer()->params(), pos,
text.outerFont(sl.pit()));
{
bool const broken_cursor = DocIterator::fixIfBroken();
bool const broken_anchor = anchor_.fixIfBroken();
-
+
if (broken_cursor || broken_anchor) {
clearNewWordPosition();
clearSelection();
if (cur[i].inset().notifyCursorEnters(cur))
return true;
}
-
+
return false;
}
Buffer const * master = buffer()->masterBuffer();
master->tocBackend().updateItem(*this);
if (master != buffer() && !master->hasGuiDelegate())
- // In case the master has no gui associated with it,
+ // In case the master has no gui associated with it,
// the TocItem is not updated (part of bug 5699).
buffer()->tocBackend().updateItem(*this);
}