X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FText3.cpp;h=3e6fdf0e14e62634173830b242372aa160a48a51;hb=425c190d623daeb6d05bce1aa2244b548225305a;hp=eb8f7a0cc291da2d331a51cb00979fc32fc8be00;hpb=d16a95afe7e800356150256439cc07c1c57f06f3;p=lyx.git

diff --git a/src/Text3.cpp b/src/Text3.cpp
index eb8f7a0cc2..3e6fdf0e14 100644
--- a/src/Text3.cpp
+++ b/src/Text3.cpp
@@ -90,13 +90,16 @@ namespace lyx {
 
 using cap::copySelection;
 using cap::cutSelection;
+using cap::cutSelectionToTemp;
 using cap::pasteFromStack;
+using cap::pasteFromTemp;
 using cap::pasteClipboardText;
 using cap::pasteClipboardGraphics;
 using cap::replaceSelection;
 using cap::grabAndEraseSelection;
 using cap::selClearOrDel;
 using cap::pasteSimpleText;
+using frontend::Clipboard;
 
 // globals...
 static Font freefont(ignore_font, ignore_language);
@@ -132,7 +135,7 @@ static void finishChange(Cursor & cur, bool selecting)
 }
 
 
-static void mathDispatch(Cursor & cur, FuncRequest const & cmd, bool display)
+static void mathDispatch(Cursor & cur, FuncRequest const & cmd)
 {
 	cur.recordUndo();
 	docstring sel = cur.selectionAsString(false);
@@ -152,45 +155,39 @@ static void mathDispatch(Cursor & cur, FuncRequest const & cmd, bool display)
 		LATTEST(old_pos == cur.pos());
 #endif
 		cur.nextInset()->edit(cur, true);
-		// don't do that also for LFUN_MATH_MODE
-		// unless you want end up with always changing
-		// to mathrm when opening an inlined inset --
-		// I really hate "LyXfunc overloading"...
-		if (display)
-			cur.dispatch(FuncRequest(LFUN_MATH_DISPLAY));
-		// Avoid an unnecessary undo step if cmd.argument
-		// is empty
-		if (!cmd.argument().empty())
-			cur.dispatch(FuncRequest(LFUN_MATH_INSERT,
-						 cmd.argument()));
+		if (cmd.action() != LFUN_MATH_MODE)
+			// LFUN_MATH_MODE has a different meaning in math mode
+			cur.dispatch(cmd);
 	} else {
-		// create a macro if we see "\\newcommand"
-		// somewhere, and an ordinary formula
-		// otherwise
-		if (sel.find(from_ascii("\\newcommand")) == string::npos
-				&& sel.find(from_ascii("\\newlyxcommand")) == string::npos
-				&& sel.find(from_ascii("\\def")) == string::npos)
-		{
-			InsetMathHull * formula = new InsetMathHull(cur.buffer());
-			string const selstr = to_utf8(sel);
-			istringstream is(selstr);
-			Lexer lex;
+		InsetMathHull * formula = new InsetMathHull(cur.buffer());
+		string const selstr = to_utf8(sel);
+		istringstream is(selstr);
+		Lexer lex;
+		lex.setStream(is);
+		if (!formula->readQuiet(lex)) {
+			// No valid formula, let's try with delims
+			is.str("$" + selstr + "$");
 			lex.setStream(is);
 			if (!formula->readQuiet(lex)) {
-				// No valid formula, let's try with delims
-				is.str("$" + selstr + "$");
-				lex.setStream(is);
-				if (!formula->readQuiet(lex)) {
-					// Still not valid, leave it as is
-					valid = false;
-					delete formula;
-					cur.insert(sel);
-				} else
-					cur.insert(formula);
-			} else
-				cur.insert(formula);
-		} else {
-			cur.insert(new MathMacroTemplate(cur.buffer(), sel));
+				// Still not valid, leave it as is
+				valid = false;
+				delete formula;
+				cur.insert(sel);
+			}
+		}
+		if (valid) {
+			cur.insert(formula);
+			cur.nextInset()->edit(cur, true);
+			LASSERT(cur.inMathed(), return);
+			cur.pos() = 0;
+			cur.resetAnchor();
+			cur.selection(true);
+			cur.pos() = cur.lastpos();
+			if (cmd.action() != LFUN_MATH_MODE)
+				// LFUN_MATH_MODE has a different meaning in math mode
+				cur.dispatch(cmd);
+			cur.clearSelection();
+			cur.pos() = cur.lastpos();
 		}
 	}
 	if (valid)
@@ -304,7 +301,7 @@ static bool doInsertInset(Cursor & cur, Text * text,
 
 	bool gotsel = false;
 	if (cur.selection()) {
-		cutSelection(cur, false, pastesel);
+		cutSelectionToTemp(cur, false, pastesel);
 		cur.clearSelection();
 		gotsel = true;
 	}
@@ -316,7 +313,7 @@ static bool doInsertInset(Cursor & cur, Text * text,
 	if (!gotsel || !pastesel)
 		return true;
 
-	pasteFromStack(cur, cur.buffer()->errorList("Paste"), 0);
+	pasteFromTemp(cur, cur.buffer()->errorList("Paste"));
 	cur.buffer()->errors("Paste");
 	cur.clearSelection(); // bug 393
 	cur.finishUndo();
@@ -376,7 +373,7 @@ static void outline(OutlineOp mode, Cursor & cur)
 	ParagraphList & pars = buf.text().paragraphs();
 	ParagraphList::iterator const bgn = pars.begin();
 	// The first paragraph of the area to be copied:
-	ParagraphList::iterator start = next(bgn, pit);
+	ParagraphList::iterator start = lyx::next(bgn, pit);
 	// The final paragraph of area to be copied:
 	ParagraphList::iterator finish = start;
 	ParagraphList::iterator const end = pars.end();
@@ -814,7 +811,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		ParagraphList & pars = buf.text().paragraphs();
 		ParagraphList::iterator bgn = pars.begin();
 		// The first paragraph of the area to be selected:
-		ParagraphList::iterator start = next(bgn, pit);
+		ParagraphList::iterator start = lyx::next(bgn, pit);
 		// The final paragraph of area to be selected:
 		ParagraphList::iterator finish = start;
 		ParagraphList::iterator end = pars.end();
@@ -1054,22 +1051,11 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
 	case LFUN_CHAR_DELETE_FORWARD:
 		if (!cur.selection()) {
-			bool was_separator = cur.paragraph().isEnvSeparator(cur.pos());
 			if (cur.pos() == cur.paragraph().size())
 				// Par boundary, force full-screen update
 				singleParUpdate = false;
 			needsUpdate |= erase(cur);
 			cur.resetAnchor();
-			if (was_separator && cur.pos() == cur.paragraph().size()
-			    && (!cur.paragraph().layout().isEnvironment()
-				|| cur.paragraph().size() > 0)) {
-				// Force full-screen update
-				singleParUpdate = false;
-				needsUpdate |= erase(cur);
-				cur.resetAnchor();
-			}
-			// It is possible to make it a lot faster still
-			// just comment out the line below...
 		} else {
 			cutSelection(cur, true, false);
 			singleParUpdate = false;
@@ -1103,33 +1089,32 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		cap::replaceSelection(cur);
 		pit_type pit = cur.pit();
 		Paragraph const & par = pars_[pit];
-		pit_type prev = pit;
-		if (pit > 0) {
-			if (!pars_[pit - 1].layout().isEnvironment())
-				prev = depthHook(pit, par.getDepth());
-			else if (pars_[pit - 1].getDepth() >= par.getDepth())
-				prev = pit - 1;
-		}
+		bool lastpar = (pit == pit_type(pars_.size() - 1));
+		Paragraph const & nextpar = lastpar ? par : pars_[pit + 1];
+		pit_type prev = pit > 0 ? depthHook(pit, par.getDepth()) : pit;
 		if (prev < pit && cur.pos() == par.beginOfBody()
-		    && !par.isEnvSeparator(cur.pos())
+		    && !par.size() && !par.isEnvSeparator(cur.pos())
 		    && !par.layout().isCommand()
 		    && pars_[prev].layout() != par.layout()
-		    && pars_[prev].layout().isEnvironment()) {
+		    && pars_[prev].layout().isEnvironment()
+		    && !nextpar.isEnvSeparator(nextpar.beginOfBody())) {
 			if (par.layout().isEnvironment()
 			    && pars_[prev].getDepth() == par.getDepth()) {
 				docstring const layout = par.layout().name();
 				DocumentClass const & tc = bv->buffer().params().documentClass();
 				lyx::dispatch(FuncRequest(LFUN_LAYOUT, tc.plainLayout().name()));
-				lyx::dispatch(FuncRequest(LFUN_SEPARATOR_INSERT, "parbreak"));
+				lyx::dispatch(FuncRequest(LFUN_SEPARATOR_INSERT, "plain"));
 				lyx::dispatch(FuncRequest(LFUN_PARAGRAPH_BREAK, "inverse"));
 				lyx::dispatch(FuncRequest(LFUN_LAYOUT, layout));
 			} else {
-				lyx::dispatch(FuncRequest(LFUN_SEPARATOR_INSERT, "parbreak"));
+				lyx::dispatch(FuncRequest(LFUN_SEPARATOR_INSERT, "plain"));
 				breakParagraph(cur);
 			}
 			Font const f(inherit_font, cur.current_font.language());
 			pars_[cur.pit() - 1].resetFonts(f);
 		} else {
+			if (par.isEnvSeparator(cur.pos()))
+				cur.posForward();
 			breakParagraph(cur, cmd.argument() == "inverse");
 		}
 		cur.resetAnchor();
@@ -1563,26 +1548,44 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		while (pos > 0 && par.isDeleted(pos - 1))
 			--pos;
 
-		BufferParams const & bufparams = bv->buffer().params();
-		bool const hebrew =
-			par.getFontSettings(bufparams, pos).language()->lang() == "hebrew";
-		bool const allow_inset_quote = !(par.isPassThru() || hebrew);
-
-		string const arg = to_utf8(cmd.argument());
-		if (allow_inset_quote) {
-			char_type c = ' ';
-			if (pos > 0 && (!cur.prevInset() || !cur.prevInset()->isSpace()))
+		bool const inner = (cmd.getArg(0) == "single" || cmd.getArg(0) == "inner");
+
+		// Guess quote side.
+		// A space triggers an opening quote. This is passed if the preceding
+		// char/inset is a space or at paragraph start.
+		char_type c = ' ';
+		if (pos > 0 && !par.isSpace(pos - 1)) {
+			if (cur.prevInset() && cur.prevInset()->lyxCode() == QUOTE_CODE) {
+				// If an opening double quotation mark precedes, and this
+				// is a single quote, make it opening as well
+				InsetQuotes & ins =
+					static_cast<InsetQuotes &>(*cur.prevInset());
+				string const type = ins.getType();
+				if (!suffixIs(type, "ld") || !inner)
+					c = par.getChar(pos - 1);
+			}
+			else if (!cur.prevInset()
+			    || (cur.prevInset() && cur.prevInset()->isChar()))
+				// If a char precedes, pass that and let InsetQuote decide
 				c = par.getChar(pos - 1);
-			InsetQuotes::QuoteTimes const quote_type = (arg == "single")
-				? InsetQuotes::SingleQuotes : InsetQuotes::DoubleQuotes;
-			cur.insert(new InsetQuotes(cur.buffer(), c, quote_type));
-			cur.posForward();
-		} else {
-			// The cursor might have been invalidated by the replaceSelection.
-			cur.buffer()->changed(true);
-			string const quote_string = (arg == "single") ? "'" : "\"";
-			lyx::dispatch(FuncRequest(LFUN_SELF_INSERT, quote_string));
+			else {
+				while (pos > 0) {
+					if (par.getInset(pos - 1)
+					    && !par.getInset(pos - 1)->isPartOfTextSequence()) {
+						// skip "invisible" insets
+						--pos;
+						continue;
+					}
+					c = par.getChar(pos - 1);
+					break;
+				}
+			}
 		}
+		InsetQuotesParams::QuoteLevel const quote_level = inner
+				? InsetQuotesParams::SecondaryQuotes : InsetQuotesParams::PrimaryQuotes;
+		cur.insert(new InsetQuotes(cur.buffer(), c, quote_level, cmd.getArg(1), cmd.getArg(2)));
+		cur.buffer()->updateBuffer();
+		cur.posForward();
 		break;
 	}
 
@@ -1618,8 +1621,10 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		bvcur.setMark(false);
 		switch (cmd.button()) {
 		case mouse_button::button1:
-			// Set the cursor
-			if (!bv->mouseSetCursor(cur, cmd.argument() == "region-select"))
+			if (!bvcur.selection())
+				// Set the cursor
+				bvcur.resetAnchor();
+			if (!bv->mouseSetCursor(cur, cmd.modifier() == ShiftModifier))
 				cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor);
 			if (bvcur.wordSelection())
 				selectWord(bvcur, WHOLE_WORD);
@@ -1645,7 +1650,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 				return;
 			}
 			if (!bv->mouseSetCursor(cur, false))
-				cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor);
+				cur.screenUpdateFlags(Update::FitCursor);
 			break;
 		}
 
@@ -1673,6 +1678,9 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
 		tm->setCursorFromCoordinates(cur, cmd.x(), y);
 		cur.setTargetX(cmd.x());
+		// Don't allow selecting a separator inset
+		if (cur.pos() && cur.paragraph().isEnvSeparator(cur.pos() - 1))
+			cur.posBackward();
 		if (cmd.y() >= wh)
 			lyx::dispatch(FuncRequest(LFUN_DOWN_SELECT));
 		else if (cmd.y() < 0)
@@ -1687,7 +1695,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		// We continue with our existing selection or start a new one, so don't
 		// reset the anchor.
 		bvcur.setCursor(cur);
-		bvcur.setSelection(true);
+		bvcur.selection(true);
 		if (cur.top() == old) {
 			// We didn't move one iota, so no need to update the screen.
 			cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor);
@@ -1767,13 +1775,9 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	}
 
 	case LFUN_HREF_INSERT: {
-		// FIXME If we're actually given an argument, shouldn't
-		// we use it, whether or not we have a selection?
 		docstring content = cmd.argument();
-		if (cur.selection()) {
+		if (content.empty() && cur.selection())
 			content = cur.selectionAsString(false);
-			cutSelection(cur, true, false);
-		}
 
 		InsetCommandParams p(HYPERLINK_CODE);
 		if (!content.empty()){
@@ -2015,22 +2019,38 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		changeDepth(cur, INC_DEPTH);
 		break;
 
-	case LFUN_MATH_DISPLAY:
-		mathDispatch(cur, cmd, true);
-		break;
-
 	case LFUN_REGEXP_MODE:
 		regexpDispatch(cur, cmd);
 		break;
 
-	case LFUN_MATH_MODE:
-		if (cmd.argument() == "on")
+	case LFUN_MATH_MODE: {
+		if (cmd.argument() == "on" || cmd.argument() == "") {
 			// don't pass "on" as argument
 			// (it would appear literally in the first cell)
-			mathDispatch(cur, FuncRequest(LFUN_MATH_MODE), false);
-		else
-			mathDispatch(cur, cmd, false);
+			docstring sel = cur.selectionAsString(false);
+			MathMacroTemplate * macro = new MathMacroTemplate(cur.buffer());
+			// create a macro template if we see "\\newcommand" somewhere, and
+			// an ordinary formula otherwise
+			if (!sel.empty()
+				&& (sel.find(from_ascii("\\newcommand")) != string::npos
+					|| sel.find(from_ascii("\\newlyxcommand")) != string::npos
+					|| sel.find(from_ascii("\\def")) != string::npos)
+				&& macro->fromString(sel)) {
+				cur.recordUndo();
+				replaceSelection(cur);
+				cur.insert(macro);
+			} else {
+				// no meaningful macro template was found
+				delete macro;
+				mathDispatch(cur,FuncRequest(LFUN_MATH_MODE));
+			}
+		} else
+			// The argument is meaningful
+			// We replace cmd with LFUN_MATH_INSERT because LFUN_MATH_MODE
+			// has a different meaning in math mode
+			mathDispatch(cur, FuncRequest(LFUN_MATH_INSERT,cmd.argument()));
 		break;
+	}
 
 	case LFUN_MATH_MACRO:
 		if (cmd.argument().empty())
@@ -2053,32 +2073,21 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			cur.push(*inset);
 			cur.top().pos() = cur.top().lastpos();
 			cur.resetAnchor();
-			cur.setSelection(true);
+			cur.selection(true);
 			cur.top().pos() = 0;
 		}
 		break;
 
-	// passthrough hat and underscore outside mathed:
+	case LFUN_MATH_DISPLAY:
 	case LFUN_MATH_SUBSCRIPT:
-		mathDispatch(cur, FuncRequest(LFUN_SELF_INSERT, "_"), false);
-		break;
 	case LFUN_MATH_SUPERSCRIPT:
-		mathDispatch(cur, FuncRequest(LFUN_SELF_INSERT, "^"), false);
-		break;
-
 	case LFUN_MATH_INSERT:
 	case LFUN_MATH_AMS_MATRIX:
 	case LFUN_MATH_MATRIX:
 	case LFUN_MATH_DELIM:
-	case LFUN_MATH_BIGDELIM: {
-		cur.recordUndo();
-		cap::replaceSelection(cur);
-		cur.insert(new InsetMathHull(cur.buffer(), hullSimple));
-		checkAndActivateInset(cur, true);
-		LASSERT(cur.inMathed(), break);
-		cur.dispatch(cmd);
+	case LFUN_MATH_BIGDELIM:
+		mathDispatch(cur, cmd);
 		break;
-	}
 
 	case LFUN_FONT_EMPH: {
 		Font font(ignore_font, ignore_language);
@@ -2233,6 +2242,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
 	case LFUN_FINISHED_BACKWARD:
 		LYXERR(Debug::DEBUG, "handle LFUN_FINISHED_BACKWARD:\n" << cur);
+		cur.setCurrentFont();
 		break;
 
 	case LFUN_FINISHED_FORWARD:
@@ -2267,6 +2277,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	case LFUN_ACCENT_GRAVE:
 	case LFUN_ACCENT_ACUTE:
 	case LFUN_ACCENT_TILDE:
+	case LFUN_ACCENT_PERISPOMENI:
 	case LFUN_ACCENT_CEDILLA:
 	case LFUN_ACCENT_MACRON:
 	case LFUN_ACCENT_DOT:
@@ -2438,7 +2449,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
 	case LFUN_ESCAPE:
 		if (cur.selection()) {
-			cur.setSelection(false);
+			cur.selection(false);
 		} else {
 			cur.undispatched();
 			// This used to be LFUN_FINISHED_RIGHT, I think FORWARD is more
@@ -2723,7 +2734,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	case LFUN_CAPTION_INSERT: {
 		code = CAPTION_CODE;
 		string arg = cmd.getArg(0);
-		bool varia = arg != "LongTableNoNumber"
+		bool varia = arg != "Unnumbered"
 			&& cur.inset().allowsCaptionVariation(arg);
 		// not allowed in description items,
 		// and in specific insets
@@ -2863,6 +2874,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	case LFUN_QUOTE_INSERT:
 		// always allow this, since we will inset a raw quote
 		// if an inset is not allowed.
+		allow_in_passthru = true;
 		break;
 	case LFUN_SPECIALCHAR_INSERT:
 		code = SPECIALCHAR_CODE;
@@ -3107,13 +3119,12 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 		break;
 
 	case LFUN_LAYOUT: {
-		enable = !cur.inset().forcePlainLayout();
-
+		DocumentClass const & tclass = cur.buffer()->params().documentClass();
 		docstring layout = cmd.argument();
-		if (layout.empty()) {
-			DocumentClass const & tclass = cur.buffer()->params().documentClass();
+		if (layout.empty())
 			layout = tclass.defaultLayoutName();
-		}
+		enable = !owner_->forcePlainLayout() && tclass.hasLayout(layout);
+
 		flag.setOnOff(layout == cur.paragraph().layout().name());
 		break;
 	}
@@ -3148,10 +3159,13 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	case LFUN_PARAGRAPH_PARAMS:
 	case LFUN_PARAGRAPH_PARAMS_APPLY:
 	case LFUN_PARAGRAPH_UPDATE:
-		enable = cur.inset().allowParagraphCustomization();
+		enable = owner_->allowParagraphCustomization();
 		break;
 
 	// FIXME: why are accent lfuns forbidden with pass_thru layouts?
+	//  Because they insert COMBINING DIACRITICAL Unicode characters,
+	//  that cannot be handled by LaTeX but must be converted according
+	//  to the definition in lib/unicodesymbols?
 	case LFUN_ACCENT_ACUTE:
 	case LFUN_ACCENT_BREVE:
 	case LFUN_ACCENT_CARON:
@@ -3165,6 +3179,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	case LFUN_ACCENT_OGONEK:
 	case LFUN_ACCENT_TIE:
 	case LFUN_ACCENT_TILDE:
+	case LFUN_ACCENT_PERISPOMENI:
 	case LFUN_ACCENT_UMLAUT:
 	case LFUN_ACCENT_UNDERBAR:
 	case LFUN_ACCENT_UNDERDOT: