X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph_pimpl.C;h=bad7602b1d0e286ef030524a38709432eb5f81d0;hb=ca6838b288daf07eec7d7a381d74c639c0de3a46;hp=ff3bd2f2c3f2d729762577d8d5e2797fbfd83a1c;hpb=0aaa8c5bcc03167509a9b25124aa839e33ff3ca0;p=lyx.git

diff --git a/src/paragraph_pimpl.C b/src/paragraph_pimpl.C
index ff3bd2f2c3..bad7602b1d 100644
--- a/src/paragraph_pimpl.C
+++ b/src/paragraph_pimpl.C
@@ -58,6 +58,15 @@ special_phrase const special_phrases[] = {
 
 size_t const phrases_nr = sizeof(special_phrases)/sizeof(special_phrase);
 
+
+bool isEncoding(BufferParams const & bparams, LyXFont const & font,
+		string const & encoding)
+{
+	return (bparams.inputenc == encoding
+		|| (bparams.inputenc == "auto"
+		    && font.language()->encoding()->latexName() == encoding));
+}
+
 } // namespace anon
 
 
@@ -78,31 +87,49 @@ Paragraph::Pimpl::Pimpl(Pimpl const & p, Paragraph * owner)
 }
 
 
-void Paragraph::Pimpl::setContentsFromPar(Paragraph const & par)
+bool Paragraph::Pimpl::isChanged(pos_type start, pos_type end) const
 {
-	owner_->text_ = par.text_;
-	// FIXME: change tracking (MG)
-	// check whether this method is really needed
-	changes_ = par.pimpl_->changes_;
+	BOOST_ASSERT(start >= 0 && start <= size());
+	BOOST_ASSERT(end > start && end <= size() + 1);
+
+	return changes_.isChanged(start, end);
 }
 
 
-bool Paragraph::Pimpl::isChanged(pos_type start, pos_type end) const
-{
-	return changes_.isChanged(start, end);
+bool Paragraph::Pimpl::isMergedOnEndOfParDeletion(bool trackChanges) const {
+	// keep the logic here in sync with the logic of eraseChars()
+
+	if (!trackChanges) {
+		return true;
+	}
+
+	Change change = changes_.lookup(size());
+
+	return change.type == Change::INSERTED && change.author == 0;
 }
 
 
 void Paragraph::Pimpl::setChange(Change const & change)
 {
-	// FIXME: change tracking (MG)
-	// how about end-of-line? size()+1?
-	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);
+	// 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);
 			}
 		}
 	}
@@ -111,11 +138,14 @@ void Paragraph::Pimpl::setChange(Change const & change)
 
 void Paragraph::Pimpl::setChange(pos_type pos, Change const & change)
 {
+	BOOST_ASSERT(pos >= 0 && pos <= size());
+
 	changes_.set(change, pos);
 
-	// FIXME: change tracking (MG)
-	// do we have to set the change recursively?
-	if (pos < size() && owner_->isInset(pos)) {
+	// see comment in setChange(Change const &) above
+
+	if (change.type != Change::DELETED &&
+	    pos < size() && owner_->isInset(pos)) {
 		owner_->getInset(pos)->setChange(change);
 	}
 }
@@ -123,94 +153,97 @@ void Paragraph::Pimpl::setChange(pos_type pos, Change const & change)
 
 Change const Paragraph::Pimpl::lookupChange(pos_type pos) const
 {
+	BOOST_ASSERT(pos >= 0 && pos <= size());
+
 	return changes_.lookup(pos);
 }
 
 
-void Paragraph::Pimpl::acceptChange(pos_type start, pos_type end)
+void Paragraph::Pimpl::acceptChanges(pos_type start, pos_type end)
 {
-	// FIXME: change tracking (MG)
-	return;
-
-	// care for empty pars
+	BOOST_ASSERT(start >= 0 && start <= size());
+	BOOST_ASSERT(end > start && end <= size() + 1);
 
-	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();
+				}
+
 				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();
+				}
 				break;
 
 			case Change::DELETED:
-				// Suppress access to nonexistent
-				// "end-of-paragraph char":
-				if (i < size()) {
-					eraseChar(i, false);
+				// 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(pos_type start, pos_type end)
 {
-	// FIXME: change tracking (MG)
-	return;
-
-	// care for empty pars
-
-	pos_type i = start;
+	BOOST_ASSERT(start >= 0 && start <= size());
+	BOOST_ASSERT(end > start && end <= size() + 1);
 
-	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();
+				}
 				break;
 
 			case Change::INSERTED:
-				if (i < size()) {
-					eraseChar(i, false);
+				// 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());
 
 	// track change
 	changes_.insert(change, pos);
@@ -243,7 +276,7 @@ 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);
@@ -255,24 +288,31 @@ void Paragraph::Pimpl::insertInset(pos_type pos, InsetBase * inset,
 
 bool Paragraph::Pimpl::eraseChar(pos_type pos, bool trackChanges)
 {
-	BOOST_ASSERT(pos <= size());
+	BOOST_ASSERT(pos >= 0 && pos <= size());
+
+	// keep the logic here in sync with the logic of isMergedOnEndOfParDeletion()
 
 	if (trackChanges) {
-		Change::Type changetype(changes_.lookup(pos).type);
+		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 (changetype == Change::UNCHANGED) {
+		if (change.type == Change::UNCHANGED ||
+		    (change.type == Change::INSERTED && change.author != 0)) {
 			setChange(pos, Change(Change::DELETED));
 			return false;
 		}
 
-		if (changetype == Change::DELETED)
+		if (change.type == Change::DELETED)
 			return false;
 	}
 
-	// Don't physically access nonexistent end-of-paragraph char
+	// 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()) {
-		// FIXME: change tracking (MG)
-		// how do we handle end-of-pars previously marked inserted?
 		return false;
 	}
 
@@ -325,6 +365,9 @@ bool Paragraph::Pimpl::eraseChar(pos_type pos, 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 (!eraseChar(i, trackChanges))
@@ -540,13 +583,8 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 		case 0xb9:    // ¹ SUPERSCRIPT ONE
 		case 0xac:    // ¬ NOT SIGN
 		case 0xb5:    // µ MICRO SIGN
-			if ((bparams.inputenc == "latin1" ||
-			     bparams.inputenc == "latin9") ||
-			    (bparams.inputenc == "auto" &&
-			     (font.language()->encoding()->latexName()
-			      == "latin1" ||
-			      font.language()->encoding()->latexName()
-			      == "latin9"))) {
+			if (isEncoding(bparams, font, "latin1")
+			    || isEncoding(bparams, font, "latin9")) {
 				os << "\\ensuremath{";
 				os.put(c);
 				os << '}';
@@ -622,6 +660,73 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 			}
 			break;
 
+		case 0x20ac:    // EURO SIGN
+			if (isEncoding(bparams, font, "latin9")
+			    || isEncoding(bparams, font, "cp1251")
+			    || isEncoding(bparams, font, "utf8")
+			    || isEncoding(bparams, font, "latin10")
+			    || isEncoding(bparams, font, "cp858")) {
+				os.put(c);
+			} else {
+				os << "\\texteuro{}";
+				column += 10;
+			}
+			break;
+
+		// These characters are covered by latin1, but not
+		// by latin9 (a.o.). We have to support them because
+		// we switched the default of latin1-languages to latin9
+		case 0xa4:    // CURRENCY SYMBOL
+		case 0xa6:    // BROKEN BAR
+		case 0xa8:    // DIAERESIS
+		case 0xb4:    // ACUTE ACCENT
+		case 0xb8:    // CEDILLA
+		case 0xbd:    // 1/2 FRACTION
+		case 0xbc:    // 1/4 FRACTION
+		case 0xbe:    // 3/4 FRACTION
+			if (isEncoding(bparams, font, "latin1")
+			    || isEncoding(bparams, font, "latin5")
+			    || isEncoding(bparams, font, "utf8")) {
+				os.put(c);
+				break;
+			} else {
+				switch (c) {
+				case 0xa4:
+					os << "\\textcurrency{}";
+					column += 15;
+					break;
+				case 0xa6:
+					os << "\\textbrokenbar{}";
+					column += 16;
+					break;
+				case 0xa8:
+					os << "\\textasciidieresis{}";
+					column += 20;
+					break;
+				case 0xb4:
+					os << "\\textasciiacute{}";
+					column += 17;
+					break;
+				case 0xb8: // from latin1.def:
+					os << "\\c\\ ";
+					column += 3;
+					break;
+				case 0xbd:
+					os << "\\textonehalf{}";
+					column += 14;
+					break;
+				case 0xbc:
+					os << "\\textonequarter{}";
+					column += 17;
+					break;
+				case 0xbe:
+					os << "\\textthreequarters{}";
+					column += 20;
+					break;
+				}
+				break;
+			}
+
 		case '$': case '&':
 		case '%': case '#': case '{':
 		case '}': case '_':
@@ -718,7 +823,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()) {
@@ -733,7 +838,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;
 		}
 
@@ -772,6 +877,12 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features,
 				break;
 			}
 		}
+		// these glyphs require the textcomp package
+		if (getChar(i) == 0x20ac || getChar(i) == 0xa4
+		    || getChar(i) == 0xa6 || getChar(i) == 0xa8
+		    || getChar(i) == 0xb4 || getChar(i) == 0xbd
+		    || getChar(i) == 0xbc || getChar(i) == 0xbe)
+			features.require("textcomp");
 	}
 }