X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph_pimpl.C;h=426862c246e3f8d04151b46d8ac03ef240cc1268;hb=35204f8f33d7400a5fefeffea533fb4cb4097211;hp=a79c0e36d12c283757372d52eab56ebd5b529751;hpb=034f172087f18a81710eb467018d38dac7c1bf21;p=lyx.git

diff --git a/src/paragraph_pimpl.C b/src/paragraph_pimpl.C
index a79c0e36d1..426862c246 100644
--- a/src/paragraph_pimpl.C
+++ b/src/paragraph_pimpl.C
@@ -14,29 +14,30 @@
 #include <config.h>
 
 #include "paragraph_pimpl.h"
+#include "paragraph.h"
 
 #include "bufferparams.h"
 #include "debug.h"
 #include "encoding.h"
 #include "language.h"
 #include "LaTeXFeatures.h"
-#include "latexrunparams.h"
 #include "LColor.h"
 #include "lyxlength.h"
 #include "lyxrc.h"
+#include "outputparams.h"
 #include "texrow.h"
 
+#include <boost/next_prior.hpp>
 
-using lyx::pos_type;
+
+namespace lyx {
 
 using std::endl;
 using std::upper_bound;
-
-using std::ostream;
+using std::lower_bound;
+using std::string;
 
 
-// Initialize static member.
-ShareContainer<LyXFont> Paragraph::Pimpl::FontTable::container;
 // Initialization of the counter for the paragraph id's,
 unsigned int Paragraph::Pimpl::paragraph_id = 0;
 
@@ -44,15 +45,15 @@ namespace {
 
 struct special_phrase {
 	string phrase;
-	string macro;
+	docstring macro;
 	bool builtin;
 };
 
-special_phrase special_phrases[] = {
-	{ "LyX", "\\LyX{}", false },
-	{ "TeX", "\\TeX{}", true },
-	{ "LaTeX2e", "\\LaTeXe{}", true },
-	{ "LaTeX", "\\LaTeX{}", true },
+special_phrase const special_phrases[] = {
+	{ "LyX", from_ascii("\\LyX{}"), false },
+	{ "TeX", from_ascii("\\TeX{}"), true },
+	{ "LaTeX2e", from_ascii("\\LaTeXe{}"), true },
+	{ "LaTeX", from_ascii("\\LaTeX{}"), true },
 };
 
 size_t const phrases_nr = sizeof(special_phrases)/sizeof(special_phrase);
@@ -69,204 +70,162 @@ Paragraph::Pimpl::Pimpl(Paragraph * owner)
 
 
 Paragraph::Pimpl::Pimpl(Pimpl const & p, Paragraph * owner)
-	: params(p.params), owner_(owner)
+	: params(p.params), changes_(p.changes_), owner_(owner)
 {
 	inset_owner = p.inset_owner;
 	fontlist = p.fontlist;
 	id_ = paragraph_id++;
-
-	if (p.tracking())
-		changes_.reset(new Changes(*p.changes_.get()));
-}
-
-
-void Paragraph::Pimpl::setContentsFromPar(Paragraph const & par)
-{
-	owner_->text_ = par.text_;
-	if (par.pimpl_->tracking()) {
-		changes_.reset(new Changes(*(par.pimpl_->changes_.get())));
-	}
-}
-
-
-void Paragraph::Pimpl::trackChanges(Change::Type type)
-{
-	if (tracking()) {
-		lyxerr[Debug::CHANGES] << "already tracking for par " << id_ << endl;
-		return;
-	}
-
-	lyxerr[Debug::CHANGES] << "track changes for par "
-		<< id_ << " type " << type << endl;
-	changes_.reset(new Changes(type));
-	changes_->set(type, 0, size());
-}
-
-
-void Paragraph::Pimpl::untrackChanges()
-{
-	changes_.reset(0);
-}
-
-
-void Paragraph::Pimpl::cleanChanges()
-{
-	// if we're not tracking, we don't want to reset...
-	if (!tracking())
-		return;
-
-	changes_.reset(new Changes(Change::INSERTED));
-	changes_->set(Change::INSERTED, 0, size());
 }
 
 
 bool Paragraph::Pimpl::isChanged(pos_type start, pos_type end) const
 {
-	if (!tracking())
-		return false;
-
-	return changes_->isChange(start, end);
-}
-
-
-bool Paragraph::Pimpl::isChangeEdited(pos_type start, pos_type end) const
-{
-	if (!tracking())
-		return false;
+	BOOST_ASSERT(start >= 0 && start <= size());
+	BOOST_ASSERT(end > start && end <= size() + 1);
 
-	return changes_->isChangeEdited(start, end);
+	return changes_.isChanged(start, end);
 }
 
 
-void Paragraph::Pimpl::setChange(pos_type pos, Change::Type type)
+void Paragraph::Pimpl::setChange(Change const & change)
 {
-	if (!tracking())
-		return;
-
-	changes_->set(type, pos);
+	// 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);
+			}
+		}
+	}
 }
 
 
-Change::Type Paragraph::Pimpl::lookupChange(pos_type pos) const
+void Paragraph::Pimpl::setChange(pos_type pos, Change const & change)
 {
-	if (!tracking())
-		return Change::UNCHANGED;
+	BOOST_ASSERT(pos >= 0 && pos <= size());
 
-	return changes_->lookup(pos);
-}
+	changes_.set(change, pos);
 
+	// see comment in setChange(Change const &) above
 
-Change const Paragraph::Pimpl::lookupChangeFull(pos_type pos) const
-{
-	if (!tracking())
-		return Change(Change::UNCHANGED);
-
-	return changes_->lookupFull(pos);
+	if (change.type != Change::DELETED &&
+	    pos < size() && owner_->isInset(pos)) {
+		owner_->getInset(pos)->setChange(change);
+	}
 }
 
 
-void Paragraph::Pimpl::markErased()
+Change const Paragraph::Pimpl::lookupChange(pos_type pos) const
 {
-	BOOST_ASSERT(tracking());
+	BOOST_ASSERT(pos >= 0 && pos <= size());
 
-	// FIXME: we should actually remove INSERTED chars.
-	// difficult because owning insettexts/tabulars need
-	// to update themselves when rows etc. change
-	changes_->set(Change::DELETED, 0, size());
-	changes_->reset(Change::DELETED);
+	return changes_.lookup(pos);
 }
 
 
-void Paragraph::Pimpl::acceptChange(pos_type start, pos_type end)
+void Paragraph::Pimpl::acceptChanges(pos_type start, pos_type end)
 {
-	if (!tracking())
-		return;
-
-	if (!size()) {
-		changes_.reset(new Changes(Change::UNCHANGED));
-		return;
-	}
-
-	lyxerr << "acceptchange" << endl;
-	pos_type i = start;
-
-	for (; i < end; ++i) {
-		switch (lookupChange(i)) {
+	BOOST_ASSERT(start >= 0 && start <= size());
+	BOOST_ASSERT(end > start && end <= size() + 1);
+	
+	for (pos_type pos = start; pos < end; ++pos) {
+		switch (lookupChange(pos).type) {
 			case Change::UNCHANGED:
 				break;
 
 			case Change::INSERTED:
-				changes_->set(Change::UNCHANGED, i);
+				changes_.set(Change(Change::UNCHANGED), pos);
 				break;
 
 			case Change::DELETED:
-				eraseIntern(i);
-				changes_->erase(i);
-				--end;
-				--i;
+				// Suppress access to non-existent
+				// "end-of-paragraph char"
+				if (pos < size()) {
+					eraseChar(pos, false);
+					--end;
+					--pos;
+				}
 				break;
 		}
-	}
 
-	lyxerr << "endacceptchange" << endl;
-	changes_->reset(Change::UNCHANGED);
+		// also accept changes in nested insets
+		if (pos < size() && owner_->isInset(pos)) {
+			owner_->getInset(pos)->acceptChanges();
+		}
+	}
 }
 
 
-void Paragraph::Pimpl::rejectChange(pos_type start, pos_type end)
+void Paragraph::Pimpl::rejectChanges(pos_type start, pos_type end)
 {
-	if (!tracking())
-		return;
+	BOOST_ASSERT(start >= 0 && start <= size());
+	BOOST_ASSERT(end > start && end <= size() + 1);
 
-	if (!size()) {
-		changes_.reset(new Changes(Change::UNCHANGED));
-		return;
-	}
-
-	pos_type i = start;
-
-	for (; i < end; ++i) {
-		switch (lookupChange(i)) {
+	for (pos_type pos = start; pos < end; ++pos) {
+		switch (lookupChange(pos).type) {
 			case Change::UNCHANGED:
+				// also reject changes inside of insets
+				if (pos < size() && owner_->isInset(pos)) {
+					owner_->getInset(pos)->rejectChanges();
+				}
 				break;
 
 			case Change::INSERTED:
-				eraseIntern(i);
-				changes_->erase(i);
-				--end;
-				--i;
+				// Suppress access to non-existent
+				// "end-of-paragraph char"
+				if (pos < size()) {
+					eraseChar(pos, false);
+					--end;
+					--pos;
+				}
 				break;
 
 			case Change::DELETED:
-				changes_->set(Change::UNCHANGED, i);
+				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;
 		}
 	}
-	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,
-				  LyXFont const & font, Change change)
+void Paragraph::Pimpl::insertChar(pos_type pos, value_type c, Change const & change)
 {
-	BOOST_ASSERT(pos <= size());
+	BOOST_ASSERT(pos >= 0 && pos <= size());
 
-	if (tracking()) {
-		changes_->record(change, pos);
-	}
+	// track change
+	changes_.insert(change, pos);
 
 	// This is actually very common when parsing buffers (and
 	// maybe inserting ascii text)
 	if (pos == size()) {
 		// when appending characters, no need to update tables
 		owner_->text_.push_back(c);
-		owner_->setFont(pos, font);
 		return;
 	}
 
@@ -274,9 +233,8 @@ void Paragraph::Pimpl::insertChar(pos_type pos, value_type c,
 
 	// 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);
@@ -284,30 +242,54 @@ void Paragraph::Pimpl::insertChar(pos_type pos, value_type c,
 
 	// Update the insets
 	owner_->insetlist.increasePosAfterPos(pos);
-
-	owner_->setFont(pos, font);
 }
 
 
-void Paragraph::Pimpl::insertInset(pos_type pos,
-				   InsetOld * inset, LyXFont const & font, Change 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, font, change);
+	insertChar(pos, META_INSET, change);
 	BOOST_ASSERT(owner_->text_[pos] == META_INSET);
 
 	// Add a new entry in the insetlist.
 	owner_->insetlist.insert(inset, pos);
-
-	if (inset_owner)
-		inset->setOwner(inset_owner);
 }
 
 
-void Paragraph::Pimpl::eraseIntern(pos_type pos)
+bool Paragraph::Pimpl::eraseChar(pos_type pos, bool trackChanges)
 {
+	BOOST_ASSERT(pos >= 0 && pos <= size());
+
+	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) {
 		owner_->insetlist.erase(pos);
@@ -340,54 +322,33 @@ void Paragraph::Pimpl::eraseIntern(pos_type pos)
 		}
 	}
 
-	// Update all other entries.
+	// Update all other entries
 	FontList::iterator fend = fontlist.end();
 	for (; it != fend; ++it)
 		it->pos(it->pos() - 1);
 
-	// Update the insetlist.
+	// Update the insetlist
 	owner_->insetlist.decreasePosAfterPos(pos);
-}
-
-
-bool Paragraph::Pimpl::erase(pos_type pos)
-{
-	BOOST_ASSERT(pos < size());
-
-	if (tracking()) {
-		Change::Type changetype(changes_->lookup(pos));
-		changes_->record(Change(Change::DELETED), pos);
-
-		// only allow the actual removal if it was /new/ text
-		if (changetype != Change::INSERTED) {
-			if (owner_->text_[pos] == Paragraph::META_INSET) {
-				InsetOld * i(owner_->getInset(pos));
-				i->markErased();
-			}
-			return false;
-		}
-	}
 
-	eraseIntern(pos);
 	return true;
 }
 
 
-int Paragraph::Pimpl::erase(pos_type start, pos_type end)
+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;
-	pos_type count = end - start;
-	while (count) {
-		if (!erase(i)) {
+	for (pos_type count = end - start; count; --count) {
+		if (!eraseChar(i, trackChanges))
 			++i;
-		}
-		--count;
 	}
 	return end - i;
 }
 
 
-void Paragraph::Pimpl::simpleTeXBlanks(ostream & os, TexRow & texrow,
+void Paragraph::Pimpl::simpleTeXBlanks(odocstream & os, TexRow & texrow,
 				       pos_type const i,
 				       unsigned int & column,
 				       LyXFont const & font,
@@ -451,9 +412,9 @@ bool Paragraph::Pimpl::isTextAt(string const & str, pos_type pos) const
 
 void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 					     BufferParams const & bparams,
-					     ostream & os,
+					     odocstream & os,
 					     TexRow & texrow,
-					     LatexRunParams const & runparams,
+					     OutputParams const & runparams,
 					     LyXFont & font,
 					     LyXFont & running_font,
 					     LyXFont & basefont,
@@ -468,11 +429,9 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 	if (style.pass_thru) {
 		if (c != Paragraph::META_INSET) {
 			if (c != '\0')
-				os << c;
-		} else {
-			InsetOld const * inset = owner_->getInset(i);
-			inset->ascii(buf, os, 0);
-		}
+				os.put(c);
+		} else
+			owner_->getInset(i)->plaintext(buf, os, runparams);
 		return;
 	}
 
@@ -481,14 +440,14 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 	// and then split to handle the two modes separately.
 	switch (c) {
 	case Paragraph::META_INSET: {
-		InsetOld * inset = owner_->getInset(i);
+		InsetBase * inset = owner_->getInset(i);
 
 		// FIXME: remove this check
 		if (!inset)
 			break;
 
 		// FIXME: move this to InsetNewline::latex
-		if (inset->lyxCode() == InsetOld::NEWLINE_CODE) {
+		if (inset->lyxCode() == InsetBase::NEWLINE_CODE) {
 			// newlines are handled differently here than
 			// the default in simpleTeXSpecialChars().
 			if (!style.newline_allowed) {
@@ -515,18 +474,26 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 			break;
 		}
 
-		if (inset->isTextInset()) {
+		// output change tracking marks only if desired,
+		// if dvipost is installed,
+		// and with dvi/ps (other formats don't work)
+		LaTeXFeatures features(buf, bparams, runparams);
+		bool const output = bparams.outputChanges
+			&& runparams.flavor == OutputParams::LATEX
+			&& features.isAvailable("dvipost");
+
+		if (inset->canTrackChanges()) {
 			column += Changes::latexMarkChange(os, running_change,
-				Change::UNCHANGED);
+				Change::UNCHANGED, output);
 			running_change = Change::UNCHANGED;
 		}
 
 		bool close = false;
-		int const len = os.tellp();
-		//ostream::pos_type const len = os.tellp();
-		if ((inset->lyxCode() == InsetOld::GRAPHICS_CODE
-		     || inset->lyxCode() == InsetOld::MATH_CODE
-		     || inset->lyxCode() == InsetOld::URL_CODE)
+		odocstream::pos_type const len = os.tellp();
+
+		if ((inset->lyxCode() == InsetBase::GRAPHICS_CODE
+		     || inset->lyxCode() == InsetBase::MATH_CODE
+		     || inset->lyxCode() == InsetBase::URL_CODE)
 		    && running_font.isRightToLeft()) {
 			os << "\\L{";
 			close = true;
@@ -561,7 +528,7 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 			texrow.start(owner_->id(), i + 1);
 			column = 0;
 		} else {
-			column += int(os.tellp()) - len;
+			column += os.tellp() - len;
 		}
 	}
 	break;
@@ -575,29 +542,38 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 			column += 15;
 			break;
 
-		case '±': case '²': case '³':
-		case '×': case '÷': case '¹':
-		case '¬': case 'µ':
+		// 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 0xb1:    // ± PLUS-MINUS SIGN
+		case 0xb2:    // ² SUPERSCRIPT TWO
+		case 0xb3:    // ³ SUPERSCRIPT THREE
+		case 0xd7:    // × MULTIPLICATION SIGN
+		case 0xf7:    // ÷ DIVISION SIGN
+		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()
+			     (font.language()->encoding()->latexName()
 			      == "latin1" ||
-			      font.language()->encoding()->LatexName()
+			      font.language()->encoding()->latexName()
 			      == "latin9"))) {
-				os << "\\ensuremath{"
-				   << c
-				   << '}';
+				os << "\\ensuremath{";
+				os.put(c);
+				os << '}';
 				column += 13;
 			} else {
-				os << c;
+				os.put(c);
 			}
 			break;
 
 		case '|': case '<': case '>':
 			// In T1 encoding, these characters exist
 			if (lyxrc.fontenc == "T1") {
-				os << c;
+				os.put(c);
 				//... but we should avoid ligatures
 				if ((c == '>' || c == '<')
 				    && i <= size() - 2
@@ -614,7 +590,7 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 			}
 			// Typewriter font also has them
 			if (font.family() == LyXFont::TYPEWRITER_FAMILY) {
-				os << c;
+				os.put(c);
 				break;
 			}
 			// Otherwise, we use what LaTeX
@@ -651,19 +627,20 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 			column += 9;
 			break;
 
-		case '£':
+		case 0xa3:    // £ POUND SIGN
 			if (bparams.inputenc == "default") {
 				os << "\\pounds{}";
 				column += 8;
 			} else {
-				os << c;
+				os.put(c);
 			}
 			break;
 
 		case '$': case '&':
 		case '%': case '#': case '{':
 		case '}': case '_':
-			os << '\\' << c;
+			os << '\\';
+			os.put(c);
 			column += 1;
 			break;
 
@@ -677,9 +654,11 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 			column += 17;
 			break;
 
-		case '*': case '[': case ']':
+		case '*': case '[':
 			// avoid being mistaken for optional arguments
-			os << '{' << c << '}';
+			os << '{';
+			os.put(c);
+			os << '}';
 			column += 2;
 			break;
 
@@ -696,7 +675,7 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 			// I assume this is hack treating typewriter as verbatim
 			if (font.family() == LyXFont::TYPEWRITER_FAMILY) {
 				if (c != '\0') {
-					os << c;
+					os.put(c);
 				}
 				break;
 			}
@@ -721,7 +700,7 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 			}
 
 			if (pnr == phrases_nr && c != '\0') {
-				os << c;
+				os.put(c);
 			}
 			break;
 		}
@@ -735,8 +714,6 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features,
 	BufferParams const & bparams = features.bufferParams();
 
 	// check the params.
-	if (params.lineTop() || params.lineBottom())
-		features.require("lyxline");
 	if (!params.spacing().isDefault())
 		features.require("setspace");
 
@@ -789,13 +766,13 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features,
 		features.require("ParagraphLeftIndent");
 
 	// then the insets
-	InsetList::iterator icit = owner_->insetlist.begin();
-	InsetList::iterator iend = owner_->insetlist.end();
+	InsetList::const_iterator icit = owner_->insetlist.begin();
+	InsetList::const_iterator iend = owner_->insetlist.end();
 	for (; icit != iend; ++icit) {
 		if (icit->inset) {
 			icit->inset->validate(features);
 			if (layout.needprotect &&
-			    icit->inset->lyxCode() == InsetOld::FOOT_CODE)
+			    icit->inset->lyxCode() == InsetBase::FOOT_CODE)
 				features.require("NeedLyXFootnoteCode");
 		}
 	}
@@ -811,3 +788,6 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features,
 		}
 	}
 }
+
+
+} // namespace lyx