#include "buffer.h"
#include "converter.h"
#include "debug.h"
+#include "exporter.h"
+#include "format.h"
#include "support/filetools.h"
#include "support/forkedcall.h"
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());
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))
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.
void updateExternal(InsetExternalParams const & params,
string const & format,
Buffer const & buffer,
+ ExportData & exportdata,
bool external_in_tmpdir)
{
Template const * const et_ptr = getTemplatePtr(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;
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
}
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);
return 0;
}
- updateExternal(params, format, buffer, external_in_tmpdir);
+ updateExternal(params, format, buffer, exportdata, 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());
- }
-
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.
projects / lyx.git / blobdiff