X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FCursor.cpp;h=dc381479e6dbd94ff17dfd7dc459e7f6793b8c31;hb=a128c373f9e3563a52405a485d9a672e210208b0;hp=b13b6a56f7f497e973e237770159cecfa834e94d;hpb=3fd2398a28c8d2c85d1bb2c33c6ca15bfc398b54;p=lyx.git

diff --git a/src/Cursor.cpp b/src/Cursor.cpp
index b13b6a56f7..dc381479e6 100644
--- a/src/Cursor.cpp
+++ b/src/Cursor.cpp
@@ -15,12 +15,12 @@
 #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"
@@ -52,7 +52,7 @@
 #include "mathed/MacroTable.h"
 #include "mathed/MathData.h"
 #include "mathed/MathFactory.h"
-#include "mathed/MathMacro.h"
+#include "mathed/InsetMathMacro.h"
 
 #include <sstream>
 #include <limits>
@@ -114,7 +114,7 @@ DocIterator bruteFind(Cursor const & c, int x, int y)
 }
 
 
-} // namespace anon
+} // namespace
 
 
 CursorData::CursorData()
@@ -194,13 +194,37 @@ void Cursor::reset()
 }
 
 
-// this (intentionally) does neither touch anchor nor selection status
 void Cursor::setCursor(DocIterator const & cur)
 {
 	DocIterator::operator=(cur);
 }
 
 
+void Cursor::setCursorSelectionTo(DocIterator dit)
+{
+	size_t i = 0;
+	// normalise dit
+	while (i < dit.depth() && i < anchor_.depth() && dit[i] == anchor_[i])
+		++i;
+	if (i != dit.depth()) {
+		// otherwise the cursor is already normal
+		if (i == anchor_.depth())
+			// dit is a proper extension of the anchor_
+			dit.cutOff(i - 1);
+		else if (i + 1 < dit.depth()) {
+			// one has dit[i] != anchor_[i] but either dit[i-1] == anchor_[i-1]
+			// or i == 0. Remove excess.
+			dit.cutOff(i);
+			if (dit[i] > anchor_[i])
+				// place dit after the inset it was in
+				++dit.pos();
+		}
+	}
+	setCursor(dit);
+	setSelection();
+}
+
+
 void Cursor::setCursorToAnchor()
 {
 	if (selection()) {
@@ -429,19 +453,6 @@ int Cursor::currentMode()
 }
 
 
-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);
@@ -526,24 +537,6 @@ void Cursor::checkNewWordPosition()
 }
 
 
-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
@@ -751,7 +744,7 @@ bool findNonVirtual(Row const & row, Row::const_iterator & cit, bool onleft)
 	return cit != row.end() && !cit->isVirtual();
 }
 
-}
+} // namespace
 
 void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos) const
 {
@@ -760,12 +753,11 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos) const
 	right_pos = -1;
 
 	Row const & row = textRow();
-	TextMetrics const & tm = bv_->textMetrics(text());
 	double dummy = 0;
-	Row::const_iterator cit = tm.findRowElement(row, pos(), boundary(), dummy);
+	Row::const_iterator cit = row.findElement(pos(), boundary(), dummy);
 	// Handle the case of empty row
 	if (cit == row.end()) {
-		if (paragraph().isRTL(buffer()->params()))
+		if (row.isRTL())
 			right_pos = row.pos();
 		else
 			left_pos = row.pos() - 1;
@@ -839,10 +831,8 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos) const
 
 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.
@@ -1024,6 +1014,56 @@ void Cursor::clearSelection()
 }
 
 
+int Cursor::countInsetsInSelection(InsetCode const & inset_code)
+{
+	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 Cursor::insetInSelection(InsetCode const & inset_code)
+{
+	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;
+}
+
+
 void Cursor::setTargetX(int x)
 {
 	x_target_ = x;
@@ -1053,7 +1093,7 @@ void Cursor::updateTextTargetOffset()
 }
 
 
-void Cursor::info(odocstream & os) const
+void Cursor::info(odocstream & os, bool devel_mode) const
 {
 	for (int i = 1, n = depth(); i < n; ++i) {
 		operator[](i).inset().infoize(os);
@@ -1065,6 +1105,14 @@ void Cursor::info(odocstream & os) const
 		if (inset)
 			prevInset()->infoize2(os);
 	}
+	if (devel_mode) {
+		InsetMath * math = inset().asInsetMath();
+		if (math)
+			os << _(", Inset: ") << math->id();
+		os << _(", Cell: ") << idx();
+		os << _(", Position: ") << pos();
+	}
+
 }
 
 
@@ -1279,7 +1327,7 @@ void Cursor::insert(MathData const & ar)
 }
 
 
-bool Cursor::backspace()
+bool Cursor::backspace(bool const force)
 {
 	if (selection()) {
 		cap::eraseSelection(*this);
@@ -1315,7 +1363,7 @@ 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();
@@ -1329,7 +1377,7 @@ bool Cursor::backspace()
 }
 
 
-bool Cursor::erase()
+bool Cursor::erase(bool const force)
 {
 	if (inMacroMode())
 		return true;
@@ -1364,7 +1412,7 @@ 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();
 		selection(true);
 		++pos();
@@ -1402,7 +1450,7 @@ bool Cursor::down()
 }
 
 
-bool Cursor::macroModeClose()
+bool Cursor::macroModeClose(bool cancel)
 {
 	if (!inMacroMode())
 		return false;
@@ -1414,36 +1462,37 @@ 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
 	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;
 	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
 		// to put the selection behind it if arity > 0.
 		MacroData const * data = buffer()->getMacro(atomAsMacro->name());
-		if (!selection.empty() && 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);
+			atomAsMacro->setDisplayMode(InsetMathMacro::DISPLAY_INTERACTIVE_INIT, 0);
 	}
 
 	// insert remembered selection into first argument of a non-macro
@@ -1452,10 +1501,11 @@ bool Cursor::macroModeClose()
 
 	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 ert_macro = !user_macro && it == words.end();
+	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
@@ -1717,6 +1767,95 @@ bool Cursor::upDownInMath(bool up)
 }
 
 
+InsetMath & Cursor::nextMath()
+{
+	return *nextAtom().nucleus();
+}
+
+
+InsetMath & Cursor::prevMath()
+{
+	return *prevAtom().nucleus();
+}
+
+
+bool Cursor::mathForward(bool word)
+{
+	LASSERT(inMathed(), return false);
+	if (pos() < lastpos()) {
+		if (word) {
+			// word: skip a group of insets of the form X*(B*|R*|P*) (greedy
+			// match) where X is any math class, B is mathbin, R is mathrel, and
+			// P is mathpunct. Make sure that the following remains true:
+			//   mathForward(true); mathBackward(true); mathForward(true)
+			// is the same as mathForward(true) and
+			//   mathBackward(true); mathForward(true); mathBackward(true)
+			// is the same as mathBackward(true).
+			MathClass mc = nextMath().mathClass();
+			do
+				posForward();
+			while (pos() < lastpos() && mc == nextMath().mathClass());
+			if (pos() < lastpos() &&
+			    ((mc = nextMath().mathClass()) == MC_BIN ||
+			     mc == MC_REL || mc == MC_PUNCT))
+				do
+					posForward();
+				while (pos() < lastpos() && mc == nextMath().mathClass());
+		} else if (openable(nextAtom())) {
+			// single step: try to enter the next inset
+			pushBackward(nextMath());
+			inset().idxFirst(*this);
+		} else
+			posForward();
+		return true;
+	}
+	if (inset().idxForward(*this))
+		return true;
+	// try to pop forwards --- but don't pop out of math! leave that to
+	// the FINISH lfuns
+	int s = depth() - 2;
+	if (s >= 0 && operator[](s).inset().asInsetMath())
+		return popForward();
+	return false;
+}
+
+
+bool Cursor::mathBackward(bool word)
+{
+	LASSERT(inMathed(), return false);
+	if (pos() > 0) {
+		if (word) {
+			// word: skip a group of insets. See the comment in mathForward.
+			MathClass mc = prevMath().mathClass();
+			do
+				posBackward();
+			while (pos() > 0 && mc == prevMath().mathClass());
+			if (pos() > 0 && (mc == MC_BIN || mc == MC_REL || mc == MC_PUNCT)) {
+				mc = prevMath().mathClass();
+				do
+					posBackward();
+				while (pos() > 0 && mc == prevMath().mathClass());
+			}
+		} else if (openable(prevAtom())) {
+			// single step: try to enter the preceding inset
+			posBackward();
+			push(nextMath());
+			inset().idxLast(*this);
+		} else
+			posBackward();
+		return true;
+	}
+	if (inset().idxBackward(*this))
+		return true;
+	// try to pop backwards --- but don't pop out of math! leave that to
+	// the FINISH lfuns
+	int s = depth() - 2;
+	if (s >= 0 && operator[](s).inset().asInsetMath())
+		return popBackward();
+	return false;
+}
+
+
 bool Cursor::atFirstOrLastRow(bool up)
 {
 	TextMetrics const & tm = bv_->textMetrics(text());
@@ -1831,10 +1970,13 @@ bool Cursor::upDownInText(bool up, bool & updateNeeded)
 		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.
@@ -1883,6 +2025,8 @@ bool Cursor::upDownInText(bool up, bool & updateNeeded)
 		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);
 	}
@@ -1958,7 +2102,7 @@ docstring parbreak(Cursor const * cur)
 	return os.str();
 }
 
-}
+} // namespace
 
 
 docstring Cursor::selectionAsString(bool with_label) const
@@ -2010,23 +2154,16 @@ docstring Cursor::selectionAsString(bool with_label) const
 }
 
 
-docstring Cursor::currentState() const
+docstring Cursor::currentState(bool devel_mode) 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
+		info(os, devel_mode);
 		return os.str();
 	}
 
 	if (inTexted())
-		return text()->currentState(*this);
+		return text()->currentState(*this, devel_mode);
 
 	return docstring();
 }
@@ -2038,18 +2175,6 @@ docstring Cursor::getPossibleLabel() const
 }
 
 
-Encoding const * Cursor::getEncoding() const
-{
-	if (empty())
-		return 0;
-	CursorSlice const & sl = innerTextSlice();
-	Text const & text = *sl.text();
-	Font font = text.getPar(sl.pit()).getFont(
-		bv().buffer().params(), sl.pos(), text.outerFont(sl.pit()));
-	return font.language()->encoding();
-}
-
-
 void Cursor::undispatched() const
 {
 	disp_.dispatched(false);
@@ -2097,6 +2222,7 @@ 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.
+	// FIXME: this is not the case, what about removing this method ? (see #10478).
 
 	// HACK. far from being perfect...
 
@@ -2144,6 +2270,7 @@ void Cursor::sanitize()
 {
 	setBuffer(&bv_->buffer());
 	DocIterator::sanitize();
+	new_word_.sanitize();
 	if (selection())
 		anchor_.sanitize();
 	else
@@ -2337,4 +2464,39 @@ void Cursor::checkBufferStructure()
 }
 
 
+bool Cursor::confirmDeletion(bool const before) const
+{
+	if (!selection()) {
+		if (Inset const * inset = before ? prevInset() : nextInset())
+			return inset->confirmDeletion();
+	} else {
+		DocIterator dit = selectionBegin();
+		CursorSlice const end = selectionEnd().top();
+		for (; dit.top() < end; dit.top().forwardPos())
+			if (Inset const * inset = dit.nextInset())
+				if (inset->confirmDeletion())
+					return true;
+	}
+	return false;
+}
+
+
+void Cursor::moveToClosestEdge(int const x, bool const edit)
+{
+	if (Inset const * inset = nextInset()) {
+		// stay in front of insets for which we want to open the dialog
+		// (e.g. InsetMathSpace).
+		if (edit && (inset->hasSettings() || !inset->contextMenuName().empty()))
+			return;
+		CoordCache::Insets const & insetCache = bv().coordCache().getInsets();
+		if (!insetCache.has(inset))
+			return;
+		int const wid = insetCache.dim(inset).wid;
+		Point p = insetCache.xy(inset);
+		if (x > p.x_ + (wid + 1) / 2)
+			posForward();
+	}
+}
+
+
 } // namespace lyx