X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FExternalTemplate.C;h=197667759426db5dd075d07a37e8ec985710ae39;hb=b5589bf6cf82439dc8dcc6c9465ce3b32dc0f389;hp=7a89cc1a4652e363fd02e6e957620e683d8d955b;hpb=36439eab2195da89b84bd77fd2b829c8daacaef7;p=lyx.git diff --git a/src/insets/ExternalTemplate.C b/src/insets/ExternalTemplate.C index 7a89cc1a46..1976677594 100644 --- a/src/insets/ExternalTemplate.C +++ b/src/insets/ExternalTemplate.C @@ -4,6 +4,7 @@ * 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. */ @@ -16,35 +17,44 @@ #include "lyxlex.h" #include "support/filetools.h" -#include "support/LAssert.h" #include "support/lstrings.h" +#include "support/package.h" #include "support/path.h" -#include "support/path_defines.h" - -#include namespace support = lyx::support; using std::endl; using std::for_each; + +using std::string; using std::ostream; +using std::vector; -// We have to have dummy default commands for security reasons! +namespace lyx { +namespace external { + +namespace { + +typedef Translator TransformIDTranslator; +TransformIDTranslator const & transformIDTranslator(); + +} // namespace anon -ExternalTemplate::ExternalTemplate() + +// We have to have dummy default commands for security reasons! +Template::Template() : inputFormat("*") {} -ExternalTemplate::FormatTemplate::FormatTemplate() +Template::Format::Format() {} -ExternalTemplateManager::ExternalTemplateManager() +TemplateManager::TemplateManager() { - // gimp gnuchess gnuplot ical netscape tetris xpaint - readTemplates(support::user_lyxdir()); + readTemplates(support::package().user_support()); if (lyxerr.debugging(Debug::EXTERNAL)) { dumpPreambleDefs(lyxerr); lyxerr << '\n'; @@ -55,7 +65,7 @@ ExternalTemplateManager::ExternalTemplateManager() class dumpPreambleDef { public: - typedef ExternalTemplateManager::PreambleDefs::value_type value_type; + typedef TemplateManager::PreambleDefs::value_type value_type; dumpPreambleDef(ostream & o) : ost(o) {} @@ -72,12 +82,12 @@ private: class dumpTemplate { public: - typedef ExternalTemplateManager::Templates::value_type value_type; + typedef TemplateManager::Templates::value_type value_type; dumpTemplate(ostream & o) : ost(o) {} void operator()(value_type const & vt) { - ExternalTemplate const & et = vt.second; + Template const & et = vt.second; ost << "Template " << et.lyxName << '\n' << "\tGuiName " << et.guiName << '\n' @@ -86,8 +96,16 @@ public: << "\tHelpTextEnd\n" << "\tInputFormat " << et.inputFormat << '\n' << "\tFileFilter " << et.fileRegExp << '\n' - << "\tEditCommand " << et.editCommand << '\n' << "\tAutomaticProduction " << et.automaticProduction << '\n'; + + typedef vector 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; @@ -99,72 +117,96 @@ private: class dumpFormat { public: - typedef ExternalTemplate::Formats::value_type value_type; + typedef Template::Formats::value_type value_type; dumpFormat(ostream & o) : ost(o) {} - void operator()(value_type const & vt) const{ - ExternalTemplate::FormatTemplate const & ft = vt.second; + 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' - << "\t\tPreamble " << ft.preambleName << '\n' - << "\tFormatEnd\n"; + << "\t\tRequirement " << ft.requirement << '\n'; + + typedef vector 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::const_iterator pit = ft.preambleNames.begin(); + vector::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::const_iterator fit = rit->second.begin(); + vector::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::dumpPreambleDefs(ostream & os) const +void TemplateManager::dumpPreambleDefs(ostream & os) const { for_each(preambledefs.begin(), preambledefs.end(), dumpPreambleDef(os)); } -void ExternalTemplateManager::dumpTemplates(ostream & os) const +void TemplateManager::dumpTemplates(ostream & os) const { 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() -{ - return templates; -} - - -ExternalTemplateManager::Templates const & -ExternalTemplateManager::getTemplates() const +TemplateManager::Templates const & +TemplateManager::getTemplates() const { return templates; } -ExternalTemplate const & ExternalTemplateManager::getTemplateByName(string const & name) +Template const * +TemplateManager::getTemplateByName(string const & name) const { - return templates[name]; + Templates::const_iterator it = templates.find(name); + return (it == templates.end()) ? 0 : &it->second; } string const -ExternalTemplateManager::getPreambleDefByName(string const & name) const +TemplateManager::getPreambleDefByName(string const & name) const { string const trimmed_name = support::trim(name); if (trimmed_name.empty()) @@ -178,7 +220,7 @@ ExternalTemplateManager::getPreambleDefByName(string const & name) const } -void ExternalTemplateManager::readTemplates(string const & path) +void TemplateManager::readTemplates(string const & path) { support::Path p(path); @@ -200,7 +242,7 @@ void ExternalTemplateManager::readTemplates(string const & path) string filename = support::LibFileSearch("", "external_templates"); if (filename.empty() || !lex.setFile(filename)) { - lex.printError("ExternalTemplateManager::readTemplates: " + lex.printError("external::TemplateManager::readTemplates: " "No template file"); return; } @@ -220,7 +262,7 @@ void ExternalTemplateManager::readTemplates(string const & path) case TM_TEMPLATE: { lex.next(); string const name = lex.getString(); - ExternalTemplate & tmp = templates[name]; + Template & tmp = templates[name]; tmp.lyxName = name; tmp.readTemplate(lex); } @@ -238,28 +280,45 @@ void ExternalTemplateManager::readTemplates(string const & path) } -void ExternalTemplate::readTemplate(LyXLex & lex) +namespace { + +void add(vector & 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_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 } + { "templateend", TO_END }, + { "transform", TO_TRANSFORM } }; pushpophelper pph(lex, templateoptiontags, TO_END); @@ -285,16 +344,16 @@ void ExternalTemplate::readTemplate(LyXLex & lex) fileRegExp = lex.getString(); break; - case TO_EDITCMD: - lex.next(true); - editCommand = lex.getString(); - break; - case TO_AUTOMATIC: lex.next(); 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); @@ -304,31 +363,120 @@ void ExternalTemplate::readTemplate(LyXLex & lex) return; default: - lex.printError("ExternalTemplate::readTemplate: " + lex.printError("external::Template::readTemplate: " "Wrong tag: $$Token"); - support::Assert(false); + 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_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 }, + { "transformcommand", FO_TRANSFORMCOMMAND }, + { "transformoption", FO_TRANSFORMOPTION }, { "updateformat", FO_UPDATEFORMAT }, { "updateresult", FO_UPDATERESULT } }; @@ -359,11 +507,69 @@ void ExternalTemplate::FormatTemplate::readFormat(LyXLex & lex) case FO_PREAMBLE: lex.next(true); - preambleName = lex.getString(); + 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: 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