X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FBuffer.cpp;h=3652e7af12eff8927f559c37711f8a4f2b1a5cd8;hb=2de30c62f8d671a8c8d4d52a6a7310e2c5ca84de;hp=f907d6cdffed2254d59d74c7216e0a87e60c0b7f;hpb=5afe6cf9474e810e24e66f8361ce0276628b3c64;p=lyx.git

diff --git a/src/Buffer.cpp b/src/Buffer.cpp
index f907d6cdff..3652e7af12 100644
--- a/src/Buffer.cpp
+++ b/src/Buffer.cpp
@@ -57,6 +57,7 @@
 #include "PDFOptions.h"
 #include "SpellChecker.h"
 #include "sgml.h"
+#include "texstream.h"
 #include "TexRow.h"
 #include "Text.h"
 #include "TextClass.h"
@@ -78,6 +79,7 @@
 #include "mathed/MathMacroTemplate.h"
 #include "mathed/MathSupport.h"
 
+#include "graphics/GraphicsCache.h"
 #include "graphics/PreviewLoader.h"
 
 #include "frontends/alert.h"
@@ -107,12 +109,12 @@
 #include "support/types.h"
 
 #include "support/bind.h"
-#include "support/shared_ptr.h"
 
 #include <algorithm>
 #include <fstream>
 #include <iomanip>
 #include <map>
+#include <memory>
 #include <set>
 #include <sstream>
 #include <vector>
@@ -236,8 +238,8 @@ public:
 	/// positions of child buffers in the buffer
 	typedef map<Buffer const * const, DocIterator> BufferPositionMap;
 	struct ScopeBuffer {
-		ScopeBuffer() {}
-		ScopeBuffer(DocIterator const & s,Buffer const * b)
+		ScopeBuffer() : buffer(0) {}
+		ScopeBuffer(DocIterator const & s, Buffer const * b)
 			: scope(s), buffer(b) {}
 		DocIterator scope;
 		Buffer const * buffer;
@@ -370,6 +372,10 @@ public:
 		+ (with_blanks ? blank_count_ : 0);
 	}
 
+	// does the buffer contain tracked changes? (if so, we automatically
+	// display the review toolbar, for instance)
+	mutable bool tracked_changes_present_;
+
 private:
 	/// So we can force access via the accessors.
 	mutable Buffer const * parent_buffer;
@@ -415,9 +421,9 @@ Buffer::Impl::Impl(Buffer * owner, FileName const & file, bool readonly_,
 	  file_fully_loaded(false), file_format(LYX_FORMAT), need_format_backup(false),
 	  ignore_parent(false),  toc_backend(owner), macro_lock(false), timestamp_(0),
 	  checksum_(0), wa_(0),  gui_(0), undo_(*owner), bibinfo_cache_valid_(false),
-	  bibfile_cache_valid_(false), cite_labels_valid_(false), inset(0),
-	  preview_loader_(0), cloned_buffer_(cloned_buffer), clone_list_(0),
-	  doing_export(false), parent_buffer(0),
+	  bibfile_cache_valid_(false), cite_labels_valid_(false), preview_error_(false),
+	  inset(0), preview_loader_(0), cloned_buffer_(cloned_buffer),
+	  clone_list_(0), doing_export(false), parent_buffer(0),
 	  word_count_(0), char_count_(0), blank_count_(0)
 {
 	if (!cloned_buffer_) {
@@ -442,6 +448,7 @@ Buffer::Impl::Impl(Buffer * owner, FileName const & file, bool readonly_,
 	preview_file_ = cloned_buffer_->d->preview_file_;
 	preview_format_ = cloned_buffer_->d->preview_format_;
 	preview_error_ = cloned_buffer_->d->preview_error_;
+	tracked_changes_present_ = cloned_buffer_->d->tracked_changes_present_;
 }
 
 
@@ -517,8 +524,12 @@ Buffer::~Buffer()
 		Impl::BufferPositionMap::iterator end = d->children_positions.end();
 		for (; it != end; ++it) {
 			Buffer * child = const_cast<Buffer *>(it->first);
-			if (theBufferList().isLoaded(child))
-				theBufferList().releaseChild(this, child);
+			if (theBufferList().isLoaded(child)) { 
+			 if (theBufferList().isOthersChild(this, child))
+				 child->setParent(0);
+			 else
+				theBufferList().release(child);
+			}
 		}
 
 		if (!isClean()) {
@@ -899,8 +910,8 @@ int Buffer::readHeader(Lexer & lex)
 	params().html_latex_end.clear();
 	params().html_math_img_scale = 1.0;
 	params().output_sync_macro.erase();
-	params().setLocalLayout(string(), false);
-	params().setLocalLayout(string(), true);
+	params().setLocalLayout(docstring(), false);
+	params().setLocalLayout(docstring(), true);
 
 	for (int i = 0; i < 4; ++i) {
 		params().user_defined_bullet(i) = ITEMIZE_DEFAULTS[i];
@@ -939,15 +950,13 @@ int Buffer::readHeader(Lexer & lex)
 									"%1$s %2$s\n"),
 							 from_utf8(token),
 							 lex.getDocString());
-				errorList.push_back(ErrorItem(_("Document header error"),
-					s, -1, 0, 0));
+				errorList.push_back(ErrorItem(_("Document header error"), s));
 			}
 		}
 	}
 	if (begin_header_line) {
 		docstring const s = _("\\begin_header is missing");
-		errorList.push_back(ErrorItem(_("Document header error"),
-			s, -1, 0, 0));
+		errorList.push_back(ErrorItem(_("Document header error"), s));
 	}
 
 	params().makeDocumentClass();
@@ -969,8 +978,7 @@ bool Buffer::readDocument(Lexer & lex)
 
 	if (!lex.checkFor("\\begin_document")) {
 		docstring const s = _("\\begin_document is missing");
-		errorList.push_back(ErrorItem(_("Document header error"),
-			s, -1, 0, 0));
+		errorList.push_back(ErrorItem(_("Document header error"), s));
 	}
 
 	readHeader(lex);
@@ -1029,7 +1037,10 @@ bool Buffer::readDocument(Lexer & lex)
 	params().indiceslist().addDefault(B_("Index"));
 
 	// read main text
-	d->old_position = originFilePath();
+	if (FileName::isAbsolute(params().origin))
+		d->old_position = params().origin;
+	else
+		d->old_position = filePath();
 	bool const res = text().read(lex, errorList, d->inset);
 	d->old_position.clear();
 
@@ -1306,15 +1317,15 @@ Buffer::ReadStatus Buffer::convertLyXFormat(FileName const & fn,
 }
 
 
-string Buffer::getBackupName() const {
+FileName Buffer::getBackupName() const {
 	FileName const & fn = fileName();
 	string const fname = fn.onlyFileNameWithoutExt();
-	string const fext  = fn.extension();
+	string const fext  = fn.extension() + "~";
 	string const fpath = lyxrc.backupdir_path.empty() ?
 		fn.onlyPath().absFileName() :
 		lyxrc.backupdir_path;
 	string const fform = convert<string>(d->file_format);
-	string const backname = fname + "-" + fform;
+	string const backname = fname + "-lyxformat-" + fform;
 	FileName backup(addName(fpath, addExtension(backname, fext)));
 
 	// limit recursion, just in case
@@ -1333,11 +1344,11 @@ string Buffer::getBackupName() const {
 			v = 1000;
 			break;
 		}
-		string newbackname = backname + "-" + convert<string>(v);
+		string const newbackname = backname + "-" + convert<string>(v);
 		backup.set(addName(fpath, addExtension(newbackname, fext)));
 		v++;
 	}
-	return v < 100 ? backup.absFileName() : "";
+	return v < 100 ? backup : FileName();
 }
 
 
@@ -1385,9 +1396,8 @@ bool Buffer::save() const
 	// proper location once that has been done successfully. that
 	// way we preserve the original file if something goes wrong.
 	string const justname = fileName().onlyFileNameWithoutExt();
-	boost::scoped_ptr<TempFile>
-		tempfile(new TempFile(fileName().onlyPath(),
-	           justname + "-XXXXXX.lyx"));
+	auto tempfile = make_unique<TempFile>(fileName().onlyPath(),
+	                                      justname + "-XXXXXX.lyx");
 	bool const symlink = fileName().isSymLink();
 	if (!symlink)
 		tempfile->setAutoRemove(false);
@@ -1401,12 +1411,10 @@ bool Buffer::save() const
 	bool made_backup = true;
 
 	FileName backupName;
-	if (lyxrc.make_backup || d->need_format_backup) {
-		if (d->need_format_backup) {
-			string backup_name = getBackupName();
-			if (!backup_name.empty())
-				backupName.set(backup_name);
-		}
+	bool const needBackup = lyxrc.make_backup || d->need_format_backup;
+	if (needBackup) {
+		if (d->need_format_backup)
+			backupName = getBackupName();
 
 		// If we for some reason failed to find a backup name in case of
 		// a format change, this will still set one. It's the best we can
@@ -1461,8 +1469,8 @@ bool Buffer::save() const
 	}
 	// else we saved the file, but failed to move it to the right location.
 
-	if (lyxrc.make_backup && made_backup && !symlink) {
-		// the original file was moved to filename.lyx~, so it will look
+	if (needBackup && made_backup && !symlink) {
+		// the original file was moved to some new location, so it will look
 		// to the user as if it was deleted. (see bug #9234.) we could try
 		// to restore it, but that would basically mean trying to do again
 		// what we just failed to do. better to leave things as they are.
@@ -1650,9 +1658,11 @@ bool Buffer::makeLaTeXFile(FileName const & fname,
 {
 	OutputParams runparams = runparams_in;
 
-	// XeTeX with TeX fonts is only safe with ASCII encoding,
-	// but the "flavor" is not known in BufferParams::encoding().
-	if (!params().useNonTeXFonts && (runparams.flavor == OutputParams::XETEX))
+	// XeTeX with TeX fonts is only safe with ASCII encoding (see also #9740),
+	// Check here, because the "flavor" is not known in BufferParams::encoding()
+	// (power users can override this safety measure selecting "utf8-plain").
+	if (!params().useNonTeXFonts && (runparams.flavor == OutputParams::XETEX)
+	    && (runparams.encoding->name() != "utf8-plain"))
 		runparams.encoding = encodings.fromLyXName("ascii");
 
 	string const encoding = runparams.encoding->iconvName();
@@ -1673,7 +1683,7 @@ bool Buffer::makeLaTeXFile(FileName const & fname,
 	ErrorList & errorList = d->errorLists["Export"];
 	errorList.clear();
 	bool failed_export = false;
-	otexstream os(ofs, d->texrow);
+	otexstream os(ofs);
 
 	// make sure we are ready to export
 	// this needs to be done before we validate
@@ -1683,7 +1693,6 @@ bool Buffer::makeLaTeXFile(FileName const & fname,
 	updateMacroInstances(OutputUpdate);
 
 	try {
-		os.texrow().reset();
 		writeLaTeXSource(os, original_path, runparams, output);
 	}
 	catch (EncodingException const & e) {
@@ -1696,17 +1705,17 @@ bool Buffer::makeLaTeXFile(FileName const & fname,
 		errorList.push_back(ErrorItem(msg, _("Some characters of your document are probably not "
 				"representable in the chosen encoding.\n"
 				"Changing the document encoding to utf8 could help."),
-				e.par_id, e.pos, e.pos + 1));
+		                              {e.par_id, e.pos}, {e.par_id, e.pos + 1}));
 		failed_export = true;
 	}
 	catch (iconv_codecvt_facet_exception const & e) {
 		errorList.push_back(ErrorItem(_("iconv conversion failed"),
-			_(e.what()), -1, 0, 0));
+		                              _(e.what())));
 		failed_export = true;
 	}
 	catch (exception const & e) {
 		errorList.push_back(ErrorItem(_("conversion failed"),
-			_(e.what()), -1, 0, 0));
+		                              _(e.what())));
 		failed_export = true;
 	}
 	catch (...) {
@@ -1714,6 +1723,8 @@ bool Buffer::makeLaTeXFile(FileName const & fname,
 		lyx_exit(1);
 	}
 
+	d->texrow = move(os.texrow());
+
 	ofs.close();
 	if (ofs.fail()) {
 		failed_export = true;
@@ -1738,8 +1749,10 @@ void Buffer::writeLaTeXSource(otexstream & os,
 	OutputParams runparams = runparams_in;
 
 	// XeTeX with TeX fonts is only safe with ASCII encoding,
-	// but the "flavor" is not known in BufferParams::encoding().
-	if (!params().useNonTeXFonts && (runparams.flavor == OutputParams::XETEX))
+	// Check here, because the "flavor" is not known in BufferParams::encoding()
+	// (power users can override this safety measure selecting "utf8-plain").
+	if (!params().useNonTeXFonts && (runparams.flavor == OutputParams::XETEX)
+	    && (runparams.encoding->name() != "utf8-plain"))
 		runparams.encoding = encodings.fromLyXName("ascii");
 	// FIXME: when only the current paragraph is shown, this is ignored
 	//        (or not reached) and characters encodable in the current
@@ -1862,6 +1875,47 @@ void Buffer::writeLaTeXSource(otexstream & os,
 		// Write the preamble
 		runparams.use_babel = params().writeLaTeX(os, features,
 							  d->filename.onlyPath());
+		
+		if (!runparams.dryrun && features.hasPolyglossiaExclusiveLanguages()
+		    && !features.hasOnlyPolyglossiaLanguages()) {
+			docstring blangs;
+			docstring plangs;
+			vector<string> bll = features.getBabelExclusiveLanguages();
+			vector<string> pll = features.getPolyglossiaExclusiveLanguages();
+			if (!bll.empty()) {
+				docstring langs;
+				for (vector<string>::const_iterator it = bll.begin(); it != bll.end(); ++it) {
+					if (!langs.empty())
+						langs += ", ";
+					langs += _(*it);
+				}
+				blangs = bll.size() > 1 ?
+					    support::bformat(_("The languages %1$s are only supported by Babel."), langs)
+					  : support::bformat(_("The language %1$s is only supported by Babel."), langs);
+			}
+			if (!pll.empty()) {
+				docstring langs;
+				for (vector<string>::const_iterator it = pll.begin(); it != pll.end(); ++it) {
+					if (!langs.empty())
+						langs += ", ";
+					langs += _(*it);
+				}
+				plangs = pll.size() > 1 ?
+					    support::bformat(_("The languages %1$s are only supported by Polyglossia."), langs)
+					  : support::bformat(_("The language %1$s is only supported by Polyglossia."), langs);
+				if (!blangs.empty())
+					plangs += "\n"; 
+			}
+
+			frontend::Alert::warning(
+				_("Incompatible Languages!"),
+				support::bformat(
+				  _("You cannot use the following languages "
+				    "together in one LaTeX document because "
+				    "they require conflicting language packages:\n"
+				    "%1$s%2$s"),
+				  plangs, blangs));
+		}
 
 		// Japanese might be required only in some children of a document,
 		// but once required, we must keep use_japanese true.
@@ -1875,8 +1929,14 @@ void Buffer::writeLaTeXSource(otexstream & os,
 		}
 
 		// make the body.
+		// mark the beginning of the body to separate it from InPreamble insets
+		os.texrow().start(TexRow::beginDocument());
 		os << "\\begin{document}\n";
 
+		// mark the start of a new paragraph by simulating a newline,
+		// so that os.afterParbreak() returns true at document start
+		os.lastChar('\n');
+
 		// output the parent macros
 		MacroSet::iterator it = parentMacros.begin();
 		MacroSet::iterator end = parentMacros.end();
@@ -1887,8 +1947,6 @@ void Buffer::writeLaTeXSource(otexstream & os,
 
 	} // output_preamble
 
-	os.texrow().start(paragraphs().begin()->id(), 0);
-
 	LYXERR(Debug::INFO, "preamble finished, now the body.");
 
 	// the real stuff
@@ -1909,8 +1967,6 @@ void Buffer::writeLaTeXSource(otexstream & os,
 	}
 	runparams_in.encoding = runparams.encoding;
 
-	os.texrow().finalize();
-
 	LYXERR(Debug::INFO, "Finished making LaTeX file.");
 	LYXERR(Debug::INFO, "Row count was " << os.texrow().rows() - 1 << '.');
 }
@@ -1946,7 +2002,7 @@ void Buffer::writeDocBookSource(odocstream & os, string const & fname,
 	LaTeXFeatures features(*this, params(), runparams);
 	validate(features);
 
-	d->texrow.reset(false);
+	d->texrow.reset();
 
 	DocumentClass const & tclass = params().documentClass();
 	string const & top_element = tclass.latexname();
@@ -1972,7 +2028,7 @@ void Buffer::writeDocBookSource(odocstream & os, string const & fname,
 		else
 			os << " PUBLIC \"-//OASIS//DTD DocBook V4.2//EN\"";
 
-		docstring preamble = from_utf8(params().preamble);
+		docstring preamble = params().preamble;
 		if (runparams.flavor != OutputParams::XML ) {
 			preamble += "<!ENTITY % output.print.png \"IGNORE\">\n";
 			preamble += "<!ENTITY % output.print.pdf \"IGNORE\">\n";
@@ -2075,14 +2131,14 @@ void Buffer::writeLyXHTMLSource(odocstream & os,
 		if (!styles.empty())
 			os << "\n<!-- Text Class Preamble -->\n" << styles << '\n';
 
-		styles = from_utf8(features.getPreambleSnippets());
+		styles = features.getPreambleSnippets().str;
 		if (!styles.empty())
 			os << "\n<!-- Preamble Snippets -->\n" << styles << '\n';
 
 		// we will collect CSS information in a stream, and then output it
 		// either here, as part of the header, or else in a separate file.
 		odocstringstream css;
-		styles = from_utf8(features.getCSSSnippets());
+		styles = features.getCSSSnippets();
 		if (!styles.empty())
 			css << "/* LyX Provided Styles */\n" << styles << '\n';
 
@@ -2137,7 +2193,7 @@ void Buffer::writeLyXHTMLSource(odocstream & os,
 	if (output_body) {
 		bool const output_body_tag = (output != IncludedFile);
 		if (output_body_tag)
-			os << "<body>\n";
+			os << "<body dir=\"auto\">\n";
 		XHTMLStream xs(os);
 		if (output != IncludedFile)
 			// if we're an included file, the counters are in the master.
@@ -2205,8 +2261,8 @@ void Buffer::validate(LaTeXFeatures & features) const
 	if (!features.runparams().is_child)
 		params().validate(features);
 
-	for_each(paragraphs().begin(), paragraphs().end(),
-		 bind(&Paragraph::validate, _1, ref(features)));
+	for (Paragraph const & p : paragraphs())
+		p.validate(features);
 
 	if (lyxerr.debugging(Debug::LATEX)) {
 		features.showStruct();
@@ -2224,8 +2280,8 @@ void Buffer::getLabelList(vector<docstring> & list) const
 
 	list.clear();
 	shared_ptr<Toc> toc = d->toc_backend.toc("label");
-	TocIterator toc_it = toc->begin();
-	TocIterator end = toc->end();
+	Toc::const_iterator toc_it = toc->begin();
+	Toc::const_iterator end = toc->end();
 	for (; toc_it != end; ++toc_it) {
 		if (toc_it->depth() == 0)
 			list.push_back(toc_it->str());
@@ -2468,7 +2524,7 @@ bool Buffer::getStatus(FuncRequest const & cmd, FuncStatus & flag)
 		size_t pos = format.find(' ');
 		if (pos != string::npos)
 			format = format.substr(0, pos);
-		enable = params().isExportable(format);
+		enable = params().isExportable(format, false);
 		if (!enable)
 			flag.message(bformat(
 					     _("Don't know how to export to format: %1$s"), arg));
@@ -2480,7 +2536,7 @@ bool Buffer::getStatus(FuncRequest const & cmd, FuncStatus & flag)
 		break;
 
 	case LFUN_BUILD_PROGRAM:
-		enable = params().isExportable("program");
+		enable = params().isExportable("program", false);
 		break;
 
 	case LFUN_BRANCH_ACTIVATE:
@@ -2760,12 +2816,16 @@ void Buffer::dispatch(FuncRequest const & func, DispatchResult & dr)
 		break;
 
 	case LFUN_CHANGES_TRACK:
-		undo().recordUndoBufferParams(CursorData());
+		if (params().save_transient_properties)
+			undo().recordUndoBufferParams(CursorData());
 		params().track_changes = !params().track_changes;
+		if (!params().track_changes)
+			dr.forceChangesUpdate();
 		break;
 
 	case LFUN_CHANGES_OUTPUT:
-		undo().recordUndoBufferParams(CursorData());
+		if (params().save_transient_properties)
+			undo().recordUndoBufferParams(CursorData());
 		params().output_changes = !params().output_changes;
 		if (params().output_changes) {
 			bool dvipost    = LaTeXFeatures::isAvailable("dvipost");
@@ -2858,11 +2918,9 @@ void Buffer::getLanguages(std::set<Language const *> & languages) const
 DocIterator Buffer::getParFromID(int const id) const
 {
 	Buffer * buf = const_cast<Buffer *>(this);
-	if (id < 0) {
-		// John says this is called with id == -1 from undo
-		lyxerr << "getParFromID(), id: " << id << endl;
+	if (id < 0)
+		// This means non-existent
 		return doc_iterator_end(buf);
-	}
 
 	for (DocIterator it = doc_iterator_begin(buf); !it.atEnd(); it.forwardPar())
 		if (it.paragraph().id() == id)
@@ -3027,12 +3085,21 @@ string Buffer::filePath() const
 }
 
 
-string Buffer::originFilePath() const
+DocFileName Buffer::getReferencedFileName(string const & fn) const
 {
-	if (FileName::isAbsolute(params().origin))
-		return params().origin;
+	DocFileName result;
+	if (FileName::isAbsolute(fn) || !FileName::isAbsolute(params().origin))
+		result.set(fn, filePath());
+	else {
+		// filePath() ends with a path separator
+		FileName const test(filePath() + fn);
+		if (test.exists())
+			result.set(fn, filePath());
+		else
+			result.set(fn, params().origin);
+	}
 
-	return filePath();
+	return result;
 }
 
 
@@ -3489,7 +3556,7 @@ void Buffer::updateMacroInstances(UpdateType utype) const
 		MacroContext mc = MacroContext(this, it);
 		for (DocIterator::idx_type i = 0; i < n; ++i) {
 			MathData & data = minset->cell(i);
-			data.updateMacros(0, mc, utype);
+			data.updateMacros(0, mc, utype, 0);
 		}
 	}
 }
@@ -3631,11 +3698,11 @@ void Buffer::changeRefsIfUnique(docstring const & from, docstring const & to)
 }
 
 // returns NULL if id-to-row conversion is unsupported
-auto_ptr<TexRow> Buffer::getSourceCode(odocstream & os, string const & format,
-			   pit_type par_begin, pit_type par_end,
-			   OutputWhat output, bool master) const
+unique_ptr<TexRow> Buffer::getSourceCode(odocstream & os, string const & format,
+                                         pit_type par_begin, pit_type par_end,
+                                         OutputWhat output, bool master) const
 {
-	auto_ptr<TexRow> texrow(NULL);
+	unique_ptr<TexRow> texrow;
 	OutputParams runparams(&params().encoding());
 	runparams.nice = true;
 	runparams.flavor = params().getOutputFlavor(format);
@@ -3687,17 +3754,15 @@ auto_ptr<TexRow> Buffer::getSourceCode(odocstream & os, string const & format,
 			// in order to know if we should output polyglossia
 			// macros (instead of babel macros)
 			LaTeXFeatures features(*this, params(), runparams);
-			params().validate(features);
+			validate(features);
 			runparams.use_polyglossia = features.usePolyglossia();
-			texrow.reset(new TexRow());
-			texrow->newline();
-			texrow->newline();
 			// latex or literate
-			otexstream ots(os, *texrow);
-
+			otexstream ots(os);
+			// output above
+			ots.texrow().newlines(2);
 			// the real stuff
 			latexParagraphs(*this, text(), ots, runparams);
-			texrow->finalize();
+			texrow = ots.releaseTexRow();
 
 			// Restore the parenthood
 			if (!master)
@@ -3732,14 +3797,13 @@ auto_ptr<TexRow> Buffer::getSourceCode(odocstream & os, string const & format,
 				writeDocBookSource(os, absFileName(), runparams, output);
 		} else {
 			// latex or literate
-			texrow.reset(new TexRow());
-			texrow->newline();
-			texrow->newline();
-			otexstream ots(os, *texrow);
+			otexstream ots(os);
+			// output above
+			ots.texrow().newlines(2);
 			if (master)
 				runparams.is_child = true;
 			writeLaTeXSource(ots, string(), runparams, output);
-			texrow->finalize();
+			texrow = ots.releaseTexRow();
 		}
 	}
 	return texrow;
@@ -3825,7 +3889,7 @@ public:
 	///
 	virtual shared_ptr<ForkedProcess> clone() const
 	{
-		return shared_ptr<ForkedProcess>(new AutoSaveBuffer(*this));
+		return make_shared<AutoSaveBuffer>(*this);
 	}
 	///
 	int start()
@@ -4288,26 +4352,22 @@ Buffer::ExportStatus Buffer::preview(string const & format, bool includeall) con
 	ExportStatus const status = doExport(format, true, false, result_file);
 	FileName const previewFile(result_file);
 
-	LATTEST (isClone());
-	d->cloned_buffer_->d->preview_file_ = previewFile;
-	d->cloned_buffer_->d->preview_format_ = format;
-	d->cloned_buffer_->d->preview_error_ = (status != ExportSuccess);
+	Impl * theimpl = isClone() ? d->cloned_buffer_->d : d;
+	theimpl->preview_file_ = previewFile;
+	theimpl->preview_format_ = format;
+	theimpl->preview_error_ = (status != ExportSuccess);
 
 	if (status != ExportSuccess)
 		return status;
-	if (previewFile.exists()) {
-		if (!formats.view(*this, previewFile, format))
-			return PreviewError;
-		else
-			return PreviewSuccess;
-	}
-	else {
-		// Successful export but no output file?
-		// Probably a bug in error detection.
-		LATTEST (status != ExportSuccess);
 
-		return status;
-	}
+	if (previewFile.exists())
+		return formats.view(*this, previewFile, format) ?
+			PreviewSuccess : PreviewError;
+
+	// Successful export but no output file?
+	// Probably a bug in error detection.
+	LATTEST(status != ExportSuccess);
+	return status;
 }
 
 
@@ -4459,56 +4519,33 @@ Buffer::ReadStatus Buffer::loadThisLyXFile(FileName const & fn)
 
 void Buffer::bufferErrors(TeXErrors const & terr, ErrorList & errorList) const
 {
-	TeXErrors::Errors::const_iterator it = terr.begin();
-	TeXErrors::Errors::const_iterator end = terr.end();
-	ListOfBuffers clist = getDescendents();
-	ListOfBuffers::const_iterator cen = clist.end();
-
-	for (; it != end; ++it) {
-		int id_start = -1;
-		int pos_start = -1;
-		int errorRow = it->error_in_line;
+	for (auto const & err : terr) {
+		TexRow::TextEntry start, end = TexRow::text_none;
+		int errorRow = err.error_in_line;
 		Buffer const * buf = 0;
 		Impl const * p = d;
-		if (it->child_name.empty())
-		    p->texrow.getIdFromRow(errorRow, id_start, pos_start);
+		if (err.child_name.empty())
+			tie(start, end) = p->texrow.getEntriesFromRow(errorRow);
 		else {
 			// The error occurred in a child
-			ListOfBuffers::const_iterator cit = clist.begin();
-			for (; cit != cen; ++cit) {
+			for (Buffer const * child : getDescendents()) {
 				string const child_name =
-					DocFileName(changeExtension(
-						(*cit)->absFileName(), "tex")).
-							mangledFileName();
-				if (it->child_name != child_name)
+					DocFileName(changeExtension(child->absFileName(), "tex")).
+					mangledFileName();
+				if (err.child_name != child_name)
 					continue;
-				(*cit)->d->texrow.getIdFromRow(errorRow,
-							id_start, pos_start);
-				if (id_start != -1) {
+				tie(start, end) = child->d->texrow.getEntriesFromRow(errorRow);
+				if (!TexRow::isNone(start)) {
 					buf = d->cloned_buffer_
-						? (*cit)->d->cloned_buffer_->d->owner_
-						: (*cit)->d->owner_;
-					p = (*cit)->d;
+						? child->d->cloned_buffer_->d->owner_
+						: child->d->owner_;
+					p = child->d;
 					break;
 				}
 			}
 		}
-		int id_end = -1;
-		int pos_end = -1;
-		bool found;
-		do {
-			++errorRow;
-			found = p->texrow.getIdFromRow(errorRow, id_end, pos_end);
-		} while (found && id_start == id_end && pos_start == pos_end);
-
-		if (id_start != id_end) {
-			// Next registered position is outside the inset where
-			// the error occurred, so signal end-of-paragraph
-			pos_end = 0;
-		}
-
-		errorList.push_back(ErrorItem(it->error_desc,
-			it->error_text, id_start, pos_start, pos_end, buf));
+		errorList.push_back(ErrorItem(err.error_desc, err.error_text,
+		                              start, end, buf));
 	}
 }
 
@@ -4568,6 +4605,7 @@ void Buffer::updateBuffer(UpdateScope scope, UpdateType utype) const
 	// update all caches
 	clearReferenceCache();
 	updateMacros();
+	setChangesPresent(false);
 
 	Buffer & cbuf = const_cast<Buffer &>(*this);
 
@@ -4595,6 +4633,11 @@ static depth_type getDepth(DocIterator const & it)
 		if (!it[i].inset().inMathed())
 			depth += it[i].paragraph().getDepth() + 1;
 	// remove 1 since the outer inset does not count
+	// we should have at least one non-math inset, so
+	// depth should nevery be 0. but maybe it is worth
+	// marking this, just in case.
+	LATTEST(depth > 0);
+	// coverity[INTEGER_OVERFLOW]
 	return depth - 1;
 }
 
@@ -4650,7 +4693,7 @@ static bool needEnumCounterReset(ParIterator const & it)
 		--prev_it.top().pit();
 		Paragraph const & prev_par = *prev_it;
 		if (prev_par.getDepth() <= cur_depth)
-			return  prev_par.layout().labeltype != LABEL_ENUMERATE;
+			return prev_par.layout().name() != par.layout().name();
 	}
 	// start of nested inset: reset
 	return true;
@@ -4734,8 +4777,12 @@ void Buffer::Impl::setLabel(ParIterator & it, UpdateType utype) const
 			break;
 		}
 
+		// Increase the master counter?
+		if (layout.stepmastercounter && needEnumCounterReset(it))
+			counters.stepMaster(enumcounter, utype);
+
 		// Maybe we have to reset the enumeration counter.
-		if (needEnumCounterReset(it))
+		if (!layout.resumecounter && needEnumCounterReset(it))
 			counters.reset(enumcounter);
 		counters.step(enumcounter, utype);
 
@@ -4831,6 +4878,9 @@ void Buffer::updateBuffer(ParIterator & parit, UpdateType utype) const
 		// set the counter for this paragraph
 		d->setLabel(parit, utype);
 
+		// update change-tracking flag 
+		parit->addChangesToBuffer(*this);
+
 		// now the insets
 		InsetList::const_iterator iit = parit->insetList().begin();
 		InsetList::const_iterator end = parit->insetList().end();
@@ -5069,13 +5119,23 @@ void Buffer::checkMasterBuffer()
 
 string Buffer::includedFilePath(string const & name, string const & ext) const
 {
+	if (d->old_position.empty() ||
+	    equivalent(FileName(d->old_position), FileName(filePath())))
+		return name;
+
 	bool isabsolute = FileName::isAbsolute(name);
-	// old_position already contains a trailing path separator
-	string const absname = isabsolute ? name : d->old_position + name;
+	// both old_position and filePath() end with a path separator
+	string absname = isabsolute ? name : d->old_position + name;
+
+	// if old_position is set to origin, we need to do the equivalent of
+	// getReferencedFileName() (see readDocument())
+	if (!isabsolute && d->old_position == params().origin) {
+		FileName const test(addExtension(filePath() + name, ext));
+		if (test.exists())
+			absname = filePath() + name;
+	}
 
-	if (d->old_position.empty()
-	    || equivalent(FileName(d->old_position), FileName(filePath()))
-	    || !FileName(addExtension(absname, ext)).exists())
+	if (!FileName(addExtension(absname, ext)).exists())
 		return name;
 
 	if (isabsolute)
@@ -5085,4 +5145,29 @@ string Buffer::includedFilePath(string const & name, string const & ext) const
 	                           from_utf8(filePath())));
 }
 
+
+void Buffer::setChangesPresent(bool b) const
+{
+	d->tracked_changes_present_ = b;
+}
+
+
+bool Buffer::areChangesPresent() const
+{
+	return d->tracked_changes_present_;
+}
+
+
+void Buffer::updateChangesPresent() const
+{
+	LYXERR(Debug::CHANGES, "Buffer::updateChangesPresent");
+	setChangesPresent(false);
+	ParConstIterator it = par_iterator_begin();
+	ParConstIterator const end = par_iterator_end();
+	for (; !areChangesPresent() && it != end; ++it)
+		it->addChangesToBuffer(*this);
+}
+
+
+
 } // namespace lyx