X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2FCursor.cpp;h=0e1c3ded5558c9dd62283ad29d738fc1c15e552d;hb=26ba2a65838731ce639a09539f617cb0f0be3b22;hp=f3fccfa98e4803afff5f247413a70d92f2ecc3ac;hpb=503c7c1688bee80a2c5dc472aaf97fb2aa0391e0;p=lyx.git

diff --git a/src/Cursor.cpp b/src/Cursor.cpp
index f3fccfa98e..0e1c3ded55 100644
--- a/src/Cursor.cpp
+++ b/src/Cursor.cpp
@@ -14,19 +14,19 @@
 
 #include <config.h>
 
+#include "Cursor.h"
+
 #include "Buffer.h"
 #include "BufferView.h"
 #include "CoordCache.h"
-#include "Cursor.h"
 #include "CutAndPaste.h"
-#include "DispatchResult.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"
@@ -35,12 +35,11 @@
 
 #include "support/debug.h"
 #include "support/docstream.h"
-#include "support/ExceptionMessage.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"
@@ -51,6 +50,8 @@
 #include "mathed/MathFactory.h"
 #include "mathed/InsetMathMacro.h"
 
+#include "frontends/Application.h"
+
 #include <sstream>
 #include <limits>
 #include <map>
@@ -121,19 +122,19 @@ DocIterator bruteFind(Cursor const & c, int x, int y)
 
 CursorData::CursorData()
 	: DocIterator(), anchor_(), selection_(false), mark_(false),
-	  word_selection_(false), autocorrect_(false), current_font(inherit_font)
+	  word_selection_(false), current_font(inherit_font)
 {}
 
 
 CursorData::CursorData(Buffer * buffer)
 	: DocIterator(buffer), anchor_(), selection_(false), mark_(false),
-	  word_selection_(false), autocorrect_(false), current_font(inherit_font)
+	  word_selection_(false), current_font(inherit_font)
 {}
 
 
 CursorData::CursorData(DocIterator const & dit)
 	: DocIterator(dit), anchor_(), selection_(false), mark_(false),
-	  word_selection_(false), autocorrect_(false), current_font(inherit_font)
+	  word_selection_(false), current_font(inherit_font)
 {}
 
 
@@ -321,6 +322,7 @@ DocIterator CursorData::selectionEnd() const
 	if (di.depth() > depth()) {
 		di.resize(depth());
 		++di.pos();
+		di.boundary(true);
 	}
 	return di;
 }
@@ -330,6 +332,8 @@ 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
@@ -342,7 +346,7 @@ docstring parbreak(CursorData const * cur)
 }
 
 
-docstring CursorData::selectionAsString(bool with_label) const
+docstring CursorData::selectionAsString(bool const with_label, bool const skipdelete) const
 {
 	if (!selection())
 		return docstring();
@@ -350,8 +354,12 @@ docstring CursorData::selectionAsString(bool with_label) const
 	if (inMathed())
 		return cap::grabSelection(*this);
 
-	int const label = with_label
+	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();
@@ -496,6 +504,56 @@ void CursorData::clearSelection()
 }
 
 
+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();
@@ -521,38 +579,18 @@ void CursorData::sanitize()
 }
 
 
-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()
+bool CursorData::undoAction()
 {
-	if (!buffer()->undo().textUndo(*this))
+	if (!buffer()->undo().undoAction(*this))
 		return false;
 	sanitize();
 	return true;
 }
 
 
-bool CursorData::textRedo()
+bool CursorData::redoAction()
 {
-	if (!buffer()->undo().textRedo(*this))
+	if (!buffer()->undo().redoAction(*this))
 		return false;
 	sanitize();
 	return true;
@@ -577,6 +615,12 @@ void CursorData::endUndoGroup() const
 }
 
 
+void CursorData::splitUndoGroup() const
+{
+	buffer()->undo().splitUndoGroup(*this);
+}
+
+
 void CursorData::recordUndo(pit_type from, pit_type to) const
 {
 	buffer()->undo().recordUndo(*this, from, to);
@@ -595,9 +639,9 @@ void CursorData::recordUndo(UndoKind kind) const
 }
 
 
-void CursorData::recordUndoInset(Inset const * in) const
+void CursorData::recordUndoInset(Inset const * inset) const
 {
-	buffer()->undo().recordUndoInset(*this, in);
+	buffer()->undo().recordUndoInset(*this, inset);
 }
 
 
@@ -627,7 +671,7 @@ void CursorData::recordUndoSelection() const
 }
 
 
-int CursorData::currentMode()
+int CursorData::currentMode() const
 {
 	LASSERT(!empty(), return Inset::UNDECIDED_MODE);
 	for (int i = depth() - 1; i >= 0; --i) {
@@ -670,6 +714,7 @@ bool CursorData::confirmDeletion(bool const before) const
 Cursor::Cursor(BufferView & bv)
 	: CursorData(&bv.buffer()), bv_(&bv),
 	  x_target_(-1), textTargetOffset_(0),
+	  x_clickpos_(-1), y_clickpos_(-1),
 	  beforeDispatchPosX_(0), beforeDispatchPosY_(0)
 {}
 
@@ -745,15 +790,15 @@ void Cursor::dispatch(FuncRequest const & cmd0)
 
 	beginUndoGroup();
 
+	Inset * nextins = nextInset();
 	// Is this a function that acts on inset at point?
-	if (lyxaction.funcHasFlag(cmd.action(), LyXAction::AtPoint)
-	    && nextInset()) {
+	if (lyxaction.funcHasFlag(cmd.action(), LyXAction::AtPoint) && nextins) {
 		disp_.dispatched(true);
 		disp_.screenUpdate(Update::FitCursor | Update::Force);
 		FuncRequest tmpcmd = cmd;
-		LYXERR(Debug::DEBUG, "Cursor::dispatch: (AtPoint) cmd: "
+		LYXERR(Debug::ACTION, "Cursor::dispatch: (AtPoint) cmd: "
 			<< cmd0 << endl << *this);
-		nextInset()->dispatch(*this, tmpcmd);
+		nextins->dispatch(*this, tmpcmd);
 		if (disp_.dispatched()) {
 			endUndoGroup();
 			return;
@@ -763,7 +808,7 @@ void Cursor::dispatch(FuncRequest const & cmd0)
 	// store some values to be used inside of the handlers
 	beforeDispatchCursor_ = *this;
 	for (; depth(); pop(), boundary(false)) {
-		LYXERR(Debug::DEBUG, "Cursor::dispatch: cmd: "
+		LYXERR(Debug::ACTION, "Cursor::dispatch: cmd: "
 			<< cmd0 << endl << *this);
 
 		// In any of these cases, the cursor is invalid, and we should
@@ -785,7 +830,7 @@ void Cursor::dispatch(FuncRequest const & cmd0)
 	// it completely to get a 'bomb early' behaviour in case this
 	// object will be used again.
 	if (!disp_.dispatched()) {
-		LYXERR(Debug::DEBUG, "RESTORING OLD CURSOR!");
+		LYXERR(Debug::ACTION, "RESTORING OLD CURSOR!");
 		// 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
@@ -855,19 +900,44 @@ void Cursor::pop()
 }
 
 
-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();
+	}
 }
 
 
@@ -1312,19 +1382,26 @@ void Cursor::updateTextTargetOffset()
 }
 
 
-bool Cursor::selHandle(bool sel)
+void Cursor::setClickPos(int x, int y)
+{
+	x_clickpos_ = x;
+	y_clickpos_ = y;
+}
+
+
+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();
-	selection(sel);
+	selection(selecting);
 	return true;
 }
 
@@ -1365,10 +1442,7 @@ bool Cursor::atFirstOrLastRow(bool up)
 ///////////////////////////////////////////////////////////////////
 
 #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"
 
@@ -1491,14 +1565,11 @@ void Cursor::niceInsert(MathAtom const & t)
 	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);
@@ -1532,9 +1603,20 @@ bool Cursor::backspace(bool const force)
 			// [|], 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;
 		}
@@ -1635,20 +1717,17 @@ bool Cursor::down()
 }
 
 
-void Cursor::handleNest(MathAtom const & a, int c)
+void Cursor::handleNest(MathAtom const & a)
 {
-	//lyxerr << "Cursor::handleNest: " << c << endl;
+	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(c));
+	asArray(cap::grabAndEraseSelection(*this), t.nucleus()->cell(idx), f);
 	insert(t);
-	posBackward();
-	pushBackward(*nextInset());
-}
-
-
-void Cursor::handleNest(MathAtom const & a)
-{
-	handleNest(a, a.nucleus()->asNestInset()->firstIdx());
+	editInsertedInset();
 }
 
 
@@ -1690,14 +1769,15 @@ bool Cursor::macroModeClose(bool cancel)
 	--pos();
 	cell().erase(pos());
 
-	// do nothing if the macro name is empty
-	if (s == "\\" || cancel)
-		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))
@@ -1715,7 +1795,7 @@ bool Cursor::macroModeClose(bool cancel)
 		// 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(InsetMathMacro::DISPLAY_INTERACTIVE_INIT, 1);
 		} else
@@ -1732,6 +1812,7 @@ bool Cursor::macroModeClose(bool cancel)
 	bool keep_mathmode = user_macro
 		|| (it != words.end() && (it->second.inset == "font"
 		                          || it->second.inset == "oldfont"
+		                          || it->second.inset == "textsize"
 		                          || it->second.inset == "mbox"));
 	bool ert_macro = !user_macro && it == words.end() && atomAsMacro;
 
@@ -1777,13 +1858,13 @@ 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;
 }
 
 
@@ -1801,8 +1882,6 @@ void Cursor::pullArg()
 		plainErase();
 		cell().insert(pos(), ar);
 		resetAnchor();
-	} else {
-		//formula()->mutateToText();
 	}
 }
 
@@ -1822,7 +1901,7 @@ void Cursor::normalize()
 		       << " in atom: '";
 		odocstringstream os;
 		otexrowstream ots(os);
-		WriteStream wi(ots, false, true, WriteStream::wsDefault);
+		TeXMathStream wi(ots, false, true, TeXMathStream::wsDefault);
 		inset().asInsetMath()->write(wi);
 		lyxerr << to_utf8(os.str()) << endl;
 		pos() = lastpos();
@@ -1926,6 +2005,8 @@ bool Cursor::upDownInMath(bool up)
 		// try to find best position within this inset
 		if (!selection())
 			setCursor(bruteFind(*this, xo, yo));
+		// FIXME : this is actually only needed for InsetMathMacro (bug #12952).
+		screenUpdateFlags(Update::SinglePar);
 		return true;
 	}
 
@@ -1969,20 +2050,39 @@ bool Cursor::mathForward(bool word)
 					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())
-		return popForward();
+	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;
 }
 
@@ -2004,21 +2104,41 @@ bool Cursor::mathBackward(bool word)
 				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())
-		return popBackward();
+	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;
 }
 
@@ -2238,6 +2358,12 @@ void Cursor::screenUpdateFlags(Update::flags f) const
 }
 
 
+void Cursor::noScreenUpdate() const
+{
+	disp_.screenUpdate(Update::None);
+}
+
+
 void Cursor::forceBufferUpdate() const
 {
 	disp_.forceBufferUpdate();
@@ -2256,12 +2382,6 @@ bool Cursor::needBufferUpdate() const
 }
 
 
-void Cursor::noScreenUpdate() const
-{
-	disp_.screenUpdate(Update::None);
-}
-
-
 Font Cursor::getFont() const
 {
 	// The logic here should more or less match to the
@@ -2341,6 +2461,22 @@ bool notifyCursorLeavesOrEnters(Cursor const & old, Cursor & cur)
 }
 
 
+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();
@@ -2374,6 +2510,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())
@@ -2384,23 +2523,26 @@ void Cursor::setCurrentFont()
 		real_current_font.setLanguage(lang);
 		real_current_font.fontInfo().setNumber(FONT_OFF);
 	}
+
+	// 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,
 		// the TocItem is not updated (part of bug 5699).
 		buffer()->tocBackend().updateItem(*this);
-
-	// If the last tracked change of the paragraph has just been
-	// deleted, then we need to recompute the buffer flag
-	// tracked_changes_present_.
-	if (inTexted() && paragraph().isChangeUpdateRequired())
-		disp_.forceChangesUpdate();
 }