-/* This file is part of
- * ======================================================
- *
- * LyX, The Document Processor
- *
- * Copyright 1995 Matthias Ettrich
- * Copyright 1995-2000 The LyX Team.
+/**
+ * \file ExternalTemplate.C
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
*
- * ====================================================== */
+ * \author Asger Alstrup Nielsen
+ * \author Angus Leeming
+ *
+ * Full author contact details are available in file CREDITS.
+ */
#include <config.h>
-#ifdef __GNUG__
-#pragma implementation
-#endif
-
-#include <algorithm>
-
#include "ExternalTemplate.h"
+#include "debug.h"
#include "lyxlex.h"
+
+#include "support/filetools.h"
+#include "support/lstrings.h"
+#include "support/package.h"
#include "support/path.h"
-#include "support/LAssert.h"
+
+namespace support = lyx::support;
using std::endl;
-using std::ostream;
using std::for_each;
-extern string user_lyxdir;
+using std::string;
+using std::ostream;
+using std::vector;
+
+namespace lyx {
+namespace external {
-// We have to have dummy default commands for security reasons!
+namespace {
-ExternalTemplate::ExternalTemplate()
- : viewCommand("true"), editCommand("true")
+typedef Translator<TransformID, string> TransformIDTranslator;
+TransformIDTranslator const & transformIDTranslator();
+
+} // namespace anon
+
+
+// We have to have dummy default commands for security reasons!
+Template::Template()
+ : inputFormat("*")
{}
-ExternalTemplate::FormatTemplate::FormatTemplate()
- : updateCommand("true") {}
+Template::Format::Format()
+{}
-ExternalTemplateManager::ExternalTemplateManager()
+TemplateManager::TemplateManager()
{
- // gimp gnuchess gnuplot ical netscape tetris xpaint
- readTemplates(user_lyxdir);
- dumpTemplates();
+ readTemplates(support::package().user_support());
+ if (lyxerr.debugging(Debug::EXTERNAL)) {
+ dumpPreambleDefs(lyxerr);
+ lyxerr << '\n';
+ dumpTemplates(lyxerr);
+ }
}
+class dumpPreambleDef {
+public:
+ typedef TemplateManager::PreambleDefs::value_type value_type;
+
+ dumpPreambleDef(ostream & o) : ost(o) {}
+
+ void operator()(value_type const & vt) {
+ ost << "PreambleDef " << vt.first << '\n'
+ << vt.second
+ << "PreambleDefEnd" << endl;
+ }
+
+private:
+ ostream & ost;
+};
+
+
class dumpTemplate {
public:
- dumpTemplate(std::ostream & o)
- : ost(o) {}
- void operator()(ExternalTemplateManager::Templates::value_type const & vt) {
- ExternalTemplate const & et = vt.second;
-
- ost << "Template " << et.lyxName << "\n"
- << "\tGuiName " << et.guiName << "\n"
+ typedef TemplateManager::Templates::value_type value_type;
+
+ dumpTemplate(ostream & o) : ost(o) {}
+
+ void operator()(value_type const & vt) {
+ Template const & et = vt.second;
+
+ ost << "Template " << et.lyxName << '\n'
+ << "\tGuiName " << et.guiName << '\n'
<< "\tHelpText\n"
<< et.helpText
<< "\tHelpTextEnd\n"
- << "\tFileFilter " << et.fileRegExp << "\n"
- << "\tViewCommand " << et.viewCommand << "\n"
- << "\tEditCommand " << et.editCommand << "\n"
- << "\tAutomaticProduction " << et.automaticProduction << "\n";
+ << "\tInputFormat " << et.inputFormat << '\n'
+ << "\tFileFilter " << et.fileRegExp << '\n'
+ << "\tAutomaticProduction " << et.automaticProduction << '\n';
+
+ typedef vector<TransformID> IDs;
+ IDs::const_iterator it = et.transformIds.begin();
+ IDs::const_iterator end = et.transformIds.end();
+ for (; it != end; ++it) {
+ ost << "\tTransform "
+ << transformIDTranslator().find(*it) << '\n';
+ }
+
et.dumpFormats(ost);
ost << "TemplateEnd" << endl;
-
+
}
private:
class dumpFormat {
public:
- dumpFormat(ostream & o)
- : ost(o) {}
- void operator()(ExternalTemplate::Formats::value_type const & vt) const{
- ExternalTemplate::FormatTemplate const & ft = vt.second;
- ost << "\tFormat " << vt.first << "\n"
- << "\t\tProduct " << ft.product << "\n"
- << "\t\tUpdateCommand " << ft.updateCommand << "\n"
- << "\t\tRequirement " << ft.requirement << "\n"
- << "\t\tPreamble\n"
- << ft.preamble
- << "\t\tPreambleEnd\n"
- << "\tFormatEnd\n";
+ typedef Template::Formats::value_type value_type;
+
+ dumpFormat(ostream & o) : ost(o) {}
+
+ void operator()(value_type const & vt) const {
+ Template::Format const & ft = vt.second;
+ ost << "\tFormat " << vt.first << '\n'
+ << "\t\tProduct " << ft.product << '\n'
+ << "\t\tUpdateFormat " << ft.updateFormat << '\n'
+ << "\t\tUpdateResult " << ft.updateResult << '\n'
+ << "\t\tRequirement " << ft.requirement << '\n';
+
+ typedef vector<Template::Option> Options;
+ Options::const_iterator oit = ft.options.begin();
+ Options::const_iterator oend = ft.options.end();
+ for (; oit != oend; ++oit) {
+ ost << "\t\tOption "
+ << oit->name
+ << ": "
+ << oit->option
+ << '\n';
+ }
+
+ vector<string>::const_iterator pit = ft.preambleNames.begin();
+ vector<string>::const_iterator pend = ft.preambleNames.end();
+ for (; pit != pend; ++pit) {
+ ost << "\t\tPreamble " << *pit << '\n';
+ }
+
+ typedef Template::Format::FileMap FileMap;
+ FileMap::const_iterator rit = ft.referencedFiles.begin();
+ FileMap::const_iterator rend = ft.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) {
+ ost << "\t\tReferencedFile " << rit->first
+ << " \"" << *fit << "\"\n";
+ }
+ }
+
+ ost << "\tFormatEnd\n";
}
private:
ostream & ost;
};
-void ExternalTemplate::dumpFormats(ostream & os) const
+void Template::dumpFormats(ostream & os) const
{
for_each(formats.begin(), formats.end(), dumpFormat(os));
}
-void ExternalTemplateManager::dumpTemplates() const
+void TemplateManager::dumpPreambleDefs(ostream & os) const
+{
+ for_each(preambledefs.begin(), preambledefs.end(), dumpPreambleDef(os));
+}
+
+
+void TemplateManager::dumpTemplates(ostream & os) const
{
- for_each(templates.begin(), templates.end(), dumpTemplate(lyxerr));
+ for_each(templates.begin(), templates.end(), dumpTemplate(os));
}
-ExternalTemplateManager & ExternalTemplateManager::get()
+TemplateManager & TemplateManager::get()
{
- static ExternalTemplateManager externalTemplateManager;
+ static TemplateManager externalTemplateManager;
return externalTemplateManager;
}
-ExternalTemplateManager::Templates &
-ExternalTemplateManager::getTemplates()
+TemplateManager::Templates const &
+TemplateManager::getTemplates() const
{
return templates;
}
-ExternalTemplateManager::Templates const &
-ExternalTemplateManager::getTemplates() const
+Template const *
+TemplateManager::getTemplateByName(string const & name) const
{
- return templates;
+ Templates::const_iterator it = templates.find(name);
+ return (it == templates.end()) ? 0 : &it->second;
+}
+
+
+string const
+TemplateManager::getPreambleDefByName(string const & name) const
+{
+ string const trimmed_name = support::trim(name);
+ if (trimmed_name.empty())
+ return string();
+
+ PreambleDefs::const_iterator it = preambledefs.find(trimmed_name);
+ if (it == preambledefs.end())
+ return string();
+
+ return it->second;
}
-void ExternalTemplateManager::readTemplates(string const & path)
+void TemplateManager::readTemplates(string const & path)
{
- Path p(path);
+ support::Path p(path);
enum TemplateTags {
- TM_TEMPLATE = 1,
- TM_END
+ TM_PREAMBLEDEF = 1,
+ TM_PREAMBLEDEF_END,
+ TM_TEMPLATE,
+ TM_TEMPLATE_END
};
-
+
keyword_item templatetags[] = {
+ { "preambledef", TM_PREAMBLEDEF },
+ { "preambledefend", TM_PREAMBLEDEF_END },
{ "template", TM_TEMPLATE },
- { "templateend", TM_END }
+ { "templateend", TM_TEMPLATE_END }
};
- string filename = LibFileSearch("", "external_templates");
- if (filename.empty()) {
- lyxerr << "No template file" << endl;
- return;
- }
+ LyXLex lex(templatetags, TM_TEMPLATE_END);
- LyXLex lex(templatetags, TM_END);
- if (!lex.setFile(filename)) {
- lyxerr << "No template file" << endl;
+ string filename = support::LibFileSearch("", "external_templates");
+ if (filename.empty() || !lex.setFile(filename)) {
+ lex.printError("external::TemplateManager::readTemplates: "
+ "No template file");
return;
}
-
- while (lex.IsOK()) {
- switch(lex.lex()) {
+
+ char const * const preamble_end_tag =
+ templatetags[TM_PREAMBLEDEF_END-1].tag;
+
+ while (lex.isOK()) {
+ switch (lex.lex()) {
+ case TM_PREAMBLEDEF: {
+ lex.next();
+ string const name = lex.getString();
+ preambledefs[name] = lex.getLongString(preamble_end_tag);
+ }
+ break;
+
case TM_TEMPLATE: {
lex.next();
- string temp = lex.GetString();
- ExternalTemplate & tmp = templates[temp];
- tmp.lyxName = temp;
+ string const name = lex.getString();
+ Template & tmp = templates[name];
+ tmp.lyxName = name;
tmp.readTemplate(lex);
}
break;
-
- case TM_END:
- lyxerr << "TemplateEnd: " << lex.GetString() << endl;
- lyxerr << "Warning: End outside Template." << endl;
+
+ case TM_TEMPLATE_END:
+ lex.printError("Warning: End outside Template.");
+ break;
+
+ case TM_PREAMBLEDEF_END:
+ lex.printError("Warning: End outside PreambleDef.");
break;
}
}
}
-void ExternalTemplate::readTemplate(LyXLex & lex)
+namespace {
+
+void add(vector<TransformID> & ids, string const & name)
+{
+ TransformID id = transformIDTranslator().find(name);
+ if (int(id) == -1) {
+ lyxerr << "external::Template::readTemplate\n"
+ << "Transform " << name << " is not recognized"
+ << std::endl;
+ } else {
+ ids.push_back(id);
+ }
+}
+
+} // namespace anon
+
+
+void Template::readTemplate(LyXLex & lex)
{
enum TemplateOptionTags {
TO_GUINAME = 1,
TO_HELPTEXT,
+ TO_INPUTFORMAT,
TO_FILTER,
- TO_VIEWCMD,
- TO_EDITCMD,
TO_AUTOMATIC,
+ TO_TRANSFORM,
TO_FORMAT,
TO_END
};
keyword_item templateoptiontags[] = {
{ "automaticproduction", TO_AUTOMATIC },
- { "editcommand", TO_EDITCMD },
{ "filefilter", TO_FILTER },
{ "format", TO_FORMAT },
{ "guiname", TO_GUINAME },
{ "helptext", TO_HELPTEXT },
+ { "inputformat", TO_INPUTFORMAT },
{ "templateend", TO_END },
- { "viewcommand", TO_VIEWCMD }
+ { "transform", TO_TRANSFORM }
};
pushpophelper pph(lex, templateoptiontags, TO_END);
-
- while (lex.IsOK()) {
+
+ while (lex.isOK()) {
switch (lex.lex()) {
case TO_GUINAME:
lex.next(true);
- guiName = lex.GetString();
+ guiName = lex.getString();
break;
-
+
case TO_HELPTEXT:
helpText = lex.getLongString("HelpTextEnd");
break;
-
- case TO_FILTER:
- lex.next(true);
- fileRegExp = lex.GetString();
- break;
-
- case TO_VIEWCMD:
+
+ case TO_INPUTFORMAT:
lex.next(true);
- viewCommand = lex.GetString();
- // For security reasons, a command may not be empty!
- if (viewCommand.empty())
- viewCommand = "true";
+ inputFormat = lex.getString();
break;
-
- case TO_EDITCMD:
+
+ case TO_FILTER:
lex.next(true);
- editCommand = lex.GetString();
- // For security reasons, a command may not be empty!
- if (editCommand.empty())
- editCommand = "true";
+ fileRegExp = lex.getString();
break;
-
+
case TO_AUTOMATIC:
lex.next();
- automaticProduction = lex.GetBool();
+ automaticProduction = lex.getBool();
+ break;
+
+ case TO_TRANSFORM:
+ lex.next(true);
+ add(transformIds, lex.getString());
break;
-
+
case TO_FORMAT:
lex.next(true);
- formats[lex.GetString()].readFormat(lex);
+ formats[lex.getString()].readFormat(lex);
break;
-
+
case TO_END:
return;
-
+
default:
- lyxerr << "Default: " << lex.GetString() << endl;
- Assert(false);
+ lex.printError("external::Template::readTemplate: "
+ "Wrong tag: $$Token");
+ BOOST_ASSERT(false);
break;
}
}
}
-void ExternalTemplate::FormatTemplate::readFormat(LyXLex & lex)
+namespace {
+
+void transform_not_found(std::ostream & os, string const & transform)
+{
+ os << "external::Format::readFormat. Transformation \""
+ << transform << "\" is unrecognized." << std::endl;
+}
+
+
+void transform_class_not_found(std::ostream & os, string const & tclass)
+{
+ os << "external::Format::readFormat. Transformation class \""
+ << tclass << "\" is unrecognized." << std::endl;
+}
+
+
+void setCommandFactory(Template::Format & format, string const & transform,
+ string const & transformer_class)
+{
+ bool class_found = false;
+ if (transform == "Resize" && transformer_class == "ResizeLatexCommand") {
+ class_found = true;
+ ResizeCommandFactory factory = ResizeLatexCommand::factory;
+ format.command_transformers[Resize] =
+ TransformStore(Resize, factory);
+
+ } else if (transform == "Rotate" &&
+ transformer_class == "RotationLatexCommand") {
+ class_found = true;
+ RotationCommandFactory factory = RotationLatexCommand::factory;
+ format.command_transformers[Rotate] =
+ TransformStore(Rotate, factory);
+
+ } else
+ transform_not_found(lyxerr, transform);
+
+ if (!class_found)
+ transform_class_not_found(lyxerr, transformer_class);
+}
+
+
+void setOptionFactory(Template::Format & format, string const & transform,
+ string const & transformer_class)
+{
+ bool class_found = false;
+ if (transform == "Clip" && transformer_class == "ClipLatexOption") {
+ class_found = true;
+ ClipOptionFactory factory = ClipLatexOption::factory;
+ format.option_transformers[Clip] =
+ TransformStore(Clip, factory);
+
+ } else if (transform == "Extra" && transformer_class == "ExtraOption") {
+ class_found = true;
+ ExtraOptionFactory factory = ExtraOption::factory;
+ format.option_transformers[Extra] =
+ TransformStore(Extra, factory);
+
+ } else if (transform == "Resize" &&
+ transformer_class == "ResizeLatexOption") {
+ class_found = true;
+ ResizeOptionFactory factory = ResizeLatexOption::factory;
+ format.option_transformers[Resize] =
+ TransformStore(Resize, factory);
+
+ } else if (transform == "Rotate" &&
+ transformer_class == "RotationLatexOption") {
+ class_found = true;
+ RotationOptionFactory factory = RotationLatexOption::factory;
+ format.option_transformers[Rotate] =
+ TransformStore(Rotate, factory);
+
+ } else
+ transform_not_found(lyxerr, transform);
+
+ if (!class_found)
+ transform_class_not_found(lyxerr, transformer_class);
+}
+
+} // namespace anon
+
+
+void Template::Format::readFormat(LyXLex & lex)
{
enum FormatTags {
FO_PRODUCT = 1,
- FO_UPDATECMD,
+ FO_UPDATEFORMAT,
+ FO_UPDATERESULT,
FO_REQUIREMENT,
+ FO_OPTION,
FO_PREAMBLE,
+ FO_TRANSFORMCOMMAND,
+ FO_TRANSFORMOPTION,
+ FO_REFERENCEDFILE,
FO_END
};
-
+
keyword_item formattags[] = {
{ "formatend", FO_END },
+ { "option", FO_OPTION },
{ "preamble", FO_PREAMBLE },
{ "product", FO_PRODUCT },
+ { "referencedfile", FO_REFERENCEDFILE },
{ "requirement", FO_REQUIREMENT },
- { "updatecommand", FO_UPDATECMD }
+ { "transformcommand", FO_TRANSFORMCOMMAND },
+ { "transformoption", FO_TRANSFORMOPTION },
+ { "updateformat", FO_UPDATEFORMAT },
+ { "updateresult", FO_UPDATERESULT }
};
pushpophelper pph(lex, formattags, FO_END);
-
- while (lex.IsOK()) {
- switch(lex.lex()) {
+
+ while (lex.isOK()) {
+ switch (lex.lex()) {
case FO_PRODUCT:
lex.next(true);
- product = lex.GetString();
+ product = lex.getString();
+ break;
+
+ case FO_UPDATEFORMAT:
+ lex.next(true);
+ updateFormat = lex.getString();
break;
-
- case FO_UPDATECMD:
+
+ case FO_UPDATERESULT:
lex.next(true);
- updateCommand = lex.GetString();
- // For security reasons, a command may not be empty!
- if (updateCommand.empty())
- updateCommand = "true";
+ updateResult = lex.getString();
break;
-
+
case FO_REQUIREMENT:
lex.next(true);
- requirement = lex.GetString();
+ requirement = lex.getString();
break;
-
+
case FO_PREAMBLE:
- preamble = lex.getLongString("preambleend");
+ lex.next(true);
+ preambleNames.push_back(lex.getString());
+ break;
+
+ case FO_TRANSFORMCOMMAND: {
+ lex.next(true);
+ string const name = lex.getString();
+ lex.next(true);
+ setCommandFactory(*this, name, lex.getString());
break;
-
+ }
+
+ case FO_TRANSFORMOPTION: {
+ lex.next(true);
+ string const name = lex.getString();
+ lex.next(true);
+ setOptionFactory(*this, name, lex.getString());
+ break;
+ }
+
+ case FO_OPTION: {
+ lex.next(true);
+ string const name = lex.getString();
+ lex.next(true);
+ string const opt = lex.getString();
+ options.push_back(Option(name, opt));
+ break;
+ }
+
+ case FO_REFERENCEDFILE: {
+ lex.next(true);
+ string const format = lex.getString();
+ lex.next(true);
+ string const file = lex.getString();
+ referencedFiles[format].push_back(file);
+ break;
+ }
+
case FO_END:
- lyxerr << "FormatEnd: " << lex.GetString() << endl;
return;
}
}
}
+namespace {
+
+TransformIDTranslator const initIDTranslator()
+{
+ TransformIDTranslator translator(TransformID(-1), "");
+ translator.addPair(Rotate, "Rotate");
+ translator.addPair(Resize, "Resize");
+ translator.addPair(Clip, "Clip");
+ translator.addPair(Extra, "Extra");
+ return translator;
+}
+
+
+TransformIDTranslator const & transformIDTranslator()
+{
+ static TransformIDTranslator const translator = initIDTranslator();
+ return translator;
+}
+
+} // namespace anon
+
+} // namespace external
+} // namespace lyx
projects / lyx.git / blobdiff