X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FExternalSupport.C;h=d84baf75069b5a48e9ec22d0d8544259387f86d4;hb=e28331ed63062dea10d0a21b9ec12034b4b17b9a;hp=0ae746b5745c600ebdeabd7b193b00b6af98987a;hpb=1e8ce6117746cf80d0e495c797c12092d641f9f0;p=lyx.git diff --git a/src/insets/ExternalSupport.C b/src/insets/ExternalSupport.C index 0ae746b574..d84baf7506 100644 --- a/src/insets/ExternalSupport.C +++ b/src/insets/ExternalSupport.C @@ -12,32 +12,34 @@ #include #include "ExternalSupport.h" +#include "ExternalTemplate.h" +#include "ExternalTransforms.h" #include "insetexternal.h" #include "buffer.h" #include "converter.h" #include "debug.h" -#include "ExternalTemplate.h" +#include "exporter.h" +#include "format.h" +#include "mover.h" #include "support/filetools.h" #include "support/forkedcall.h" #include "support/lstrings.h" #include "support/lyxalgo.h" #include "support/lyxlib.h" -#include "support/path.h" -#include "support/path_defines.h" - -#include "support/std_ostream.h" - - -namespace support = lyx::support; +#include "support/os.h" +#include "support/package.h" using std::endl; using std::string; -using std::ostream; +using std::vector; namespace lyx { + +using support::FileName; + namespace external { Template const * getTemplatePtr(InsetExternalParams const & params) @@ -49,42 +51,115 @@ Template const * getTemplatePtr(InsetExternalParams const & params) void editExternal(InsetExternalParams const & params, Buffer const & buffer) { - external::Template const * const et_ptr = - external::getTemplatePtr(params); - if (!et_ptr) - return; - external::Template const & et = *et_ptr; + formats.edit(buffer, params.filename, + formats.getFormatFromFile(params.filename)); +} - if (et.editCommand.empty()) - return; - string const command = doSubstitution(params, buffer, et.editCommand); +namespace { - 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 subst_path(string const & input, + string const & placeholder, + string const & path, + bool use_latex_path, + support::latex_path_extension ext = support::PROTECT_EXTENSION, + support::latex_path_dots dots = support::LEAVE_DOTS) +{ + if (input.find(placeholder) == string::npos) + return input; + // Don't use external_path here when use_latex_path is false, as the + // path will be compared with another one in internal style later + // in Converters::move. + string const path2 = use_latex_path ? + support::latex_path(path, ext, dots) : path; + return support::subst(input, placeholder, path2); } +} // namespace anon -namespace { string const doSubstitution(InsetExternalParams const & params, Buffer const & buffer, string const & s, - string const & filename) + bool use_latex_path, + bool external_in_tmpdir, + Substitute what) { - string result; - string const basename = support::ChangeExtension(filename, string()); - string const filepath = support::OnlyPath(filename); + 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 const basename = support::changeExtension( + support::onlyFilename(filename), string()); + string const absname = support::makeAbsPath(filename, parentpath).absFilename(); + + string result = s; + if (what != ALL_BUT_PATHS) { + 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 = subst_path(result, "$$FPath", filepath, + use_latex_path, + support::PROTECT_EXTENSION, + support::ESCAPE_DOTS); + result = subst_path(result, "$$AbsPath", abspath, + use_latex_path, + support::PROTECT_EXTENSION, + support::ESCAPE_DOTS); + result = subst_path(result, "$$RelPathMaster", + relToMasterPath, use_latex_path, + support::PROTECT_EXTENSION, + support::ESCAPE_DOTS); + result = subst_path(result, "$$RelPathParent", + relToParentPath, use_latex_path, + support::PROTECT_EXTENSION, + support::ESCAPE_DOTS); + if (support::absolutePath(filename)) { + result = subst_path(result, "$$AbsOrRelPathMaster", + abspath, use_latex_path, + support::PROTECT_EXTENSION, + support::ESCAPE_DOTS); + result = subst_path(result, "$$AbsOrRelPathParent", + abspath, use_latex_path, + support::PROTECT_EXTENSION, + support::ESCAPE_DOTS); + } else { + result = subst_path(result, "$$AbsOrRelPathMaster", + relToMasterPath, use_latex_path, + support::PROTECT_EXTENSION, + support::ESCAPE_DOTS); + result = subst_path(result, "$$AbsOrRelPathParent", + relToParentPath, use_latex_path, + support::PROTECT_EXTENSION, + support::ESCAPE_DOTS); + } + } + + if (what == PATHS) + return result; - result = support::subst(s, "$$FName", filename); - result = support::subst(result, "$$Basename", basename); - result = support::subst(result, "$$FPath", filepath); - result = support::subst(result, "$$Tempname", params.tempname()); - result = support::subst(result, "$$Sysdir", support::system_lyxdir()); + result = subst_path(result, "$$FName", filename, use_latex_path, + support::EXCLUDE_EXTENSION); + result = subst_path(result, "$$Basename", basename, use_latex_path, + support::PROTECT_EXTENSION, support::ESCAPE_DOTS); + result = subst_path(result, "$$Extension", + '.' + support::getExtension(filename), use_latex_path); + result = subst_path(result, "$$Tempname", params.tempname().absFilename(), use_latex_path); + result = subst_path(result, "$$Sysdir", + support::package().system_support(), use_latex_path); // Handle the $$Contents(filename) syntax if (support::contains(result, "$$Contents(\"")) { @@ -94,12 +169,10 @@ string const doSubstitution(InsetExternalParams const & params, string const file = result.substr(pos + 12, end - (pos + 12)); string contents; - string const filepath = support::IsFileReadable(file) ? - buffer.filePath() : buffer.temppath(); - support::Path p(filepath); - - if (support::IsFileReadable(file)) - contents = support::GetFileContents(file); + FileName const absfile( + support::makeAbsPath(file, m_buffer->temppath())); + if (support::isFileReadable(absfile)) + contents = support::getFileContents(absfile); result = support::subst(result, ("$$Contents(\"" + file + "\")").c_str(), @@ -109,30 +182,32 @@ 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. + If \p external_in_tmpdir == true, then the generated file is + placed in the buffer's temporary directory. */ void updateExternal(InsetExternalParams const & params, string const & format, Buffer const & buffer, + ExportData & exportdata, bool external_in_tmpdir) { - external::Template const * const et_ptr = - external::getTemplatePtr(params); + Template const * const et_ptr = getTemplatePtr(params); if (!et_ptr) return; // FAILURE - external::Template const & et = *et_ptr; + Template const & et = *et_ptr; if (!et.automaticProduction) return; // NOT_NEEDED - external::Template::Formats::const_iterator cit = - et.formats.find(format); + Template::Formats::const_iterator cit = et.formats.find(format); if (cit == et.formats.end()) return; // FAILURE - external::Template::Format const & outputFormat = cit->second; + Template::Format const & outputFormat = cit->second; if (outputFormat.updateResult.empty()) return; // NOT_NEEDED @@ -140,82 +215,128 @@ void updateExternal(InsetExternalParams const & params, if (from_format.empty()) return; // NOT_NEEDED - string from_file = params.filename.absFilename(); - if (from_format == "*") { - if (from_file.empty()) + if (params.filename.empty()) return; // NOT_NEEDED // Try and ascertain the file format from its contents. - from_format = support::getExtFromContents(from_file); + from_format = formats.getFormatFromFile(params.filename); if (from_format.empty()) return; // FAILURE + } string const to_format = outputFormat.updateFormat; if (to_format.empty()) return; // NOT_NEEDED - if (!converters.isReachable(from_format, to_format)) { + if (!theConverters().isReachable(from_format, to_format)) { lyxerr[Debug::EXTERNAL] - << "InsetExternal::updateExternal. " + << "external::updateExternal. " << "Unable to convert from " << from_format << " to " << to_format << endl; return; // FAILURE } - if (external_in_tmpdir && !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); + // The master buffer. This is useful when there are multiple levels + // of include files + Buffer const * m_buffer = buffer.getMasterBuffer(); + + // We copy the source file to the temp dir and do the conversion + // there if necessary + FileName const temp_file( + support::makeAbsPath(params.filename.mangledFilename(), + m_buffer->temppath())); + if (!params.filename.empty()) { + unsigned long const from_checksum = support::sum(params.filename); unsigned long const temp_checksum = support::sum(temp_file); if (from_checksum != temp_checksum) { - if (!support::copy(from_file, temp_file)) + Mover const & mover = getMover(from_format); + if (!mover.copy(params.filename, temp_file)) { + lyxerr[Debug::EXTERNAL] + << "external::updateExternal. " + << "Unable to copy " + << params.filename << " to " << temp_file << endl; return; // FAILURE + } } - - from_file = temp_file; } + // the generated file (always in the temp dir) string const to_file = doSubstitution(params, buffer, outputFormat.updateResult, - from_file); - - string const abs_to_file = - support::MakeAbsPath(to_file, buffer.filePath()); + false, true); + FileName const abs_to_file( + support::makeAbsPath(to_file, m_buffer->temppath())); + + // Record the referenced files for the exporter. + // The exporter will copy them to the export dir. + typedef Template::Format::FileMap FileMap; + FileMap::const_iterator rit = outputFormat.referencedFiles.begin(); + FileMap::const_iterator rend = outputFormat.referencedFiles.end(); + for (; rit != rend; ++rit) { + vector::const_iterator fit = rit->second.begin(); + vector::const_iterator fend = rit->second.end(); + for (; fit != fend; ++fit) { + FileName const source(support::makeAbsPath( + doSubstitution(params, buffer, *fit, + false, true), + m_buffer->temppath())); + // The path of the referenced file is never the + // temp path, but the filename may be the mangled + // or the real name. Therefore we substitute the + // paths and names separately. + string file = support::subst(*fit, "$$FName", + "$$FPath$$Basename$$Extension"); + file = doSubstitution(params, buffer, file, false, false, + PATHS); + file = doSubstitution(params, buffer, file, + false, external_in_tmpdir, + ALL_BUT_PATHS); + // if file is a relative name, it is interpreted + // relative to the master document. + exportdata.addExternalFile(rit->first, source, 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(temp_file, abs_to_file) < 0) return; // SUCCESS - string const to_file_base = - support::ChangeExtension(to_file, string()); + // FIXME (Abdel 12/08/06): Is there a need to show these errors? + ErrorList el; /* bool const success = */ - converters.convert(&buffer, from_file, to_file_base, - from_format, to_format); + theConverters().convert(&buffer, temp_file, abs_to_file, + params.filename, from_format, to_format, el, + Converters::try_default | Converters::try_cache); // return success } + +string const substituteCommands(InsetExternalParams const & params, + string const & input, string const & format); + +string const substituteOptions(InsetExternalParams const & params, + string const & input, string const & format); + } // namespace anon int writeExternal(InsetExternalParams const & params, string const & format, - Buffer const & buffer, ostream & os, - bool external_in_tmpdir) + Buffer const & buffer, odocstream & os, + ExportData & exportdata, + bool external_in_tmpdir, + bool external_in_comment) { - external::Template const * const et_ptr = - external::getTemplatePtr(params); + Template const * const et_ptr = getTemplatePtr(params); if (!et_ptr) return 0; - external::Template const & et = *et_ptr; + Template const & et = *et_ptr; - external::Template::Formats::const_iterator cit = - et.formats.find(format); + Template::Formats::const_iterator cit = et.formats.find(format); if (cit == et.formats.end()) { lyxerr[Debug::EXTERNAL] << "External template format '" << format @@ -224,31 +345,171 @@ int writeExternal(InsetExternalParams const & params, return 0; } - updateExternal(params, format, buffer, external_in_tmpdir); + if (!external_in_comment) + updateExternal(params, format, buffer, exportdata, + external_in_tmpdir); + + bool const use_latex_path = format == "LaTeX"; + string str = doSubstitution(params, buffer, cit->second.product, + use_latex_path, external_in_tmpdir); + str = substituteCommands(params, str, format); + str = substituteOptions(params, str, format); + // FIXME UNICODE + os << from_utf8(str); + return int(lyx::count(str.begin(), str.end(),'\n')); +} + +namespace { - 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()); +// Empty template, specialised below. +template +string const substituteIt(string const &, + TransformID, + string const &, + Template::Format const &, + InsetExternalParams const &); + + +template <> +string const substituteIt(string const & input, + TransformID id, + string const & /* formatname */, + Template::Format const & format, + InsetExternalParams const & params) +{ + typedef std::map Transformers; + Transformers::const_iterator it = format.command_transformers.find(id); + if (it == format.command_transformers.end()) + return input; + + TransformStore const & store = it->second; + + TransformCommand::ptr_type ptr; + if (id == Rotate) + ptr = store.getCommandTransformer(params.rotationdata); + else if (id == Resize) + ptr = store.getCommandTransformer(params.resizedata); + + if (!ptr.get()) + return input; + + string result = + support::subst(input, ptr->front_placeholder(), ptr->front()); + return support::subst(result, ptr->back_placeholder(), ptr->back()); +} + + +template <> +string const substituteIt(string const & input, + TransformID id, + string const & fname, + Template::Format const & format, + InsetExternalParams const & params) +{ + typedef std::map Transformers; + Transformers::const_iterator it = format.option_transformers.find(id); + if (it == format.option_transformers.end()) + return input; + + TransformStore const & store = it->second; + + TransformOption::ptr_type ptr; + switch (id) { + case Clip: + ptr = store.getOptionTransformer(params.clipdata); + break; + case Extra: + ptr = store.getOptionTransformer(params.extradata.get(fname)); + break; + case Rotate: + ptr = store.getOptionTransformer(params.rotationdata); + break; + case Resize: + ptr = store.getOptionTransformer(params.resizedata); + break; } - - string const str = doSubstitution(params, buffer, cit->second.product, - from_file); - os << str; - return int(lyx::count(str.begin(), str.end(),'\n') + 1); + + if (!ptr.get()) + return input; + + return support::subst(input, ptr->placeholder(), ptr->option()); } -/// Substitute meta-variables in this string -string const doSubstitution(InsetExternalParams const & params, - Buffer const & buffer, string const & s) +template +string const transformIt(InsetExternalParams const & params, + string const & s, string const & formatname) +{ + Template const * const et = getTemplatePtr(params); + if (!et || et->transformIds.empty()) + return s; + + Template::Formats::const_iterator fit = et->formats.find(formatname); + if (fit == et->formats.end()) + return s; + + string result = s; + Template::Format const & format = fit->second; + + typedef vector TransformsIDs; + TransformsIDs::const_iterator it = et->transformIds.begin(); + TransformsIDs::const_iterator end = et->transformIds.end(); + for (; it != end; ++it) { + result = substituteIt(result, *it, formatname, + format, params); + } + return result; +} + + +string const substituteCommands(InsetExternalParams const & params, + string const & input, string const & format) +{ + return transformIt(params, input, format); +} + + +string const substituteOption(InsetExternalParams const & params, + string const & input, string const & format) +{ + string opt = transformIt(params, input, format); + + if (format == "LaTeX" || format == "PDFLaTeX") + return sanitizeLatexOption(opt); + if (format == "DocBook") + return sanitizeDocBookOption(opt); + return opt; +} + + +string const substituteOptions(InsetExternalParams const & params, + string const & input, string const & format) { - string const buffer_path = buffer.filePath(); - string const filename = params.filename.outputFilename(buffer_path); - return doSubstitution(params, buffer, s, filename); + string output = input; + + Template const * const et = getTemplatePtr(params); + if (!et || et->transformIds.empty()) + return output; + + Template::Formats::const_iterator fit = et->formats.find(format); + if (fit == et->formats.end() || fit->second.options.empty()) + return output; + + typedef vector Options; + Options const & options = fit->second.options; + Options::const_iterator it = options.begin(); + Options::const_iterator end = options.end(); + for (; it != end; ++it) { + string const opt = substituteOption(params, it->option, format); + string const placeholder = "$$" + it->name; + output = support::subst(output, placeholder, opt); + } + + return output; } +} // namespace anon + } // namespace external + } // namespace lyx