X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FExternalSupport.C;h=38e4970f97b9ddf25785a9a1fd8d8ede9d706703;hb=5603df4a5b7e511b31026c9a4f8f55b2b10fde57;hp=a84d0a0dd8f31a592ad1a8d91278415286df8451;hpb=16e1f90daad4974183e6a9766d3f0391ac9bcf0b;p=lyx.git

diff --git a/src/insets/ExternalSupport.C b/src/insets/ExternalSupport.C
index a84d0a0dd8..38e4970f97 100644
--- a/src/insets/ExternalSupport.C
+++ b/src/insets/ExternalSupport.C
@@ -19,6 +19,8 @@
 #include "buffer.h"
 #include "converter.h"
 #include "debug.h"
+#include "exporter.h"
+#include "format.h"
 
 #include "support/filetools.h"
 #include "support/forkedcall.h"
@@ -51,39 +53,60 @@ Template const * getTemplatePtr(InsetExternalParams const & params)
 
 void editExternal(InsetExternalParams const & params, Buffer const & buffer)
 {
-	Template const * const et_ptr = getTemplatePtr(params);
-	if (!et_ptr)
-		return;
-	Template const & et = *et_ptr;
-
-	if (et.editCommand.empty())
-		return;
-
-	string const command = doSubstitution(params, buffer, et.editCommand);
-
-	support::Path p(buffer.filePath());
-	support::Forkedcall call;
-	if (lyxerr.debugging(Debug::EXTERNAL)) {
-		lyxerr << "Executing '" << command << "' in '"
-		       << buffer.filePath() << '\'' << endl;
-	}
-	call.startscript(support::Forkedcall::DontWait, command);
+	string const file_with_path = params.filename.absFilename();
+	formats.edit(buffer, file_with_path,
+	             support::getExtFromContents(file_with_path));
 }
 
 
-namespace {
-
 string const doSubstitution(InsetExternalParams const & params,
 			    Buffer const & buffer, string const & s,
-			    string const & filename)
+			    bool external_in_tmpdir)
 {
+	Buffer const * m_buffer = buffer.getMasterBuffer();
+	string const parentpath = external_in_tmpdir ?
+		m_buffer->temppath() :
+		buffer.filePath();
+	string const filename = external_in_tmpdir ?
+		params.filename.mangledFilename() :
+		params.filename.outputFilename(parentpath);
 	string result;
-	string const basename = support::ChangeExtension(filename, string());
+	string const basename = support::ChangeExtension(
+			support::OnlyFilename(filename), string());
+	string const absname = support::MakeAbsPath(filename, parentpath);
 	string const filepath = support::OnlyPath(filename);
+	string const abspath = support::OnlyPath(absname);
+	string const masterpath = external_in_tmpdir ?
+		m_buffer->temppath() :
+		m_buffer->filePath();
+	string relToMasterPath = support::OnlyPath(
+			support::MakeRelPath(absname, masterpath));
+	if (relToMasterPath == "./")
+		relToMasterPath.clear();
+	string relToParentPath = support::OnlyPath(
+			support::MakeRelPath(absname, parentpath));
+	if (relToParentPath == "./")
+		relToParentPath.clear();
 
 	result = support::subst(s, "$$FName", filename);
 	result = support::subst(result, "$$Basename", basename);
+	result = support::subst(result, "$$Extension",
+			'.' + support::GetExtension(filename));
 	result = support::subst(result, "$$FPath", filepath);
+	result = support::subst(result, "$$AbsPath", abspath);
+	result = support::subst(result, "$$RelPathMaster", relToMasterPath);
+	result = support::subst(result, "$$RelPathParent", relToParentPath);
+	if (support::AbsolutePath(filename)) {
+		result = support::subst(result, "$$AbsOrRelPathMaster",
+		                        abspath);
+		result = support::subst(result, "$$AbsOrRelPathParent",
+		                        abspath);
+	} else {
+		result = support::subst(result, "$$AbsOrRelPathMaster",
+		                        relToMasterPath);
+		result = support::subst(result, "$$AbsOrRelPathParent",
+		                        relToParentPath);
+	}
 	result = support::subst(result, "$$Tempname", params.tempname());
 	result = support::subst(result, "$$Sysdir", support::system_lyxdir());
 
@@ -96,7 +119,7 @@ string const doSubstitution(InsetExternalParams const & params,
 		string contents;
 
 		string const filepath = support::IsFileReadable(file) ?
-			buffer.filePath() : buffer.temppath();
+			buffer.filePath() : m_buffer->temppath();
 		support::Path p(filepath);
 
 		if (support::IsFileReadable(file))
@@ -110,6 +133,9 @@ string const doSubstitution(InsetExternalParams const & params,
 	return result;
 }
 
+
+namespace {
+
 /** update the file represented by the template.
     If \param external_in_tmpdir == true, then the generated file is
     place in the buffer's temporary directory.
@@ -117,6 +143,7 @@ string const doSubstitution(InsetExternalParams const & params,
 void updateExternal(InsetExternalParams const & params,
 		    string const & format,
 		    Buffer const & buffer,
+                    ExportData & exportdata,
 		    bool external_in_tmpdir)
 {
 	Template const * const et_ptr = getTemplatePtr(params);
@@ -139,16 +166,17 @@ void updateExternal(InsetExternalParams const & params,
 	if (from_format.empty())
 		return; // NOT_NEEDED
 
-	string from_file = params.filename.absFilename();
+	string abs_from_file = params.filename.absFilename();
 
 	if (from_format == "*") {
-		if (from_file.empty())
+		if (abs_from_file.empty())
 			return; // NOT_NEEDED
 
 		// Try and ascertain the file format from its contents.
-		from_format = support::getExtFromContents(from_file);
+		from_format = support::getExtFromContents(abs_from_file);
 		if (from_format.empty())
 			return; // FAILURE
+
 	}
 
 	string const to_format = outputFormat.updateFormat;
@@ -163,38 +191,64 @@ void updateExternal(InsetExternalParams const & params,
 		return; // FAILURE
 	}
 
-	if (external_in_tmpdir && !from_file.empty()) {
+	// The master buffer. This is useful when there are multiple levels
+	// of include files
+	Buffer const * m_buffer = buffer.getMasterBuffer();
+
+	if (external_in_tmpdir && !abs_from_file.empty()) {
 		// We are running stuff through LaTeX
 		string const temp_file =
 			support::MakeAbsPath(params.filename.mangledFilename(),
-					     buffer.temppath());
-		unsigned long const from_checksum = support::sum(from_file);
+					     m_buffer->temppath());
+		unsigned long const from_checksum = support::sum(abs_from_file);
 		unsigned long const temp_checksum = support::sum(temp_file);
 
 		if (from_checksum != temp_checksum) {
-			if (!support::copy(from_file, temp_file))
+			if (!support::copy(abs_from_file, temp_file)) {
+				lyxerr[Debug::EXTERNAL]
+					<< "external::updateExternal. "
+					<< "Unable to copy "
+					<< abs_from_file << " to " << temp_file << endl;
 				return; // FAILURE
+			}
 		}
 
-		from_file = temp_file;
+		abs_from_file = temp_file;
 	}
 
 	string const to_file = doSubstitution(params, buffer,
 					      outputFormat.updateResult,
-					      from_file);
+	                                      external_in_tmpdir);
 
 	string const abs_to_file =
-		support::MakeAbsPath(to_file, buffer.filePath());
-
+		support::MakeAbsPath(to_file, external_in_tmpdir
+			? m_buffer->temppath()
+			: buffer.filePath());
+
+	// record the referenced files for the exporter
+	typedef Template::Format::FileMap FileMap;
+	FileMap::const_iterator rit  = outputFormat.referencedFiles.begin();
+	FileMap::const_iterator rend = outputFormat.referencedFiles.end();
+	for (; rit != rend; ++rit) {
+		vector<string>::const_iterator fit  = rit->second.begin();
+		vector<string>::const_iterator fend = rit->second.end();
+		for (; fit != fend; ++fit) {
+			string const file = doSubstitution(params, buffer,
+			                                   *fit,
+			                                   external_in_tmpdir);
+			exportdata.addExternalFile(rit->first, file);
+		}
+	}
+	
 	// Do we need to perform the conversion?
 	// Yes if to_file does not exist or if from_file is newer than to_file
-	if (support::compare_timestamps(from_file, abs_to_file) < 0)
+	if (support::compare_timestamps(abs_from_file, abs_to_file) < 0)
 		return; // SUCCESS
 
 	string const to_file_base =
 		support::ChangeExtension(to_file, string());
 	/* bool const success = */
-		converters.convert(&buffer, from_file, to_file_base,
+		converters.convert(&buffer, abs_from_file, to_file_base,
 				   from_format, to_format);
 	// return success
 }
@@ -212,6 +266,7 @@ string const substituteOptions(InsetExternalParams const & params,
 int writeExternal(InsetExternalParams const & params,
 		  string const & format,
 		  Buffer const & buffer, ostream & os,
+                  ExportData & exportdata,
 		  bool external_in_tmpdir)
 {
 	Template const * const et_ptr = getTemplatePtr(params);
@@ -228,34 +283,16 @@ int writeExternal(InsetExternalParams const & params,
 		return 0;
 	}
 
-	updateExternal(params, format, buffer, external_in_tmpdir);
-
-	string from_file = params.filename.outputFilename(buffer.filePath());
-	if (external_in_tmpdir && !from_file.empty()) {
-		// We are running stuff through LaTeX
-		from_file =
-			support::MakeAbsPath(params.filename.mangledFilename(),
-					     buffer.temppath());
-	}
+	updateExternal(params, format, buffer, exportdata, external_in_tmpdir);
 
 	string str = doSubstitution(params, buffer, cit->second.product,
-				    from_file);
+	                            external_in_tmpdir);
 	str = substituteCommands(params, str, format);
 	str = substituteOptions(params, str, format);
 	os << str;
 	return int(lyx::count(str.begin(), str.end(),'\n') + 1);
 }
 
-
-/// Substitute meta-variables in this string
-string const doSubstitution(InsetExternalParams const & params,
-			    Buffer const & buffer, string const & s)
-{
-	string const buffer_path = buffer.filePath();
-	string const filename = params.filename.outputFilename(buffer_path);
-	return doSubstitution(params, buffer, s, filename);
-}
-
 namespace {
 
 // Empty template, specialised below.