+ 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<DocIterator &>(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
+ 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);
+}
+
+
+void CursorData::recordUndoFullBuffer() const
+{
+ buffer()->undo().recordUndoFullBuffer(*this);
+}
+
+
+void CursorData::recordUndoBufferParams() const
+{
+ buffer()->undo().recordUndoBufferParams(*this);
+}
+
+
+void CursorData::recordUndoSelection() const
+{
+ if (inMathed()) {
+ if (cap::multipleCellsSelected(*this))
+ recordUndoInset();
+ else
+ recordUndo();
+ } else {
+ buffer()->undo().recordUndo(*this,
+ selBegin().pit(), selEnd().pit());
+ }
+}
+
+
+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;