// -*- C++ -*-
-/* This file is part of*
- * ======================================================
+/**
+ * \file ExternalTemplate.h
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
*
- * LyX, The Document Processor
- *
- * Copyright 1995 Matthias Ettrich
- * Copyright 1995-2001 The LyX Team.
+ * \author Asger Alstrup Nielsen
+ * \author Angus Leeming
*
- * ====================================================== */
+ * Full author contact details are available in file CREDITS.
+ */
#ifndef EXTERNALTEMPLATE_H
#define EXTERNALTEMPLATE_H
-#ifdef __GNUG__
-#pragma interface
-#endif
+#include "ExternalTransforms.h"
+
+#include <vector>
+
+namespace lyx {
+
+namespace support { class FileName; }
-#include <iosfwd>
-#include <map>
-#include "LString.h"
-#include <boost/utility.hpp>
+class Lexer;
-class LyXLex;
+enum PreviewMode {
+ PREVIEW_OFF = 0,
+ PREVIEW_GRAPHICS,
+ PREVIEW_INSTANT
+};
+
+namespace external {
+
+class Template {
+public:
+ /// We have to have default commands for safety reasons!
+ Template();
+ ///
+ void readTemplate(Lexer &);
+ ///
+ void dumpFormats(std::ostream &) const;
+
+ class Option {
+ public:
+ Option(std::string const & name_, std::string const & opt_)
+ : name(name_), option(opt_) {}
+ std::string name;
+ std::string option;
+ };
-///
-struct ExternalTemplate {
/// What is the name of this template in the LyX format?
- string lyxName;
+ std::string lyxName;
/// What will the button in the GUI say?
- string guiName;
+ std::string guiName;
/// A short help text
- string helpText;
+ docstring helpText;
+ /** The format of the input file. Can be "*", in which case we try and
+ * ascertain the format from the contents of the file.
+ */
+ std::string inputFormat;
/// A file extension regular expression for the file browser
- string fileRegExp;
- /// What command should be executed to view the file?
- string viewCommand;
- /// What command should be executed to edit the file?
- string editCommand;
+ std::string fileRegExp;
/// Should we do automatic production of the output?
bool automaticProduction;
+ /// How should we preview the data in LyX?
+ PreviewMode preview_mode;
+ /// A collection of transforms that we can use to transform the data.
+ std::vector<TransformID> transformIds;
+
/// This is the information needed to support a specific output format
- struct FormatTemplate {
+ class Format {
+ public:
+ Format();
+ ///
+ void readFormat(Lexer &);
+
/// The text that should be inserted into the exported file
- string product;
- /// The shell command to produce a resulting file
- string updateCommand;
+ std::string product;
/// The filename of the resulting file
- string updateResult;
+ std::string updateResult;
+ /// The format of this file.
+ std::string updateFormat;
/// What features does this external inset require?
- string requirement;
- /// What should be inserted into the preamble
- string preamble;
- ///
- void readFormat(LyXLex &);
- /// This constructor has to default a command for safety reasons!
- FormatTemplate();
+ std::vector<std::string> requirements;
+ /// A collection of preamble snippets identified by name.
+ std::vector<std::string> preambleNames;
+ /// A list of options to the basic command.
+ std::vector<Option> options;
+
+ /// The factory functions for each supported transformation.
+ std::map<TransformID, TransformStore> command_transformers;
+ std::map<TransformID, TransformStore> option_transformers;
+
+ typedef std::map<std::string,
+ std::vector<std::string> > FileMap;
+ /// Referenced files for some formats
+ FileMap referencedFiles;
};
///
- void readTemplate(LyXLex &);
- ///
- typedef std::map<string, FormatTemplate> Formats;
+ typedef std::map<std::string, Format> Formats;
///
Formats formats;
- ///
- void dumpFormats(std::ostream &) const;
-
- /// We have to have default commands for safety reasons!
- ExternalTemplate();
-
};
-
/**
- A singleton class that manages the external inset templates
-*/
-class ExternalTemplateManager : boost::noncopyable {
+ * A singleton class that manages the external inset templates
+ */
+class TemplateManager {
public:
/// Map from the LyX name of the template to the template structure
- typedef std::map<string, ExternalTemplate> Templates;
+ typedef std::map<std::string, Template> Templates;
+ /** Map from the LyX name of the preamble definition to the preamble
+ * definition itself.
+ */
+ typedef std::map<std::string, docstring> PreambleDefs;
+
+ static TemplateManager & get();
- static ExternalTemplateManager & get();
- Templates & getTemplates();
Templates const & getTemplates() const;
- /// return the template by LyX name
- ExternalTemplate const & getTemplateByName(const string & name);
+ /** return the template by LyX name.
+ * If it isn't found, return 0.
+ */
+ Template const * getTemplateByName(std::string const & name) const;
+ /** return the preamble definition by LyX name.
+ * If it isn't found, return an empty std::string.
+ */
+ docstring getPreambleDefByName(std::string const & name) const;
+ /// noncopyable
+ TemplateManager(TemplateManager const &) = delete;
+ void operator=(TemplateManager const &) = delete;
private:
- ExternalTemplateManager();
- void readTemplates(string const & path);
- void dumpTemplates() const;
+ TemplateManager();
+
+ void readTemplates(support::FileName const & path);
+ void dumpTemplates(std::ostream &) const;
+ void dumpPreambleDefs(std::ostream &) const;
+
Templates templates;
+ PreambleDefs preambledefs;
};
-#endif
+} // namespace external
+} // namespace lyx
+
+#endif // EXTERNALTEMPLATE_H
projects / lyx.git / blobdiff