X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph_pimpl.C;h=900837a49a80d2c26e790ef0de5d81f4f2f965e5;hb=ba62665f966508db5a4de6864f4aa7374c5a5356;hp=5d8055b963ade18ec07b28f2ecce69b028654f84;hpb=ccd9433f4cb34e1bab6ecf53f6e35af79aba648e;p=lyx.git

diff --git a/src/paragraph_pimpl.C b/src/paragraph_pimpl.C
index 5d8055b963..900837a49a 100644
--- a/src/paragraph_pimpl.C
+++ b/src/paragraph_pimpl.C
@@ -58,6 +58,18 @@ special_phrase const special_phrases[] = {
 
 size_t const phrases_nr = sizeof(special_phrases)/sizeof(special_phrase);
 
+
+/// Get the real encoding of a character with font \p font.
+/// doc_encoding == bparams.encoding(), but we use a precomputed variable
+/// since bparams.encoding() is expensive
+inline Encoding const & getEncoding(BufferParams const & bparams,
+		Encoding const & doc_encoding, LyXFont const & font)
+{
+	if (bparams.inputenc == "auto" || bparams.inputenc == "default")
+		return *(font.language()->encoding());
+	return doc_encoding;
+}
+
 } // namespace anon
 
 
@@ -78,35 +90,49 @@ Paragraph::Pimpl::Pimpl(Pimpl const & p, Paragraph * owner)
 }
 
 
-void Paragraph::Pimpl::setContentsFromPar(Paragraph const & par)
-{
-	owner_->text_ = par.text_;
-	// FIXME: change tracking (MG)
-	changes_ = par.pimpl_->changes_;
-}
-
-
 bool Paragraph::Pimpl::isChanged(pos_type start, pos_type end) const
 {
-	// FIXME: change tracking (MG)
-	return false;
+	BOOST_ASSERT(start >= 0 && start <= size());
+	BOOST_ASSERT(end > start && end <= size() + 1);
 
 	return changes_.isChanged(start, end);
 }
 
 
-void Paragraph::Pimpl::setChange(Change const & change)
-{
-	// FIXME: change tracking (MG)
+bool Paragraph::Pimpl::isMergedOnEndOfParDeletion(bool trackChanges) const {
+	// keep the logic here in sync with the logic of eraseChars()
 
-	return;
+	if (!trackChanges) {
+		return true;
+	}
+
+	Change change = changes_.lookup(size());
+
+	return change.type == Change::INSERTED && change.author == 0;
+}
 
-	changes_.set(change, 0, size());
 
-	if (change.type == Change::UNCHANGED) { // only for UNCHANGED ???
-		for (pos_type i = 0; i < size(); ++i) {
-			if (owner_->isInset(i)) {
-				owner_->getInset(i)->setChange(change);
+void Paragraph::Pimpl::setChange(Change const & change)
+{
+	// beware of the imaginary end-of-par character!
+	changes_.set(change, 0, size() + 1);
+
+	/*
+	 * Propagate the change recursively - but not in case of DELETED!
+	 *
+	 * Imagine that your co-author makes changes in an existing inset. He
+	 * sends your document to you and you come to the conclusion that the
+	 * inset should go completely. If you erase it, LyX must not delete all
+	 * text within the inset. Otherwise, the change tracked insertions of
+	 * your co-author get lost and there is no way to restore them later.
+	 *
+	 * Conclusion: An inset's content should remain untouched if you delete it
+	 */
+
+	if (change.type != Change::DELETED) {
+		for (pos_type pos = 0; pos < size(); ++pos) {
+			if (owner_->isInset(pos)) {
+				owner_->getInset(pos)->setChange(change);
 			}
 		}
 	}
@@ -115,111 +141,115 @@ void Paragraph::Pimpl::setChange(Change const & change)
 
 void Paragraph::Pimpl::setChange(pos_type pos, Change const & change)
 {
-	// FIXME: change tracking (MG)
-	return;
+	BOOST_ASSERT(pos >= 0 && pos <= size());
 
 	changes_.set(change, pos);
+
+	// see comment in setChange(Change const &) above
+
+	if (change.type != Change::DELETED &&
+	    pos < size() && owner_->isInset(pos)) {
+		owner_->getInset(pos)->setChange(change);
+	}
 }
 
 
-Change const Paragraph::Pimpl::lookupChange(pos_type pos) const
+Change const & Paragraph::Pimpl::lookupChange(pos_type pos) const
 {
-	// FIXME: change tracking (MG)
-	return Change(Change::UNCHANGED);
+	BOOST_ASSERT(pos >= 0 && pos <= size());
 
 	return changes_.lookup(pos);
 }
 
 
-void Paragraph::Pimpl::acceptChange(pos_type start, pos_type end)
+void Paragraph::Pimpl::acceptChanges(BufferParams const & bparams, pos_type start, pos_type end)
 {
-	// FIXME: change tracking (MG)
-	return;
+	BOOST_ASSERT(start >= 0 && start <= size());
+	BOOST_ASSERT(end > start && end <= size() + 1);
 
-	// care for empty pars
-
-	lyxerr[Debug::CHANGES] << "acceptchange" << endl;
-	pos_type i = start;
-
-	for (; i < end; ++i) {
-		switch (lookupChange(i).type) {
+	for (pos_type pos = start; pos < end; ++pos) {
+		switch (lookupChange(pos).type) {
 			case Change::UNCHANGED:
+				// accept changes in nested inset
+				if (pos < size() && owner_->isInset(pos)) {
+					owner_->getInset(pos)->acceptChanges(bparams);
+				}
+
 				break;
 
 			case Change::INSERTED:
-				// FIXME: change tracking (MG)
-				changes_.set(Change(Change::UNCHANGED), i);
+				changes_.set(Change(Change::UNCHANGED), pos);
+				// also accept changes in nested inset
+				if (pos < size() && owner_->isInset(pos)) {
+					owner_->getInset(pos)->acceptChanges(bparams);
+				}
 				break;
 
 			case Change::DELETED:
-				// Suppress access to nonexistent
-				// "end-of-paragraph char":
-				if (i < size()) {
-					erase(i);
+				// Suppress access to non-existent
+				// "end-of-paragraph char"
+				if (pos < size()) {
+					eraseChar(pos, false);
 					--end;
-					--i;
+					--pos;
 				}
 				break;
 		}
-	}
 
-	lyxerr[Debug::CHANGES] << "endacceptchange" << endl;
-	// FIXME: change tracking (MG)
-	// changes_.reset(Change::UNCHANGED);
+	}
 }
 
 
-void Paragraph::Pimpl::rejectChange(pos_type start, pos_type end)
+void Paragraph::Pimpl::rejectChanges(BufferParams const & bparams, pos_type start, pos_type end)
 {
-	// FIXME: change tracking (MG)
-	return;
+	BOOST_ASSERT(start >= 0 && start <= size());
+	BOOST_ASSERT(end > start && end <= size() + 1);
 
-	// care for empty pars
-
-	pos_type i = start;
-
-	for (; i < end; ++i) {
-		switch (lookupChange(i).type) {
+	for (pos_type pos = start; pos < end; ++pos) {
+		switch (lookupChange(pos).type) {
 			case Change::UNCHANGED:
+				// reject changes in nested inset
+				if (pos < size() && owner_->isInset(pos)) {
+					owner_->getInset(pos)->rejectChanges(bparams);
+				}
 				break;
 
 			case Change::INSERTED:
-				if (i < size()) {
-					erase(i);
+				// Suppress access to non-existent
+				// "end-of-paragraph char"
+				if (pos < size()) {
+					eraseChar(pos, false);
 					--end;
-					--i;
+					--pos;
 				}
 				break;
 
 			case Change::DELETED:
-				// FIXME: change tracking (MG)
-				changes_.set(Change(Change::UNCHANGED), i);
-				// No real char at position size():
-				if (i < size() && owner_->isInset(i))
-					// FIXME: change tracking (MG)
-					owner_->getInset(i)->setChange(Change(Change::UNCHANGED));
+				changes_.set(Change(Change::UNCHANGED), pos);
+
+				// Do NOT reject changes within a deleted inset!
+				// There may be insertions of a co-author inside of it!
+
 				break;
 		}
 	}
-	// FIXME: change tracking (MG)
-	// changes_.reset(Change::UNCHANGED);
 }
 
 
 Paragraph::value_type Paragraph::Pimpl::getChar(pos_type pos) const
 {
+	BOOST_ASSERT(pos >= 0 && pos <= size());
+
 	return owner_->getChar(pos);
 }
 
 
 void Paragraph::Pimpl::insertChar(pos_type pos, value_type c, Change const & change)
 {
-	BOOST_ASSERT(pos <= size());
+	BOOST_ASSERT(pos >= 0 && pos <= size());
 
-	// FIXME: change tracking (MG)
-	if (false) {
-		changes_.record(change, pos);
-	}
+	// track change
+	changes_.insert(change, pos);
 
 	// This is actually very common when parsing buffers (and
 	// maybe inserting ascii text)
@@ -233,9 +263,8 @@ void Paragraph::Pimpl::insertChar(pos_type pos, value_type c, Change const & cha
 
 	// Update the font table.
 	FontTable search_font(pos, LyXFont());
-	for (FontList::iterator it = lower_bound(fontlist.begin(),
-						      fontlist.end(),
-						      search_font, matchFT());
+	for (FontList::iterator it 
+	      = lower_bound(fontlist.begin(), fontlist.end(), search_font, matchFT());
 	     it != fontlist.end(); ++it)
 	{
 		it->pos(it->pos() + 1);
@@ -246,11 +275,11 @@ void Paragraph::Pimpl::insertChar(pos_type pos, value_type c, Change const & cha
 }
 
 
-void Paragraph::Pimpl::insertInset(pos_type pos,
-				   InsetBase * inset, Change const & change)
+void Paragraph::Pimpl::insertInset(pos_type pos, InsetBase * inset,
+                                   Change const & change)
 {
 	BOOST_ASSERT(inset);
-	BOOST_ASSERT(pos <= size());
+	BOOST_ASSERT(pos >= 0 && pos <= size());
 
 	insertChar(pos, META_INSET, change);
 	BOOST_ASSERT(owner_->text_[pos] == META_INSET);
@@ -260,12 +289,38 @@ void Paragraph::Pimpl::insertInset(pos_type pos,
 }
 
 
-void Paragraph::Pimpl::erase(pos_type pos)
+bool Paragraph::Pimpl::eraseChar(pos_type pos, bool trackChanges)
 {
-	// FIXME: change tracking (MG)
-	// do something like changes_.erase(i);
-	// in one of the next patches, the two erase functions 
- 	// will be merged but I don't want to break too many things at the same time :-)
+	BOOST_ASSERT(pos >= 0 && pos <= size());
+
+	// keep the logic here in sync with the logic of isMergedOnEndOfParDeletion()
+
+	if (trackChanges) {
+		Change change = changes_.lookup(pos);
+
+		// set the character to DELETED if 
+		//  a) it was previously unchanged or
+		//  b) it was inserted by a co-author
+
+		if (change.type == Change::UNCHANGED ||
+		    (change.type == Change::INSERTED && change.author != 0)) {
+			setChange(pos, Change(Change::DELETED));
+			return false;
+		}
+
+		if (change.type == Change::DELETED)
+			return false;
+	}
+
+	// Don't physically access the imaginary end-of-paragraph character.
+	// eraseChar() can only mark it as DELETED. A physical deletion of
+	// end-of-par must be handled externally.
+	if (pos == size()) {
+		return false;
+	}
+
+	// track change
+	changes_.erase(pos);
 
 	// if it is an inset, delete the inset entry
 	if (owner_->text_[pos] == Paragraph::META_INSET) {
@@ -306,58 +361,66 @@ void Paragraph::Pimpl::erase(pos_type pos)
 
 	// Update the insetlist
 	owner_->insetlist.decreasePosAfterPos(pos);
-}
-
 
-bool Paragraph::Pimpl::erase(pos_type pos, bool /*trackChanges*/)
-{
-	BOOST_ASSERT(pos <= size());
-
-	// FIXME: change tracking (MG)
-	if (false) {
-		Change::Type changetype(changes_.lookup(pos).type);
-
-		// only allow the actual removal if it was /new/ text
-		if (changetype != Change::INSERTED) {
-			changes_.record(Change(Change::DELETED), pos);
-			if (pos < size() && owner_->isInset(pos))
-				// FIXME: change tracking (MG)
-				owner_->getInset(pos)->setChange(Change(Change::DELETED));
-			return false;
-		}
-	}
-
-	// Don't physically access nonexistent end-of-paragraph char
-	if (pos < size()) {
-		erase(pos);
-		return true;
-	}
-
-	return false;
+	return true;
 }
 
 
-int Paragraph::Pimpl::erase(pos_type start, pos_type end, bool trackChanges)
+int Paragraph::Pimpl::eraseChars(pos_type start, pos_type end, bool trackChanges)
 {
+	BOOST_ASSERT(start >= 0 && start <= size());
+	BOOST_ASSERT(end >= start && end <= size() + 1);
+
 	pos_type i = start;
 	for (pos_type count = end - start; count; --count) {
-		if (!erase(i, trackChanges))
+		if (!eraseChar(i, trackChanges))
 			++i;
 	}
 	return end - i;
 }
 
 
-void Paragraph::Pimpl::simpleTeXBlanks(odocstream & os, TexRow & texrow,
-				       pos_type const i,
+int Paragraph::Pimpl::latexSurrogatePair(odocstream & os, value_type c,
+		value_type next, Encoding const & encoding)
+{
+	// Writing next here may circumvent a possible font change between
+	// c and next. Since next is only output if it forms a surrogate pair
+	// with c we can ignore this:
+	// A font change inside a surrogate pair does not make sense and is
+	// hopefully impossible to input.
+	// FIXME: change tracking
+	// Is this correct WRT change tracking?
+	docstring const latex1 = encoding.latexChar(next);
+	docstring const latex2 = encoding.latexChar(c);
+	os << latex1 << '{' << latex2 << '}';
+	return latex1.length() + latex2.length() + 2;
+}
+
+
+bool Paragraph::Pimpl::simpleTeXBlanks(BufferParams const & bparams,
+                                       Encoding const & doc_encoding,
+                                       odocstream & os, TexRow & texrow,
+                                       pos_type & i,
 				       unsigned int & column,
 				       LyXFont const & font,
 				       LyXLayout const & style)
 {
 	if (style.pass_thru)
-		return;
+		return false;
+
+	if (i < size() - 1) {
+		char_type next = getChar(i + 1);
+		if (Encodings::isCombiningChar(next)) {
+			// This space has an accent, so we must always output it.
+			Encoding const & encoding = getEncoding(bparams, doc_encoding, font);
+			column += latexSurrogatePair(os, ' ', next, encoding) - 1;
+			++i;
+			return true;
+		}
+	}
 
-	if (column > lyxrc.ascii_linelen
+	if (lyxrc.plaintext_linelen > 0
+	    && column > lyxrc.plaintext_linelen
 	    && i
 	    && getChar(i - 1) != ' '
 	    && (i < size() - 1)
@@ -379,6 +442,7 @@ void Paragraph::Pimpl::simpleTeXBlanks(odocstream & os, TexRow & texrow,
 	} else {
 		os << ' ';
 	}
+	return false;
 }
 
 
@@ -392,6 +456,8 @@ bool Paragraph::Pimpl::isTextAt(string const & str, pos_type pos) const
 
 	// does the wanted text start at point?
 	for (string::size_type i = 0; i < str.length(); ++i) {
+		// Caution: direct comparison of characters works only
+		// because str is pure ASCII.
 		if (str[i] != owner_->text_[pos + i])
 			return false;
 	}
@@ -412,6 +478,7 @@ bool Paragraph::Pimpl::isTextAt(string const & str, pos_type pos) const
 
 void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 					     BufferParams const & bparams,
+					     Encoding const & doc_encoding,
 					     odocstream & os,
 					     TexRow & texrow,
 					     OutputParams const & runparams,
@@ -429,6 +496,8 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 	if (style.pass_thru) {
 		if (c != Paragraph::META_INSET) {
 			if (c != '\0')
+				// FIXME UNICODE: This can fail if c cannot
+				// be encoded in the current encoding.
 				os.put(c);
 		} else
 			owner_->getInset(i)->plaintext(buf, os, runparams);
@@ -454,7 +523,8 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 				os << '\n';
 			} else {
 				if (open_font) {
-					column += running_font.latexWriteEndChanges(os, basefont, basefont);
+					column += running_font.latexWriteEndChanges(
+						os, basefont, basefont, bparams);
 					open_font = false;
 				}
 				basefont = owner_->getLayoutFont(bparams, outerfont);
@@ -507,10 +577,8 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 #endif
 		// some insets cannot be inside a font change command
 		if (open_font && inset->noFontChange()) {
-			column +=running_font.
-				latexWriteEndChanges(os,
-						     basefont,
-						     basefont);
+			column += running_font.latexWriteEndChanges(
+					os, basefont, basefont, bparams);
 			open_font = false;
 			basefont = owner_->getLayoutFont(bparams, outerfont);
 			running_font = basefont;
@@ -542,25 +610,10 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 			column += 15;
 			break;
 
-		case '±': case '²': case '³':
-		case '×': case '÷': case '¹':
-		case '¬': case 'µ':
-			if ((bparams.inputenc == "latin1" ||
-			     bparams.inputenc == "latin9") ||
-			    (bparams.inputenc == "auto" &&
-			     (font.language()->encoding()->latexName()
-			      == "latin1" ||
-			      font.language()->encoding()->latexName()
-			      == "latin9"))) {
-				os << "\\ensuremath{";
-				os.put(c);
-				os << '}';
-				column += 13;
-			} else {
-				os.put(c);
-			}
-			break;
-
+		// The following characters could be written literally in latin1, but they
+		// would be wrongly converted on systems where char is signed, so we give
+		// the code points.
+		// This also makes us independant from the encoding of this source file.
 		case '|': case '<': case '>':
 			// In T1 encoding, these characters exist
 			if (lyxrc.fontenc == "T1") {
@@ -570,12 +623,13 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 				    && i <= size() - 2
 				    && getChar(i + 1) == c) {
 					//os << "\\textcompwordmark{}";
+					//column += 19;
 					// Jean-Marc, have a look at
 					// this. I think this works
 					// equally well:
 					os << "\\,{}";
 					// Lgb
-					column += 19;
+					column += 3;
 				}
 				break;
 			}
@@ -618,15 +672,6 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 			column += 9;
 			break;
 
-		case '£':
-			if (bparams.inputenc == "default") {
-				os << "\\pounds{}";
-				column += 8;
-			} else {
-				os.put(c);
-			}
-			break;
-
 		case '$': case '&':
 		case '%': case '#': case '{':
 		case '}': case '_':
@@ -664,6 +709,8 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 		default:
 
 			// I assume this is hack treating typewriter as verbatim
+			// FIXME UNICODE: This can fail if c cannot be encoded
+			// in the current encoding.
 			if (font.family() == LyXFont::TYPEWRITER_FAMILY) {
 				if (c != '\0') {
 					os.put(c);
@@ -691,7 +738,27 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 			}
 
 			if (pnr == phrases_nr && c != '\0') {
-				os.put(c);
+				Encoding const & encoding = getEncoding(bparams, doc_encoding, font);
+				if (i < size() - 1) {
+					char_type next = getChar(i + 1);
+					if (Encodings::isCombiningChar(next)) {
+						column += latexSurrogatePair(os, c, next, encoding) - 1;
+						++i;
+						break;
+					}
+				}
+				docstring const latex = encoding.latexChar(c);
+				if (latex.length() > 1 &&
+				    latex[latex.length() - 1] != '}') {
+					// Prevent eating of a following
+					// space or command corruption by
+					// following characters
+					column += latex.length() + 1;
+					os << latex << "{}";
+				} else {
+					column += latex.length() - 1;
+					os << latex;
+				}
 			}
 			break;
 		}
@@ -723,7 +790,7 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features,
 					     << endl;
 			features.require("noun");
 			lyxerr[Debug::LATEX] << "Noun enabled. Font: "
-					     << fcit->font().stateText(0)
+					     << to_utf8(fcit->font().stateText(0))
 					     << endl;
 		}
 		switch (fcit->font().color()) {
@@ -738,7 +805,7 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features,
 		default:
 			features.require("color");
 			lyxerr[Debug::LATEX] << "Color enabled. Font: "
-					     << fcit->font().stateText(0)
+					     << to_utf8(fcit->font().stateText(0))
 					     << endl;
 		}
 
@@ -769,6 +836,7 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features,
 	}
 
 	// then the contents
+	Encoding const & doc_encoding = bparams.encoding();
 	for (pos_type i = 0; i < size() ; ++i) {
 		for (size_t pnr = 0; pnr < phrases_nr; ++pnr) {
 			if (!special_phrases[pnr].builtin
@@ -777,6 +845,12 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features,
 				break;
 			}
 		}
+		// We do not need the completely realized font, since we are
+		// only interested in the language, and that is never inherited.
+		// Therefore we can use getFontSettings instead of getFont.
+		LyXFont const & font = owner_->getFontSettings(bparams, i);
+		Encoding const & encoding = getEncoding(bparams, doc_encoding, font);
+		encoding.validate(getChar(i), features);
 	}
 }