X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FCursor.cpp;h=7afefcf372e3b7cd26558c69af60f8dd28ecf55d;hb=4e50da3e655b9f8d26f7d5e439d72b219d32279d;hp=185d8669506f765711728866265333f0ec3f762e;hpb=d8db0e8515b0d1698264a11811e36ae78c94d353;p=lyx.git diff --git a/src/Cursor.cpp b/src/Cursor.cpp index 185d866950..7afefcf372 100644 --- a/src/Cursor.cpp +++ b/src/Cursor.cpp @@ -14,46 +14,48 @@ #include -#include "Bidi.h" +#include "Cursor.h" + #include "Buffer.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 "Language.h" +#include "Layout.h" #include "LyXAction.h" #include "LyXRC.h" #include "Paragraph.h" -#include "ParIterator.h" #include "Row.h" +#include "texstream.h" #include "Text.h" #include "TextMetrics.h" #include "TocBackend.h" -#include "support/lassert.h" #include "support/debug.h" #include "support/docstream.h" +#include "support/gettext.h" +#include "support/lassert.h" +#include "insets/InsetLayout.h" #include "insets/InsetTabular.h" -#include "insets/InsetText.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 "mathed/MathFactory.h" +#include "mathed/InsetMathMacro.h" -#include +#include "frontends/Application.h" #include #include #include +#include using namespace std; @@ -61,52 +63,34 @@ namespace lyx { 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::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(); - map const & data = - c.bv().coordCache().getInsets().getData(); - map::const_iterator I = data.find(inset); + 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 (I == data.end()) { + if (!insetCache.has(inset)) { it.top().pos() = 0; return it; } - Point o = I->second.pos; + Point const o = insetCache.xy(inset); inset->cursorPos(c.bv(), it.top(), c.boundary(), xo, yo); // Convert to absolute xo += o.x_; @@ -128,152 +112,622 @@ DocIterator bruteFind2(Cursor const & c, int x, int y) } -/* -/// 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); +} // namespace + + +// +// CursorData +// + + +CursorData::CursorData() + : DocIterator(), anchor_(), selection_(false), mark_(false), + word_selection_(false), current_font(inherit_font) +{} + + +CursorData::CursorData(Buffer * buffer) + : DocIterator(buffer), anchor_(), selection_(false), mark_(false), + word_selection_(false), current_font(inherit_font) +{} + + +CursorData::CursorData(DocIterator const & dit) + : DocIterator(dit), anchor_(), selection_(false), mark_(false), + word_selection_(false), current_font(inherit_font) +{} + + + + +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; +} + + +void CursorData::reset() +{ + clear(); + push_back(CursorSlice(buffer()->inset())); + anchor_ = doc_iterator_begin(buffer()); + anchor_.clear(); + new_word_ = doc_iterator_begin(buffer()); + new_word_.clear(); + selection_ = false; + mark_ = false; +} + + +void CursorData::setCursor(DocIterator const & cur) +{ + DocIterator::operator=(cur); +} + + +void CursorData::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 CursorData::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); + } +} + + +CursorSlice CursorData::normalAnchor() const +{ + if (!selection()) + return top(); + // 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. + if (anchor_.depth() < depth()) { + LYXERR0("Cursor is deeper than anchor. PLEASE REPORT.\nCursor is" + << *this); + const_cast(anchor_) = *this; + } + + CursorSlice normal = anchor_[depth() - 1]; + if (depth() < anchor_.depth() && top() <= normal) { + // anchor is behind cursor -> move anchor behind the inset + ++normal.pos(); + } + return normal; +} + + +void CursorData::setSelection() +{ + selection(true); + if (idx() == normalAnchor().idx() && + pit() == normalAnchor().pit() && + pos() == normalAnchor().pos()) + selection(false); +} + + +void CursorData::setSelection(DocIterator const & where, int n) +{ + setCursor(where); + selection(true); + anchor_ = where; + pos() += n; +} + + +void CursorData::resetAnchor() +{ + anchor_ = *this; + checkNewWordPosition(); +} + + +CursorSlice CursorData::selBegin() const +{ + if (!selection()) + return top(); + return normalAnchor() < top() ? normalAnchor() : top(); +} + + +CursorSlice CursorData::selEnd() const +{ + if (!selection()) + return top(); + return normalAnchor() > top() ? normalAnchor() : top(); +} + + +DocIterator CursorData::selectionBegin() const +{ + if (!selection()) + return *this; + + DocIterator di; + // FIXME: This is a work-around for the problem that + // CursorSlice doesn't keep track of the boundary. + if (normalAnchor() == top()) + di = anchor_.boundary() > boundary() ? anchor_ : *this; else - ++et.pit(); - - double best_dist = numeric_limits::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; - } - } + di = normalAnchor() < top() ? anchor_ : *this; + di.resize(depth()); + return di; +} + + +DocIterator CursorData::selectionEnd() const +{ + if (!selection()) + return *this; + + DocIterator di; + // FIXME: This is a work-around for the problem that + // CursorSlice doesn't keep track of the boundary. + if (normalAnchor() == top()) + di = anchor_.boundary() < boundary() ? anchor_ : *this; + else + di = normalAnchor() > top() ? anchor_ : *this; + + if (di.depth() > depth()) { + di.resize(depth()); + ++di.pos(); + di.boundary(true); + } + return di; +} + + +namespace { + +docstring parbreak(CursorData const * cur) +{ + if (cur->inset().getLayout().parbreakIgnored()) + return docstring(); + odocstringstream os; + os << '\n'; + // 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 CursorData::selectionAsString(bool const with_label, bool const skipdelete) const +{ + if (!selection()) + return docstring(); + + if (inMathed()) + return cap::grabSelection(*this); + + int label = with_label + ? AS_STR_LABEL | AS_STR_INSETS : AS_STR_INSETS; + if (skipdelete) + label = with_label + ? AS_STR_LABEL | AS_STR_INSETS | AS_STR_SKIPDELETE + : AS_STR_INSETS | AS_STR_SKIPDELETE; + + idx_type const startidx = selBegin().idx(); + idx_type const endidx = selEnd().idx(); + if (startidx != endidx) { + // multicell selection + InsetTabular * table = inset().asInsetTabular(); + LASSERT(table, return docstring()); + return table->asString(startidx, endidx); + } + + ParagraphList const & pars = text()->paragraphs(); + + pit_type const startpit = selBegin().pit(); + pit_type const endpit = selEnd().pit(); + size_t const startpos = selBegin().pos(); + size_t const endpos = selEnd().pos(); + + if (startpit == endpit) + return pars[startpit].asString(startpos, endpos, label); + + // First paragraph in selection + docstring result = pars[startpit]. + asString(startpos, pars[startpit].size(), label) + + 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(this); + } + + // Last paragraph in selection + result += pars[endpit].asString(0, endpos, label); + + return result; +} + + +void CursorData::info(odocstream & os, bool devel_mode) const +{ + for (int i = 1, n = depth(); i < n; ++i) { + operator[](i).inset().infoize(os); + os << " "; + } + if (pos() != 0) { + Inset const * inset = prevInset(); + // prevInset() can return 0 in certain case. + if (inset) + prevInset()->infoize2(os); + } + if (devel_mode) { + InsetMath * math = inset().asInsetMath(); + if (math) + os << _(", Inset: ") << math->id(); + os << _(", Cell: ") << idx(); + os << _(", Position: ") << pos(); + } + +} + +docstring CursorData::currentState(bool devel_mode) const +{ + if (inMathed()) { + odocstringstream os; + info(os, devel_mode); + return os.str(); + } + + if (inTexted()) + return text()->currentState(*this, devel_mode); + + return docstring(); +} + + +void CursorData::markNewWordPosition() +{ + 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 CursorData::clearNewWordPosition() +{ + if (!new_word_.empty()) { + LYXERR(Debug::DEBUG, "clear new word: " + << " par: " << pit() + << " pos: " << pos()); + new_word_.resize(0); + } +} + + +void CursorData::checkNewWordPosition() +{ + if (!lyxrc.spellcheck_continuously || new_word_.empty()) + return ; + // forget the position of the current new word if + // 1) or the remembered position was "broken" + // 2) or the count of nested insets changed + // 3) the top-level inset is not the same anymore + // 4) the cell index changed + // 5) or the paragraph changed + // 6) or the cursor pos is out of paragraph bound + if (new_word_.fixIfBroken() + || depth() != new_word_.depth() + || &inset() != &new_word_.inset() + || pit() != new_word_.pit() + || idx() != new_word_.idx() + || new_word_.pos() > new_word_.lastpos()) + 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(); + } +} + + +void CursorData::clearSelection() +{ + selection(false); + setWordSelection(false); + setMark(false); + resetAnchor(); +} + + +int CursorData::countInsetsInSelection(InsetCode const & inset_code) const +{ + if (!selection_) + return 0; + + DocIterator from, to; + from = selectionBegin(); + to = selectionEnd(); + + int count = 0; + + if (!from.nextInset()) //move to closest inset + from.forwardInset(); + + while (!from.empty() && from < to) { + Inset * inset = from.nextInset(); + if (!inset) + break; + if (inset->lyxCode() == inset_code) + count ++; + from.forwardInset(); + } + return count; +} + + +bool CursorData::insetInSelection(InsetCode const & inset_code) const +{ + if (!selection_) + return false; + + DocIterator from, to; + from = selectionBegin(); + to = selectionEnd(); + + if (!from.nextInset()) //move to closest inset + from.forwardInset(); + + while (!from.empty() && from < to) { + Inset * inset = from.nextInset(); + if (!inset) + break; + if (inset->lyxCode() == inset_code) + return true; + from.forwardInset(); + } + return false; +} + + +bool CursorData::fixIfBroken() +{ + bool const broken_cursor = DocIterator::fixIfBroken(); + bool const broken_anchor = anchor_.fixIfBroken(); + + if (broken_cursor || broken_anchor) { + clearNewWordPosition(); + clearSelection(); + return true; + } + return false; +} + + +void CursorData::sanitize() +{ + DocIterator::sanitize(); + new_word_.sanitize(); + if (selection()) + anchor_.sanitize(); + else + resetAnchor(); +} + + +bool CursorData::undoAction() +{ + if (!buffer()->undo().undoAction(*this)) + return false; + sanitize(); + return true; +} + + +bool CursorData::redoAction() +{ + if (!buffer()->undo().redoAction(*this)) + return false; + sanitize(); + return true; +} + + +void CursorData::finishUndo() const +{ + buffer()->undo().finishUndo(); +} + + +void CursorData::beginUndoGroup() const +{ + buffer()->undo().beginUndoGroup(*this); +} + + +void CursorData::endUndoGroup() const +{ + buffer()->undo().endUndoGroup(*this); +} + + +void CursorData::splitUndoGroup() const +{ + buffer()->undo().splitUndoGroup(*this); +} + + +void CursorData::recordUndo(pit_type from, pit_type to) const +{ + buffer()->undo().recordUndo(*this, from, to); +} + + +void CursorData::recordUndo(pit_type from) const +{ + buffer()->undo().recordUndo(*this, from, pit()); +} + + +void CursorData::recordUndo(UndoKind kind) const +{ + buffer()->undo().recordUndo(*this, kind); +} + + +void CursorData::recordUndoInset(Inset const * inset) const +{ + buffer()->undo().recordUndoInset(*this, inset); +} - if (best_cursor != et) { - cursor.setCursor(best_cursor); - return true; - } - return false; +void CursorData::recordUndoFullBuffer() const +{ + buffer()->undo().recordUndoFullBuffer(*this); } -*/ -/// moves position closest to (x, y) in given box -bool bruteFind3(Cursor & cur, int x, int y, bool up) +void CursorData::recordUndoBufferParams() const { - BufferView & bv = cur.bv(); - int ylow = up ? 0 : y + 1; - int yhigh = up ? y - 1 : bv.workHeight(); - int xlow = 0; - int xhigh = bv.workWidth(); + buffer()->undo().recordUndoBufferParams(*this); +} -// 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()); +void CursorData::recordUndoSelection() const +{ + if (inMathed()) { + if (cap::multipleCellsSelected(*this)) + recordUndoInset(); + else + recordUndo(); + } else { + buffer()->undo().recordUndo(*this, + selBegin().pit(), selEnd().pit()); + } +} + - double best_dist = numeric_limits::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.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; - //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; - } - } - } +int CursorData::currentMode() const +{ + 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(); + // Also return UNDECIDED_MODE when the mode is locked, + // as in this case it is treated the same as TEXT_MODE + if (res != Inset::UNDECIDED_MODE || locked_mode) + return res; } + return Inset::TEXT_MODE; +} - //lyxerr << "best_dist: " << best_dist << " cur:\n" << best_cursor << endl; - if (best_cursor == et) - return false; - cur.setCursor(best_cursor); - return true; + +bool CursorData::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; } -} // namespace anon + + +// +// Cursor +// // 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_(), + : CursorData(&bv.buffer()), bv_(&bv), x_target_(-1), textTargetOffset_(0), - selection_(false), mark_(false), word_selection_(false), - logicalpos_(false), current_font(inherit_font) + beforeDispatchPosX_(0), beforeDispatchPosY_(0) {} void Cursor::reset() { - clear(); - push_back(CursorSlice(buffer()->inset())); - anchor_ = doc_iterator_begin(buffer()); - anchor_.clear(); + CursorData::reset(); clearTargetX(); - selection_ = false; - mark_ = false; } -// this (intentionally) does neither touch anchor nor selection status -void Cursor::setCursor(DocIterator const & cur) +void Cursor::setCursorData(CursorData const & data) { - DocIterator::operator=(cur); + CursorData::operator=(data); } @@ -297,6 +751,7 @@ bool Cursor::getStatus(FuncRequest const & cmd, FuncStatus & status) const 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(), /**/); @@ -322,27 +777,29 @@ void Cursor::saveBeforeDispatchPosXY() 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; 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) && nextInset()) { disp_.dispatched(true); - disp_.update(Update::FitCursor | Update::Force); + disp_.screenUpdate(Update::FitCursor | Update::Force); FuncRequest tmpcmd = cmd; LYXERR(Debug::DEBUG, "Cursor::dispatch: (AtPoint) cmd: " << cmd0 << endl << *this); nextInset()->dispatch(*this, tmpcmd); if (disp_.dispatched()) { - buffer()->undo().endUndoGroup(); + endUndoGroup(); return; } } @@ -352,20 +809,23 @@ void Cursor::dispatch(FuncRequest const & cmd0) 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. // 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()) break; } - + // it completely to get a 'bomb early' behaviour in case this // object will be used again. if (!disp_.dispatched()) { @@ -373,21 +833,36 @@ void Cursor::dispatch(FuncRequest const & cmd0) // 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(); 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(); + + // 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(); + old.fixIfBroken(); + bool badcursor = notifyCursorLeavesOrEnters(old, *this); + if (badcursor) { + fixIfBroken(); + bv().resetInlineCompletionPos(); + } + old.endUndoGroup(); + } } @@ -397,33 +872,71 @@ DispatchResult const & Cursor::result() const } +void Cursor::message(docstring const & msg) const +{ + disp_.setMessage(msg); +} + + +void Cursor::errorMessage(docstring const & msg) const +{ + disp_.setMessage(msg); + disp_.setError(true); +} + + BufferView & Cursor::bv() const { - LASSERT(bv_, /**/); + LBUFERR(bv_); return *bv_; } void Cursor::pop() { - LASSERT(depth() >= 1, /**/); + LBUFERR(depth() >= 1); pop_back(); } -void Cursor::push(Inset & p) +void Cursor::push(Inset & inset) { - push_back(CursorSlice(p)); - p.setBuffer(*buffer()); + push_back(CursorSlice(inset)); + inset.setBuffer(*buffer()); } -void Cursor::pushBackward(Inset & p) +void Cursor::pushBackward(Inset & inset) { LASSERT(!empty(), return); //lyxerr << "Entering inset " << t << " front" << endl; + push(inset); + inset.idxFirst(*this); +} + + +void Cursor::editInsertedInset() +{ + LASSERT(!empty(), return); + if (pos() == 0) + return; + + InsetMath &p = prevMath(); + if (!p.isActive()) + return; + + posBackward(); push(p); p.idxFirst(*this); + // this could be a while() loop, but only one cell is not empty in + // cases we are interested in. The cell is not empty because we + // have inserted the selection in there. + if (!cell().empty()) { + // if it is not empty, move to the next one. + if (!inset().idxNext(*this)) + // If there is no next one, exit the inset. + popForward(); + } } @@ -450,24 +963,9 @@ bool Cursor::popForward() } -int Cursor::currentMode() -{ - LASSERT(!empty(), /**/); - for (int i = depth() - 1; i >= 0; --i) { - int res = operator[](i).inset().currentMode(); - bool locked_mode = operator[](i).inset().lockedMode(); - // Also return UNDECIDED_MODE when the mode is locked, - // as in this case it is treated the same as TEXT_MODE - if (res != Inset::UNDECIDED_MODE || locked_mode) - return res; - } - return Inset::TEXT_MODE; -} - - 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_; } @@ -477,54 +975,15 @@ Row const & Cursor::textRow() const { 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; -} - - -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); - } -} - - -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); @@ -535,51 +994,58 @@ bool Cursor::posVisRight(bool skip_inset) 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()); } // 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()) << "," + + // 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. - new_pos_is_RTL = paragraph().getFontSettings( + // 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. + 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 *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() ) @@ -587,23 +1053,20 @@ bool Cursor::posVisRight(bool skip_inset) 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); } - + } - 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() + LYXERR(Debug::RTL, "moving to: " << new_cur.pos() << (new_cur.boundary() ? " (boundary)" : "")); *this = new_cur; } @@ -617,7 +1080,6 @@ bool Cursor::posVisLeft(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); @@ -626,53 +1088,60 @@ bool Cursor::posVisLeft(bool skip_inset) // 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 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()); } // 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()) << "," + + // 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. - new_pos_is_RTL = paragraph().getFontSettings( + // 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. + 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 *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() ) @@ -680,154 +1149,142 @@ bool Cursor::posVisLeft(bool skip_inset) 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); } - + } - 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() + LYXERR(Debug::RTL, "moving to: " << new_cur.pos() << (new_cur.boundary() ? " (boundary)" : "")); *this = new_cur; } - + return moved; } -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) +{ + 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 { - // preparing bidi tables - Paragraph const & par = paragraph(); - Buffer const & buf = *buffer(); + // 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); + // Inside a table, determining whether to move to the next or + // previous row should be done based on the table's direction. + if (inset().asInsetTabular()) { + par_is_LTR = !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 @@ -836,245 +1293,62 @@ bool Cursor::posVisToNewRow(bool movingLeft) --pit(); pos() = lastpos(); boundary(false); - } else { // move to previous row in this par - pos() = row.pos() - 1; // this is guaranteed to be in previous row - boundary(false); - } - } - // 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 - return false; - // move to first row in next par - ++pit(); - pos() = 0; - boundary(false); - } else { // move to next row in this par - pos() = row.endpos(); - boundary(false); - } - } - - // make sure we're at left-/right-most pos in new row - posVisToRowExtremity(!movingLeft); - - return true; -} - - -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); - } - } - } - LYXERR(Debug::RTL, "leaving extremity: " << pit() << "," << pos() << "," - << (boundary() ? 1 : 0)); -} - - -CursorSlice Cursor::normalAnchor() const -{ - if (!selection()) - return top(); - LASSERT(anchor_.depth() >= depth(), /**/); - CursorSlice normal = anchor_[depth() - 1]; - if (depth() < anchor_.depth() && top() <= normal) { - // anchor is behind cursor -> move anchor behind the inset - ++normal.pos(); - } - return normal; -} - - -CursorSlice Cursor::selBegin() const -{ - if (!selection()) - return top(); - return normalAnchor() < top() ? normalAnchor() : top(); -} - - -CursorSlice Cursor::selEnd() const -{ - if (!selection()) - return top(); - return normalAnchor() > top() ? normalAnchor() : top(); -} - - -DocIterator Cursor::selectionBegin() const -{ - if (!selection()) - return *this; - - DocIterator di; - // FIXME: This is a work-around for the problem that - // CursorSlice doesn't keep track of the boundary. - if (normalAnchor() == top()) - di = anchor_.boundary() > boundary() ? anchor_ : *this; - else - di = normalAnchor() < top() ? anchor_ : *this; - di.resize(depth()); - return di; -} - - -DocIterator Cursor::selectionEnd() const -{ - if (!selection()) - return *this; + } else { // move to previous row in this par + pos() = row.pos() - 1; // this is guaranteed to be in previous row + boundary(false); + } + } + // 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 + return false; + // move to first row in next par + ++pit(); + pos() = 0; + boundary(false); + } else { // move to next row in this par + pos() = row.endpos(); + boundary(false); + } + } - DocIterator di; - // FIXME: This is a work-around for the problem that - // CursorSlice doesn't keep track of the boundary. - if (normalAnchor() == top()) - di = anchor_.boundary() < boundary() ? anchor_ : *this; - else - di = normalAnchor() > top() ? anchor_ : *this; + // make sure we're at left-/right-most pos in new row + posVisToRowExtremity(!movingLeft); - if (di.depth() > depth()) { - di.resize(depth()); - ++di.pos(); - } - return di; + return true; } -void Cursor::setSelection() +void Cursor::posVisToRowExtremity(bool left) { - setSelection(true); - // A selection with no contents is not a selection - // FIXME: doesnt look ok - if (idx() == normalAnchor().idx() && - pit() == normalAnchor().pit() && - pos() == normalAnchor().pos()) - setSelection(false); -} + LYXERR(Debug::RTL, "entering extremity: " << pit() << "," << pos() << "," + << (boundary() ? 1 : 0)); + 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); -void Cursor::setSelection(DocIterator const & where, int n) -{ - setCursor(where); - setSelection(true); - anchor_ = where; - pos() += n; + LYXERR(Debug::RTL, "leaving extremity: " << pit() << "," << pos() << "," + << (boundary() ? 1 : 0)); } -void Cursor::clearSelection() +bool Cursor::reverseDirectionNeeded() const { - setSelection(false); - setWordSelection(false); - setMark(false); - resetAnchor(); + /* + * 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()); } @@ -1107,64 +1381,43 @@ void Cursor::updateTextTargetOffset() } -void Cursor::info(odocstream & os) const -{ - for (int i = 1, n = depth(); i < n; ++i) { - operator[](i).inset().infoize(os); - os << " "; - } - if (pos() != 0) { - Inset const * inset = prevInset(); - // prevInset() can return 0 in certain case. - if (inset) - prevInset()->infoize2(os); - } - // overwite old message - os << " "; -} - - -bool Cursor::selHandle(bool sel) +bool Cursor::selHandle(bool selecting) { //lyxerr << "Cursor::selHandle" << endl; if (mark()) - sel = true; - if (sel == selection()) + selecting = true; + if (selecting == selection()) return false; - if (!sel) + if (!selecting) cap::saveSelection(*this); resetAnchor(); - setSelection(sel); + selection(selecting); return true; } -ostream & operator<<(ostream & os, Cursor const & cur) +bool Cursor::atFirstOrLastRow(bool up) { - 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; -} + 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()); -LyXErr & operator<<(LyXErr & os, Cursor const & cur) -{ - os.stream() << cur; - return os; + if (up) { + if (pit() == 0 && row == 0) + return true; + } else { + if (pit() + 1 >= int(text()->paragraphs().size()) && + row + 1 >= int(pm.rows().size())) + return true; + } + return false; } @@ -1181,39 +1434,13 @@ LyXErr & operator<<(LyXErr & os, Cursor const & cur) /////////////////////////////////////////////////////////////////// #include "mathed/InsetMathChar.h" -#include "mathed/InsetMathGrid.h" -#include "mathed/InsetMathScript.h" #include "mathed/InsetMathUnknown.h" -#include "mathed/MathFactory.h" #include "mathed/MathStream.h" #include "mathed/MathSupport.h" namespace lyx { -//#define FILEDEBUG 1 - - -bool Cursor::isInside(Inset const * p) const -{ - for (size_t i = 0; i != depth(); ++i) - if (&operator[](i).inset() == p) - return true; - return false; -} - - -void Cursor::leaveInset(Inset const & inset) -{ - for (size_t i = 0; i != depth(); ++i) { - if (&operator[](i).inset() == &inset) { - resize(i); - return; - } - } -} - - bool Cursor::openable(MathAtom const & t) const { if (!t->isActive()) @@ -1226,62 +1453,35 @@ bool Cursor::openable(MathAtom const & t) const return true; // we can't move into anything new during selection - if (depth() >= anchor_.depth()) + if (depth() >= realAnchor().depth()) return false; - if (t.nucleus() != &anchor_[depth()].inset()) + if (t.nucleus() != &realAnchor()[depth()].inset()) return false; return true; } -void Cursor::setScreenPos(int x, int /*y*/) -{ - setTargetX(x); - //bruteFind(*this, x, y, 0, bv().workWidth(), 0, bv().workHeight()); -} - - - void Cursor::plainErase() { cell().erase(pos()); } -void Cursor::markInsert() -{ - insert(char_type(0)); -} - - -void Cursor::markErase() -{ - cell().erase(pos()); -} - - void Cursor::plainInsert(MathAtom const & t) { cell().insert(pos(), t); ++pos(); inset().setBuffer(bv_->buffer()); inset().initView(); -} - - -void Cursor::insert(docstring const & str) -{ - for_each(str.begin(), str.end(), - boost::bind(static_cast - (&Cursor::insert), this, _1)); + checkBufferStructure(); } 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)); @@ -1291,74 +1491,92 @@ void Cursor::insert(char_type c) } -void Cursor::insert(MathAtom const & t) +void Cursor::insert(docstring const & str) { - //lyxerr << "Cursor::insert MathAtom '" << t << "'" << endl; - macroModeClose(); - cap::selClearOrDel(*this); - plainInsert(t); + for (char_type c : str) + insert(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) +void Cursor::insert(MathAtom const & t) +{ + LATTEST(inMathed()); + //lyxerr << "Cursor::insert MathAtom '" << t << "'" << endl; + macroModeClose(); + cap::selClearOrDel(*this); + plainInsert(t); +} + + +void Cursor::insert(MathData const & ar) +{ + LATTEST(inMathed()); + macroModeClose(); + if (selection()) + cap::eraseSelection(*this); + cell().insert(pos(), ar); + pos() += ar.size(); + // FIXME audit setBuffer calls + inset().setBuffer(bv_->buffer()); +} + + +int Cursor::niceInsert(docstring const & t, Parse::flags f, bool enter) { + LATTEST(inMathed()); MathData ar(buffer()); asArray(t, ar, f); if (ar.size() == 1 && (enter || selection())) niceInsert(ar[0]); else insert(ar); + return ar.size(); } void Cursor::niceInsert(MathAtom const & t) { + LATTEST(inMathed()); macroModeClose(); docstring const safe = cap::grabAndEraseSelection(*this); plainInsert(t); // If possible, enter the new inset and move the contents of the selection if (t->isActive()) { - posBackward(); - // be careful here: don't use 'pushBackward(t)' as this we need to - // push the clone, not the original - pushBackward(*nextInset()); - // We may not use niceInsert here (recursion) + idx_type const idx = prevMath().asNestInset()->firstIdx(); MathData ar(buffer()); asArray(safe, ar); - insert(ar); + prevMath().cell(idx).insert(0, ar); + editInsertedInset(); + } 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(); + } } } -void Cursor::insert(MathData const & ar) -{ - macroModeClose(); - if (selection()) - cap::eraseSelection(*this); - cell().insert(pos(), ar); - pos() += ar.size(); - // FIXME audit setBuffer/updateBuffer calls - inset().setBuffer(bv_->buffer()); -} - - -bool Cursor::backspace() +bool Cursor::backspace(bool const force) { - autocorrect() = false; - if (selection()) { cap::eraseSelection(*this); return true; @@ -1377,9 +1595,20 @@ bool Cursor::backspace() // [|], can not delete from inside return false; } else { - if (inMathed()) - pullArg(); - else + if (inMathed()) { + switch (inset().asInsetMath()->getType()) { + case hullEqnArray: + case hullAlign: + case hullFlAlign: { + FuncRequest cmd(LFUN_CHAR_BACKWARD); + this->dispatch(cmd); + break; + } + default: + pullArg(); + break; + } + } else popBackward(); return true; } @@ -1393,11 +1622,11 @@ bool Cursor::backspace() } } - 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(); @@ -1407,9 +1636,8 @@ bool Cursor::backspace() } -bool Cursor::erase() +bool Cursor::erase(bool const force) { - autocorrect() = false; if (inMacroMode()) return true; @@ -1443,9 +1671,9 @@ bool Cursor::erase() } // '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(); @@ -1464,7 +1692,6 @@ bool Cursor::up() if (disp_.dispatched()) return true; setCursor(save); - autocorrect() = false; return false; } @@ -1478,12 +1705,51 @@ bool Cursor::down() if (disp_.dispatched()) return true; setCursor(save); - autocorrect() = false; return false; } -bool Cursor::macroModeClose() +void Cursor::handleNest(MathAtom const & a) +{ + idx_type const idx = a.nucleus()->asNestInset()->firstIdx(); + //lyxerr << "Cursor::handleNest: " << idx << endl; + InsetMath const * im = selectionBegin().inset().asInsetMath(); + Parse::flags const f = im && im->currentMode() != InsetMath::MATH_MODE + ? Parse::TEXTMODE : Parse::NORMAL; + MathAtom t = a; + asArray(cap::grabAndEraseSelection(*this), t.nucleus()->cell(idx), f); + insert(t); + editInsertedInset(); +} + + +int Cursor::targetX() const +{ + if (x_target() != -1) + return x_target(); + int x = 0; + int y = 0; + getPos(x, y); + return x; +} + + +int Cursor::textTargetOffset() const +{ + return textTargetOffset_; +} + + +void Cursor::setTargetX() +{ + int x; + int y; + getPos(x, y); + setTargetX(x); +} + + +bool Cursor::macroModeClose(bool cancel) { if (!inMacroMode()) return false; @@ -1495,95 +1761,78 @@ bool Cursor::macroModeClose() --pos(); cell().erase(pos()); - // do nothing if the macro name is empty - if (s == "\\") - return false; - // trigger updates of macros, at least, if no full // updates take place anyway - updateFlags(Update::Force); + screenUpdateFlags(Update::Force); + + // do nothing if the macro name is empty + if (s == "\\" || cancel) { + return false; + } docstring const name = s.substr(1); 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(); + InsetMathNest * atomAsNest = atom.nucleus()->asNestInset(); 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 // 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()) { 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); - } - - // 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 - if (macroArg) { - if (selection.size() > 1 || selection[0]->asScriptInset()) - plainInsert(MathAtom(new InsetMathBrace(selection))); - else - insert(selection); - } - - return true; -} - - -docstring Cursor::macroName() -{ - return inMacroMode() ? activeMacro()->name() : docstring(); -} - - -void Cursor::handleNest(MathAtom const & a, int c) -{ - //lyxerr << "Cursor::handleNest: " << c << endl; - MathAtom t = a; - asArray(cap::grabAndEraseSelection(*this), t.nucleus()->cell(c)); - insert(t); - posBackward(); - pushBackward(*nextInset()); -} - - -int Cursor::targetX() const -{ - if (x_target() != -1) - return x_target(); - int x = 0; - int y = 0; - getPos(x, y); - return x; -} - + atomAsMacro->setDisplayMode(InsetMathMacro::DISPLAY_INTERACTIVE_INIT, 0); + } -int Cursor::textTargetOffset() const -{ - return textTargetOffset_; -} + // insert remembered selection into first argument of a non-macro + else if (atomAsNest && atomAsNest->nargs() > 0) + atomAsNest->cell(atomAsNest->firstIdx()).append(selection); + + 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) { + if (selection.size() > 1 || selection[0]->asScriptInset()) + plainInsert(MathAtom(new InsetMathBrace(selection))); + else + insert(selection); + } -void Cursor::setTargetX() -{ - int x; - int y; - getPos(x, y); - setTargetX(x); + return true; } @@ -1591,7 +1840,7 @@ bool Cursor::inMacroMode() const { if (!inMathed()) return false; - if (pos() == 0) + if (pos() == 0 || cell().empty()) return false; InsetMathUnknown const * p = prevAtom()->asUnknownInset(); return p && !p->final(); @@ -1600,13 +1849,19 @@ bool Cursor::inMacroMode() const InsetMathUnknown * Cursor::activeMacro() { - return inMacroMode() ? prevAtom().nucleus()->asUnknownInset() : 0; + return inMacroMode() ? prevAtom().nucleus()->asUnknownInset() : nullptr; } InsetMathUnknown const * Cursor::activeMacro() const { - return inMacroMode() ? prevAtom().nucleus()->asUnknownInset() : 0; + return inMacroMode() ? prevAtom().nucleus()->asUnknownInset() : nullptr; +} + + +docstring Cursor::macroName() +{ + return inMacroMode() ? activeMacro()->name() : docstring(); } @@ -1624,18 +1879,6 @@ void Cursor::pullArg() } -void Cursor::touch() -{ - // FIXME: look here -#if 0 - DocIterator::const_iterator it = begin(); - DocIterator::const_iterator et = end(); - for ( ; it != et; ++it) - it->cell().touch(); -#endif -} - - void Cursor::normalize() { if (idx() > lastidx()) { @@ -1650,7 +1893,8 @@ void Cursor::normalize() << pos() << ' ' << lastpos() << " in idx: " << idx() << " in atom: '"; odocstringstream os; - WriteStream wi(os, false, true, WriteStream::wsDefault); + otexrowstream ots(os); + TeXMathStream wi(ots, false, true, TeXMathStream::wsDefault); inset().asInsetMath()->write(wi); lyxerr << to_utf8(os.str()) << endl; pos() = lastpos(); @@ -1676,13 +1920,13 @@ bool Cursor::upDownInMath(bool up) 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 // 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) { @@ -1712,7 +1956,7 @@ bool Cursor::upDownInMath(bool up) push(*const_cast(p)); idx() = p->idxOfScript(up); pos() = lastpos(); - + // we went in the right direction? Otherwise don't jump into the script int x; int y; @@ -1725,7 +1969,7 @@ bool Cursor::upDownInMath(bool up) return true; } } - + // try right if (pos() != lastpos()) { InsetMathScript const * p = nextAtom()->asScriptInset(); @@ -1733,7 +1977,7 @@ bool Cursor::upDownInMath(bool up) push(*const_cast(p)); idx() = p->idxOfScript(up); pos() = 0; - + // we went in the right direction? Otherwise don't jump into the script int x; int y; @@ -1747,16 +1991,16 @@ bool Cursor::upDownInMath(bool up) } } } - + // try to find an inset that knows better then we, if (inset().idxUpDown(*this, up)) { //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; } - + // any improvement going just out of inset? if (popBackward() && inMathed()) { //lyxerr << "updown: popBackward succeeded" << endl; @@ -1767,38 +2011,132 @@ bool Cursor::upDownInMath(bool up) if (up ? ynew < yold : ynew > yold) return true; } - + // no success, we are probably at the document top or bottom operator=(old); return false; } -bool Cursor::atFirstOrLastRow(bool up) +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())) { + InsetMathScript const * n = nextMath().asScriptInset(); + bool to_brace_deco = n && !n->nuc().empty() + && n->nuc().back()->lyxCode() == MATH_DECORATION_CODE + && n->nuc().back()->mathClass() == MC_OP; + // single step: try to enter the next inset + pushBackward(nextMath()); + inset().idxFirst(*this); + // Make sure the cursor moves directly to an + // \overbrace or \underbrace inset (bug 2264) + if (to_brace_deco) { + pushBackward(nextMath()); + inset().idxFirst(*this); + } + } else + posForward(); + return true; + } + if (inset().idxForward(*this)) + return true; + InsetMath const * m = inset().asInsetMath(); + bool from_brace_deco = m + && m->lyxCode() == MATH_DECORATION_CODE + && m->mathClass() == MC_OP; + // 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() && popForward()) { + // Make sure the cursor moves directly to an + // \overbrace or \underbrace inset (bug 2264) + bool to_script = inset().asInsetMath() + && inset().asInsetMath()->asScriptInset(); + return from_brace_deco && to_script ? mathForward(word) : true; + } + return false; +} + + +bool Cursor::mathBackward(bool word) { - 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; - } else { - if (pit() + 1 >= int(text()->paragraphs().size()) && - row + 1 >= int(pm.rows().size())) - return true; + 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())) { + InsetMathScript const * p = prevMath().asScriptInset(); + bool to_brace_deco = p && !p->nuc().empty() + && p->nuc().back()->lyxCode() == MATH_DECORATION_CODE + && p->nuc().back()->mathClass() == MC_OP; + // single step: try to enter the preceding inset + posBackward(); + push(nextMath()); + inset().idxLast(*this); + // Make sure the cursor moves directly to an + // \overbrace or \underbrace inset (bug 2264) + if (to_brace_deco) { + posBackward(); + push(nextMath()); + inset().idxLast(*this); + } + } else + posBackward(); + return true; + } + if (inset().idxBackward(*this)) + return true; + InsetMath const * m = inset().asInsetMath(); + bool from_brace_deco = m + && m->lyxCode() == MATH_DECORATION_CODE + && m->mathClass() == MC_OP; + // 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() && popBackward()) { + // Make sure the cursor moves directly to an + // \overbrace or \underbrace inset (bug 2264) + bool to_script = inset().asInsetMath() + && inset().asInsetMath()->asScriptInset(); + return from_brace_deco && to_script ? mathBackward(word) : true; } return false; } + bool Cursor::upDownInText(bool up, bool & updateNeeded) { - LASSERT(text(), /**/); + LASSERT(text(), return false); // where are we? int xo = 0; @@ -1813,15 +2151,17 @@ bool Cursor::upDownInText(bool up, bool & updateNeeded) 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. - - // 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); + // 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 + bool inRTL = innerParagraph().isRTL(bv().buffer().params()); bool left; bool right; if (inRTL) { @@ -1839,7 +2179,7 @@ bool Cursor::upDownInText(bool up, bool & updateNeeded) xo = targetX(); } else xo = targetX(); - + // first get the current line TextMetrics & tm = bv_->textMetrics(text()); ParagraphMetrics const & pm = tm.parMetrics(pit()); @@ -1848,7 +2188,7 @@ bool Cursor::upDownInText(bool up, bool & updateNeeded) 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 @@ -1861,11 +2201,11 @@ bool Cursor::upDownInText(bool up, bool & updateNeeded) 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; @@ -1874,33 +2214,40 @@ bool Cursor::upDownInText(bool up, bool & updateNeeded) updateNeeded |= bv().checkDepm(dummy, *this); updateTextTargetOffset(); + if (updateNeeded) + forceBufferUpdate(); } return false; } // with and without selection are handled differently if (!selection()) { - int yo = bv().getPos(*this, boundary()).y_; + int yo1 = 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); + tm.editXY(*this, xo, yo1 - textRow().ascent() - 1); else - tm.editXY(*this, xo, yo + textRow().descent() + 1); + tm.editXY(*this, xo, yo1 + textRow().descent() + 1); + x_target_ = old.x_target_; 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) + // 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: @@ -1911,10 +2258,10 @@ bool Cursor::upDownInText(bool up, bool & updateNeeded) --next_row; } else if (pit() > 0) { --pit(); - TextMetrics & tm = bv_->textMetrics(text()); - if (!tm.contains(pit())) - tm.newParMetricsUp(); - ParagraphMetrics const & pmcur = tm.parMetrics(pit()); + TextMetrics & tm2 = bv_->textMetrics(text()); + if (!tm2.contains(pit())) + tm2.newParMetricsUp(); + ParagraphMetrics const & pmcur = tm2.parMetrics(pit()); next_row = pmcur.rows().size() - 1; } } else { @@ -1922,30 +2269,28 @@ bool Cursor::upDownInText(bool up, bool & updateNeeded) ++next_row; } else if (pit() + 1 < int(text()->paragraphs().size())) { ++pit(); - TextMetrics & tm = bv_->textMetrics(text()); - if (!tm.contains(pit())) - tm.newParMetricsDown(); + TextMetrics & tm2 = bv_->textMetrics(text()); + if (!tm2.contains(pit())) + tm2.newParMetricsDown(); 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); } + if (updateNeeded) + forceBufferUpdate(); updateTextTargetOffset(); return true; -} +} void Cursor::handleFont(string const & font) @@ -1986,162 +2331,75 @@ void Cursor::handleFont(string const & font) } -void Cursor::message(docstring const & msg) const -{ - disp_.setMessage(msg); -} - - -void Cursor::errorMessage(docstring const & msg) const -{ - disp_.setMessage(msg); - disp_.setError(true); -} - - -static docstring parbreak(InsetCode code) -{ - 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) - os << '\n'; - return os.str(); -} - - -docstring Cursor::selectionAsString(bool with_label) const -{ - if (!selection()) - return docstring(); - - if (inMathed()) - return cap::grabSelection(*this); - - int const label = with_label - ? AS_STR_LABEL | AS_STR_INSETS : AS_STR_INSETS; - - idx_type const startidx = selBegin().idx(); - idx_type const endidx = selEnd().idx(); - if (startidx != endidx) { - // multicell selection - InsetTabular * table = inset().asInsetTabular(); - LASSERT(table, return docstring()); - return table->asString(startidx, endidx); - } - - ParagraphList const & pars = text()->paragraphs(); - - pit_type const startpit = selBegin().pit(); - pit_type const endpit = selEnd().pit(); - size_t const startpos = selBegin().pos(); - size_t const endpos = selEnd().pos(); - - if (startpit == endpit) - return pars[startpit].asString(startpos, endpos, label); - - // First paragraph in selection - docstring result = pars[startpit]. - asString(startpos, pars[startpit].size(), label) - + parbreak(inset().lyxCode()); - - // 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()); - } - - // Last paragraph in selection - result += pars[endpit].asString(0, endpos, label); - - return result; -} - - -docstring Cursor::currentState() const +void Cursor::undispatched() const { - if (inMathed()) { - odocstringstream os; - info(os); - return os.str(); - } - - if (inTexted()) - return text()->currentState(*this); - - return docstring(); + disp_.dispatched(false); } -docstring Cursor::getPossibleLabel() const +void Cursor::dispatched() const { - return inMathed() ? from_ascii("eq:") : text()->getPossibleLabel(*this); + disp_.dispatched(true); } -Encoding const * Cursor::getEncoding() const +void Cursor::screenUpdateFlags(Update::flags f) 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(); + disp_.screenUpdate(f); } -void Cursor::undispatched() +void Cursor::noScreenUpdate() const { - disp_.dispatched(false); + disp_.screenUpdate(Update::None); } -void Cursor::dispatched() +void Cursor::forceBufferUpdate() const { - disp_.dispatched(true); + disp_.forceBufferUpdate(); } -void Cursor::updateFlags(Update::flags f) +void Cursor::clearBufferUpdate() const { - disp_.update(f); + disp_.clearBufferUpdate(); } -void Cursor::noUpdate() +bool Cursor::needBufferUpdate() const { - disp_.update(Update::None); + return disp_.needBufferUpdate(); } 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. + // FIXME: this is not the case, what about removing this method ? (see #10478). + // 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())); @@ -2150,16 +2408,10 @@ Font Cursor::getFont() const } -bool Cursor::fixIfBroken() +void Cursor::sanitize() { - bool const broken_cursor = DocIterator::fixIfBroken(); - bool const broken_anchor = anchor_.fixIfBroken(); - - if (broken_cursor || broken_anchor) { - clearSelection(); - return true; - } - return false; + setBuffer(&bv_->buffer()); + CursorData::sanitize(); } @@ -2195,11 +2447,27 @@ bool notifyCursorLeavesOrEnters(Cursor const & old, Cursor & cur) if (cur[i].inset().notifyCursorEnters(cur)) return true; } - + return false; } +void Cursor::setLanguageFromInput() +{ + if (!lyxrc.respect_os_kbd_language + || !inTexted() + || paragraph().isPassThru()) + return; + string const & code = theApp()->inputLanguageCode(); + Language const * lang = languages.getFromCode(code, buffer()->getLanguages()); + if (lang) { + current_font.setLanguage(lang); + real_current_font.setLanguage(lang); + } else + LYXERR0("setLanguageFromCode: unknown language code " << code); +} + + void Cursor::setCurrentFont() { CursorSlice const & cs = innerTextSlice(); @@ -2233,6 +2501,9 @@ void Cursor::setCurrentFont() current_font = par.getFontSettings(bufparams, cpos); real_current_font = tm.displayFont(cpit, cpos); + // set language to input language + setLanguageFromInput(); + // special case for paragraph end if (cs.pos() == lastpos() && tm.isRTLBoundary(cpit, cs.pos()) @@ -2243,108 +2514,45 @@ void Cursor::setCurrentFont() real_current_font.setLanguage(lang); real_current_font.fontInfo().setNumber(FONT_OFF); } -} - - -bool Cursor::textUndo() -{ - DocIterator dit = *this; - // Undo::textUndo() will modify dit. - if (!buffer()->undo().textUndo(dit)) - return false; - // Set cursor - setCursor(dit); - clearSelection(); - fixIfBroken(); - return true; -} - - -bool Cursor::textRedo() -{ - DocIterator dit = *this; - // Undo::textRedo() will modify dit. - if (!buffer()->undo().textRedo(dit)) - return false; - // Set cursor - setCursor(dit); - clearSelection(); - fixIfBroken(); - return true; -} - - -void Cursor::finishUndo() const -{ - buffer()->undo().finishUndo(); -} - - -void Cursor::beginUndoGroup() const -{ - buffer()->undo().beginUndoGroup(); -} - - -void Cursor::endUndoGroup() const -{ - buffer()->undo().endUndoGroup(); -} - - -void Cursor::recordUndo(UndoKind kind, pit_type from, pit_type to) const -{ - buffer()->undo().recordUndo(*this, kind, from, to); -} - - -void Cursor::recordUndo(UndoKind kind, pit_type from) const -{ - buffer()->undo().recordUndo(*this, kind, from); -} - - -void Cursor::recordUndo(UndoKind kind) const -{ - buffer()->undo().recordUndo(*this, kind); -} - - -void Cursor::recordUndoInset(UndoKind kind) const -{ - buffer()->undo().recordUndoInset(*this, kind); -} - - -void Cursor::recordUndoFullDocument() const -{ - buffer()->undo().recordUndoFullDocument(*this); -} - -void Cursor::recordUndoSelection() const -{ - if (inMathed()) { - if (cap::multipleCellsSelected(*this)) - recordUndoInset(); - else - recordUndo(); - } else { - buffer()->undo().recordUndo(*this, ATOMIC_UNDO, - selBegin().pit(), selEnd().pit()); + // No language in pass thru situations + if (cs.paragraph().isPassThru()) { + current_font.setLanguage(latex_language); + real_current_font.setLanguage(latex_language); } } void Cursor::checkBufferStructure() { + if (buffer()->isInternal()) + return; + 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); } +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(); + } +} + + } // namespace lyx