#include <config.h>
#include "Buffer.h"
-#include "BufferParams.h"
#include "BufferView.h"
#include "CoordCache.h"
#include "Cursor.h"
#include "CutAndPaste.h"
#include "DispatchResult.h"
-#include "Encoding.h"
-#include "Font.h"
#include "FuncCode.h"
#include "FuncRequest.h"
-#include "Language.h"
#include "Layout.h"
#include "LyXAction.h"
#include "LyXRC.h"
#include "mathed/MacroTable.h"
#include "mathed/MathData.h"
#include "mathed/MathFactory.h"
-#include "mathed/MathMacro.h"
+#include "mathed/InsetMathMacro.h"
#include <sstream>
#include <limits>
}
-} // namespace anon
+} // namespace
+
+
+//
+// CursorData
+//
CursorData::CursorData()
- : DocIterator(), anchor_(),
- selection_(false), mark_(false), word_selection_(false),
- current_font(inherit_font),
- autocorrect_(false), macromode_(false)
+ : DocIterator(), anchor_(), selection_(false), mark_(false),
+ word_selection_(false), current_font(inherit_font), autocorrect_(false)
{}
CursorData::CursorData(Buffer * buffer)
- : DocIterator(buffer), anchor_(),
- selection_(false), mark_(false), word_selection_(false),
- current_font(inherit_font),
- autocorrect_(false), macromode_(false)
+ : DocIterator(buffer), anchor_(), selection_(false), mark_(false),
+ word_selection_(false), current_font(inherit_font), autocorrect_(false)
{}
CursorData::CursorData(DocIterator const & dit)
- : DocIterator(dit), anchor_(),
- selection_(false), mark_(false), word_selection_(false),
- current_font(inherit_font),
- autocorrect_(false), macromode_(false)
+ : DocIterator(dit), anchor_(), selection_(false), mark_(false),
+ word_selection_(false), current_font(inherit_font), autocorrect_(false)
{}
}
-LyXErr & operator<<(LyXErr & os, CursorData const & cur)
-{
- os.stream() << cur;
- 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();
+ }
+ return di;
+}
+
+
+namespace {
+
+docstring parbreak(CursorData const * cur)
+{
+ 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 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(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 ;
+ if (!inTexted())
+ clearNewWordPosition();
+ else {
+ // forget the position of the current new word if
+ // 1) the paragraph changes or
+ // 2) the count of nested insets changes or
+ // 3) the cursor pos is out of paragraph bound
+ if (pit() != new_word_.pit() ||
+ depth() != new_word_.depth() ||
+ new_word_.pos() > new_word_.lastpos()) {
+ clearNewWordPosition();
+ } else if (new_word_.fixIfBroken())
+ // 4) or the remembered position was "broken"
+ 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();
+}
+
+
+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();
+ if (selection())
+ anchor_.sanitize();
+ else
+ resetAnchor();
+}
+
+
+bool CursorData::isInside(Inset const * p) const
+{
+ for (size_t i = 0; i != depth(); ++i)
+ if (&operator[](i).inset() == p)
+ return true;
+ return false;
+}
+
+
+void CursorData::leaveInset(Inset const & inset)
+{
+ for (size_t i = 0; i != depth(); ++i) {
+ if (&operator[](i).inset() == &inset) {
+ resize(i);
+ return;
+ }
+ }
+}
+
+
+bool CursorData::textUndo()
+{
+ if (!buffer()->undo().textUndo(*this))
+ return false;
+ sanitize();
+ return true;
+}
+
+
+bool CursorData::textRedo()
+{
+ if (!buffer()->undo().textRedo(*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::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 * in) const
+{
+ buffer()->undo().recordUndoInset(*this, in);
+}
+
+
+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()
+{
+ 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;
+}
+
+
+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;
+}
+
+
+
+//
+// Cursor
+//
// be careful: this is called from the bv's constructor, too, so
void Cursor::reset()
{
- clear();
- push_back(CursorSlice(buffer()->inset()));
- anchor_ = doc_iterator_begin(buffer());
- anchor_.clear();
- new_word_ = doc_iterator_begin(buffer());
- new_word_.clear();
+ CursorData::reset();
clearTargetX();
- selection_ = false;
- mark_ = false;
-}
-
-
-void Cursor::setCursor(DocIterator const & cur)
-{
- DocIterator::operator=(cur);
-}
-
-
-void Cursor::setCursorSelectionTo(DocIterator dit)
-{
- size_t i = 0;
- // normalise dit
- while (i < dit.depth() && i < anchor_.depth() && dit[i] == anchor_[i])
- ++i;
- if (i != dit.depth()) {
- // otherwise the cursor is already normal
- if (i == anchor_.depth())
- // dit is a proper extension of the anchor_
- dit.cutOff(i - 1);
- else if (i + 1 < dit.depth()) {
- // one has dit[i] != anchor_[i] but either dit[i-1] == anchor_[i-1]
- // or i == 0. Remove excess.
- dit.cutOff(i);
- if (dit[i] > anchor_[i])
- // place dit after the inset it was in
- ++dit.pos();
- }
- }
- setCursor(dit);
- setSelection();
-}
-
-
-void Cursor::setCursorToAnchor()
-{
- if (selection()) {
- DocIterator normal = anchor_;
- while (depth() < normal.depth())
- normal.pop_back();
- if (depth() < anchor_.depth() && top() <= anchor_[depth() - 1])
- ++normal.pos();
- setCursor(normal);
- }
}
}
+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
{
LBUFERR(bv_);
}
-int Cursor::currentMode()
-{
- 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;
-}
-
-
-bool Cursor::inCoordCache() const
-{
- // the root inset is not in cache, but we do not need it.
- if (depth() == 1)
- return true;
- CoordCache::Insets const & icache = bv_->coordCache().getInsets();
- for (size_t i = 1 ; i < depth() ; ++i)
- if (!icache.has(&(*this)[i].inset()))
- return false;
- return true;
-}
-
-
void Cursor::getPos(int & x, int & y) const
{
Point p = bv().getPos(*this);
}
-void Cursor::resetAnchor()
-{
- anchor_ = *this;
- checkNewWordPosition();
-}
-
-
-void Cursor::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 Cursor::clearNewWordPosition()
-{
- if (!new_word_.empty()) {
- LYXERR(Debug::DEBUG, "clear new word: "
- << " par: " << pit()
- << " pos: " << pos());
- new_word_.resize(0);
- }
-}
-
-
-void Cursor::checkNewWordPosition()
-{
- if (!lyxrc.spellcheck_continuously || new_word_.empty())
- return ;
- if (!inTexted())
- clearNewWordPosition();
- else {
- // forget the position of the current new word if
- // 1) the paragraph changes or
- // 2) the count of nested insets changes or
- // 3) the cursor pos is out of paragraph bound
- if (pit() != new_word_.pit() ||
- depth() != new_word_.depth() ||
- new_word_.pos() > new_word_.lastpos()) {
- clearNewWordPosition();
- } else if (new_word_.fixIfBroken())
- // 4) or the remembered position was "broken"
- 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();
- }
- }
- }
-}
-
-
bool Cursor::posVisRight(bool skip_inset)
{
Cursor new_cur = *this; // where we will move to
return cit != row.end() && !cit->isVirtual();
}
-}
+} // namespace
void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos) const
{
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)
-{
- 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);
-
- LYXERR(Debug::RTL, "leaving extremity: " << pit() << "," << pos() << ","
- << (boundary() ? 1 : 0));
-}
-
-
-bool Cursor::reverseDirectionNeeded() const
-{
- /*
- * We determine the directions based on the direction of the
- * bottom() --- i.e., outermost --- paragraph, because that is
- * the only way to achieve consistency of the arrow's movements
- * within a paragraph, and thus avoid situations in which the
- * cursor gets stuck.
- */
- return bottom().paragraph().isRTL(bv().buffer().params());
-}
-
-
-CursorSlice Cursor::normalAnchor() const
-{
- if (!selection())
- 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;
-}
-
-
-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;
+ 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)
{
- selection(true);
- if (idx() == normalAnchor().idx() &&
- pit() == normalAnchor().pit() &&
- pos() == normalAnchor().pos())
- selection(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);
- selection(true);
- anchor_ = where;
- pos() += n;
+ LYXERR(Debug::RTL, "leaving extremity: " << pit() << "," << pos() << ","
+ << (boundary() ? 1 : 0));
}
-void Cursor::clearSelection()
+bool Cursor::reverseDirectionNeeded() const
{
- selection(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());
}
}
-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);
- }
-}
-
-
bool Cursor::selHandle(bool sel)
{
//lyxerr << "Cursor::selHandle" << endl;
selection(sel);
return true;
}
+
+
+bool Cursor::atFirstOrLastRow(bool up)
+{
+ 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;
+ }
+ return false;
+}
+
+
} // namespace lyx
namespace lyx {
-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())
}
-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);
}
-void Cursor::insert(docstring const & str)
-{
- for (char_type c : str)
- insert(c);
-}
-
-
void Cursor::insert(char_type c)
{
//lyxerr << "Cursor::insert char '" << c << "'" << endl;
}
-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(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()))
void Cursor::niceInsert(MathAtom const & t)
{
+ LATTEST(inMathed());
macroModeClose();
docstring const safe = cap::grabAndEraseSelection(*this);
plainInsert(t);
}
-void Cursor::insert(MathData const & ar)
-{
- macroModeClose();
- if (selection())
- cap::eraseSelection(*this);
- cell().insert(pos(), ar);
- pos() += ar.size();
- // FIXME audit setBuffer calls
- inset().setBuffer(bv_->buffer());
-}
-
-
bool Cursor::backspace(bool const force)
{
if (selection()) {
}
+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;
+}
+
+
+int Cursor::textTargetOffset() const
+{
+ return textTargetOffset_;
+}
+
+
+void Cursor::setTargetX()
+{
+ int x;
+ int y;
+ getPos(x, y);
+ setTargetX(x);
+}
+
+
bool Cursor::macroModeClose()
{
if (!inMacroMode())
if (in && in->interpretString(*this, s))
return true;
bool const user_macro = buffer()->getMacro(name, *this, false);
- MathAtom atom = user_macro ? MathAtom(new MathMacro(buffer(), name))
+ MathAtom atom = user_macro ? MathAtom(new InsetMathMacro(buffer(), name))
: createInsetMath(name, buffer());
// try to put argument into macro, if we just inserted a macro
bool macroArg = false;
- MathMacro * atomAsMacro = atom.nucleus()->asMacro();
+ InsetMathMacro * atomAsMacro = atom.nucleus()->asMacro();
if (atomAsMacro) {
// macros here are still unfolded (in init mode in fact). So
// we have to resolve the macro here manually and check its arity
MacroData const * data = buffer()->getMacro(atomAsMacro->name());
if (!selection.empty() && data && data->numargs() - data->optionals() > 0) {
macroArg = true;
- atomAsMacro->setDisplayMode(MathMacro::DISPLAY_INTERACTIVE_INIT, 1);
+ atomAsMacro->setDisplayMode(InsetMathMacro::DISPLAY_INTERACTIVE_INIT, 1);
} else
// non-greedy case. Do not touch the arguments behind
- atomAsMacro->setDisplayMode(MathMacro::DISPLAY_INTERACTIVE_INIT, 0);
+ atomAsMacro->setDisplayMode(InsetMathMacro::DISPLAY_INTERACTIVE_INIT, 0);
}
// insert remembered selection into first argument of a non-macro
MathWordList const & words = mathedWordList();
MathWordList::const_iterator it = words.find(name);
- bool keep_mathmode = it != words.end() && (it->second.inset == "font"
- || it->second.inset == "oldfont"
- || it->second.inset == "mbox");
+ 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
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;
-}
-
-
-int Cursor::textTargetOffset() const
-{
- return textTargetOffset_;
-}
-
-
-void Cursor::setTargetX()
-{
- int x;
- int y;
- getPos(x, y);
- setTargetX(x);
+ }
+
+ return true;
}
}
+docstring Cursor::macroName()
+{
+ return inMacroMode() ? activeMacro()->name() : docstring();
+}
+
+
void Cursor::pullArg()
{
// FIXME: Look here
}
-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()) {
}
-InsetMath & Cursor::nextMath()
-{
- return *nextAtom().nucleus();
-}
-
-
-InsetMath & Cursor::prevMath()
-{
- return *prevAtom().nucleus();
-}
-
-
bool Cursor::mathForward(bool word)
{
LASSERT(inMathed(), return false);
if (pos() < lastpos()) {
if (word) {
- // word: skip a group of insets with same math class
+ // word: skip a group of insets of the form X*(B*|R*|P*) (greedy
+ // match) where X is any math class, B is mathbin, R is mathrel, and
+ // P is mathpunct. Make sure that the following remains true:
+ // mathForward(true); mathBackward(true); mathForward(true)
+ // is the same as mathForward(true) and
+ // mathBackward(true); mathForward(true); mathBackward(true)
+ // is the same as mathBackward(true).
MathClass mc = nextMath().mathClass();
do
posForward();
while (pos() < lastpos() && mc == nextMath().mathClass());
+ if (pos() < lastpos() &&
+ ((mc = nextMath().mathClass()) == MC_BIN ||
+ mc == MC_REL || mc == MC_PUNCT))
+ do
+ posForward();
+ while (pos() < lastpos() && mc == nextMath().mathClass());
} else if (openable(nextAtom())) {
// single step: try to enter the next inset
pushBackward(nextMath());
LASSERT(inMathed(), return false);
if (pos() > 0) {
if (word) {
- // word: skip a group of insets with same math class
+ // word: skip a group of insets. See the comment in mathForward.
MathClass mc = prevMath().mathClass();
do
posBackward();
while (pos() > 0 && mc == prevMath().mathClass());
+ if (pos() > 0 && (mc == MC_BIN || mc == MC_REL || mc == MC_PUNCT)) {
+ mc = prevMath().mathClass();
+ do
+ posBackward();
+ while (pos() > 0 && mc == prevMath().mathClass());
+ }
} else if (openable(prevAtom())) {
// single step: try to enter the preceding inset
posBackward();
}
-bool Cursor::atFirstOrLastRow(bool up)
-{
- 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;
- }
- return false;
-}
-
-
bool Cursor::upDownInText(bool up, bool & updateNeeded)
{
LASSERT(text(), return false);
int yo = bv().getPos(*this).y_;
Cursor old = *this;
// To next/previous row
+ // FIXME: the y position is often guessed wrongly across styles and
+ // insets, which leads to weird behaviour.
if (up)
tm.editXY(*this, xo, yo - textRow().ascent() - 1);
else
tm.editXY(*this, xo, yo + textRow().descent() + 1);
+ x_target_ = old.x_target_;
clearSelection();
// This happens when you move out of an inset.
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);
}
}
-void Cursor::message(docstring const & msg) const
-{
- disp_.setMessage(msg);
-}
-
-
-void Cursor::errorMessage(docstring const & msg) const
-{
- disp_.setMessage(msg);
- disp_.setError(true);
-}
-
-
-namespace {
-
-docstring parbreak(Cursor const * cur)
-{
- 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 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(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;
-}
-
-
-docstring Cursor::currentState() const
-{
- if (inMathed()) {
- odocstringstream os;
- info(os);
-#ifdef DEVEL_VERSION
- InsetMath * math = inset().asInsetMath();
- if (math)
- os << _(", Inset: ") << math->id();
- os << _(", Cell: ") << idx();
- os << _(", Position: ") << pos();
-#endif
- return os.str();
- }
-
- if (inTexted())
- return text()->currentState(*this);
-
- return docstring();
-}
-
-
-docstring Cursor::getPossibleLabel() const
-{
- return inMathed() ? from_ascii("eq:") : text()->getPossibleLabel(*this);
-}
-
-
-Encoding const * Cursor::getEncoding() const
-{
- if (empty())
- return 0;
- BufferParams const & bp = bv().buffer().params();
- if (bp.useNonTeXFonts)
- return encodings.fromLyXName("utf8-plain");
-
- CursorSlice const & sl = innerTextSlice();
- Text const & text = *sl.text();
- Font font = text.getPar(sl.pit()).getFont(bp, sl.pos(),
- text.outerFont(sl.pit()));
- return font.language()->encoding();
-}
-
-
void Cursor::undispatched() const
{
disp_.dispatched(false);
}
-bool Cursor::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 Cursor::sanitize()
{
- setBuffer(&bv_->buffer());
- DocIterator::sanitize();
+ setBuffer(buffer());
+ CursorData::sanitize();
new_word_.sanitize();
- if (selection())
- anchor_.sanitize();
- else
- resetAnchor();
}
}
-bool Cursor::textUndo()
-{
- if (!buffer()->undo().textUndo(*this))
- return false;
- sanitize();
- return true;
-}
-
-
-bool Cursor::textRedo()
-{
- if (!buffer()->undo().textRedo(*this))
- return false;
- sanitize();
- return true;
-}
-
-
-void Cursor::finishUndo() const
-{
- buffer()->undo().finishUndo();
-}
-
-
-void Cursor::beginUndoGroup() const
-{
- buffer()->undo().beginUndoGroup(*this);
-}
-
-
-void Cursor::endUndoGroup() const
-{
- buffer()->undo().endUndoGroup(*this);
-}
-
-
-void Cursor::recordUndo(pit_type from, pit_type to) const
-{
- buffer()->undo().recordUndo(*this, from, to);
-}
-
-
-void Cursor::recordUndo(pit_type from) const
-{
- buffer()->undo().recordUndo(*this, from, pit());
-}
-
-
-void Cursor::recordUndo(UndoKind kind) const
-{
- buffer()->undo().recordUndo(*this, kind);
-}
-
-
-void Cursor::recordUndoInset(Inset const * in) const
-{
- buffer()->undo().recordUndoInset(*this, in);
-}
-
-
-void Cursor::recordUndoFullBuffer() const
-{
- buffer()->undo().recordUndoFullBuffer(*this);
-}
-
-
-void Cursor::recordUndoBufferParams() const
-{
- buffer()->undo().recordUndoBufferParams(*this);
-}
-
-
-void Cursor::recordUndoSelection() const
-{
- if (inMathed()) {
- if (cap::multipleCellsSelected(*this))
- recordUndoInset();
- else
- recordUndo();
- } else {
- buffer()->undo().recordUndo(*this,
- selBegin().pit(), selEnd().pit());
- }
-}
-
-
void Cursor::checkBufferStructure()
{
Buffer const * master = buffer()->masterBuffer();
}
-bool Cursor::confirmDeletion(bool const before) const
-{
- if (!selection()) {
- if (Inset const * inset = before ? prevInset() : nextInset())
- return inset->confirmDeletion();
- } else {
- DocIterator dit = selectionBegin();
- DocIterator const sel_end = selectionEnd();
- for (; dit < sel_end; dit.posForward())
- if (Inset const * inset = dit.nextInset())
- if (inset->confirmDeletion())
- return true;
- }
- return false;
-}
-
-
void Cursor::moveToClosestEdge(int const x, bool const edit)
{
if (Inset const * inset = nextInset()) {
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)