-/* 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
+ *
+ * Full author contact details are available in file CREDITS
+ */
#include <config.h>
-#ifdef __GNUG__
-#pragma implementation
-#endif
#include <algorithm>
#include "ExternalTemplate.h"
#include "lyxlex.h"
+#include "debug.h"
#include "support/path.h"
#include "support/LAssert.h"
+#include "support/filetools.h"
+#include "support/path_defines.h"
+
+using namespace lyx::support;
using std::endl;
using std::ostream;
-
-extern string user_lyxdir;
-
+using std::for_each;
// We have to have dummy default commands for security reasons!
ExternalTemplate::ExternalTemplate()
- : viewCommand("true"), editCommand("true")
+ : inputFormat("*")
{}
+
ExternalTemplate::FormatTemplate::FormatTemplate()
- : updateCommand("true") {}
+{}
ExternalTemplateManager::ExternalTemplateManager()
{
// gimp gnuchess gnuplot ical netscape tetris xpaint
- readTemplates(user_lyxdir);
- dumpTemplates();
+ readTemplates(user_lyxdir());
+ if (lyxerr.debugging())
+ dumpTemplates();
}
class dumpTemplate {
public:
- dumpTemplate(std::ostream & o)
+ dumpTemplate(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"
<< "\tHelpText\n"
<< et.helpText
<< "\tHelpTextEnd\n"
+ << "\tInputFormat " << et.inputFormat << "\n"
<< "\tFileFilter " << et.fileRegExp << "\n"
- << "\tViewCommand " << et.viewCommand << "\n"
<< "\tEditCommand " << et.editCommand << "\n"
<< "\tAutomaticProduction " << et.automaticProduction << "\n";
et.dumpFormats(ost);
ost << "TemplateEnd" << endl;
-
+
}
private:
class dumpFormat {
public:
- dumpFormat(ostream & o)
+ 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\tUpdateFormat " << ft.updateFormat << "\n"
+ << "\t\tUpdateResult " << ft.updateResult << "\n"
<< "\t\tRequirement " << ft.requirement << "\n"
<< "\t\tPreamble\n"
<< ft.preamble
};
-void ExternalTemplate::dumpFormats(ostream & os) const
+void ExternalTemplate::dumpFormats(ostream & os) const
{
for_each(formats.begin(), formats.end(), dumpFormat(os));
}
-void ExternalTemplateManager::dumpTemplates() const
+
+void ExternalTemplateManager::dumpTemplates() const
{
for_each(templates.begin(), templates.end(), dumpTemplate(lyxerr));
}
}
-void ExternalTemplateManager::readTemplates(string const & path)
+ExternalTemplate const & ExternalTemplateManager::getTemplateByName(string const & name)
+{
+ return templates[name];
+}
+
+
+void ExternalTemplateManager::readTemplates(string const & path)
{
Path p(path);
TM_TEMPLATE = 1,
TM_END
};
-
+
keyword_item templatetags[] = {
{ "template", TM_TEMPLATE },
{ "templateend", TM_END }
};
+ string filename = LibFileSearch("", "external_templates");
+ if (filename.empty()) {
+ lyxerr << "ExternalTemplateManager::readTemplates: "
+ "No template file" << endl;
+ return;
+ }
+
LyXLex lex(templatetags, TM_END);
- if (!lex.setFile("external_templates")) {
- lyxerr << "No template file" << endl;
+ if (!lex.setFile(filename)) {
+ lyxerr << "ExternalTemplateManager::readTemplates: "
+ "No template file" << endl;
return;
}
-
- while (lex.IsOK()) {
- switch(lex.lex()) {
+
+ while (lex.isOK()) {
+ switch (lex.lex()) {
case TM_TEMPLATE: {
lex.next();
- string temp = lex.GetString();
+ string const temp = lex.getString();
ExternalTemplate & tmp = templates[temp];
tmp.lyxName = temp;
tmp.readTemplate(lex);
}
break;
-
+
case TM_END:
- lyxerr << "TemplateEnd: " << lex.GetString() << endl;
- lyxerr << "Warning: End outside Template." << endl;
+ lex.printError("Warning: End outside Template.");
break;
}
}
enum TemplateOptionTags {
TO_GUINAME = 1,
TO_HELPTEXT,
+ TO_INPUTFORMAT,
TO_FILTER,
- TO_VIEWCMD,
TO_EDITCMD,
TO_AUTOMATIC,
TO_FORMAT,
{ "format", TO_FORMAT },
{ "guiname", TO_GUINAME },
{ "helptext", TO_HELPTEXT },
- { "templateend", TO_END },
- { "viewcommand", TO_VIEWCMD }
+ { "inputformat", TO_INPUTFORMAT },
+ { "templateend", TO_END }
};
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:
+
+ case TO_INPUTFORMAT:
lex.next(true);
- fileRegExp = lex.GetString();
+ inputFormat = lex.getString();
break;
-
- case TO_VIEWCMD:
+
+ case TO_FILTER:
lex.next(true);
- viewCommand = lex.GetString();
- // For security reasons, a command may not be empty!
- if (viewCommand.empty())
- viewCommand = "true";
+ fileRegExp = lex.getString();
break;
-
+
case TO_EDITCMD:
lex.next(true);
- editCommand = lex.GetString();
- // For security reasons, a command may not be empty!
- if (editCommand.empty())
- editCommand = "true";
+ editCommand = lex.getString();
break;
-
+
case TO_AUTOMATIC:
lex.next();
- automaticProduction = lex.GetBool();
+ automaticProduction = lex.getBool();
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;
+ lex.printError("ExternalTemplate::readTemplate: "
+ "Wrong tag: $$Token");
Assert(false);
break;
}
}
-void ExternalTemplate::FormatTemplate::readFormat(LyXLex & lex)
+void ExternalTemplate::FormatTemplate::readFormat(LyXLex & lex)
{
enum FormatTags {
FO_PRODUCT = 1,
- FO_UPDATECMD,
+ FO_UPDATEFORMAT,
+ FO_UPDATERESULT,
FO_REQUIREMENT,
FO_PREAMBLE,
FO_END
};
-
+
keyword_item formattags[] = {
{ "formatend", FO_END },
{ "preamble", FO_PREAMBLE },
{ "product", FO_PRODUCT },
{ "requirement", FO_REQUIREMENT },
- { "updatecommand", FO_UPDATECMD }
+ { "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");
break;
-
+
case FO_END:
- lyxerr << "FormatEnd: " << lex.GetString() << endl;
+ if (lyxerr.debugging())
+ lex.printError("FormatEnd");
return;
}
}
}
-