Another (IMHO false) fall-through warning silenced

[lyx.git] / src / insets / ExternalTemplate.h

diff --git a/src/insets/ExternalTemplate.h b/src/insets/ExternalTemplate.h
index 766d89880ea97b801c0d23e1183c11d9011817e7..e5b6755059700b009b756ea12edea6b70cc19a47 100644 (file)
--- a/src/insets/ExternalTemplate.h
+++ b/src/insets/ExternalTemplate.h
@@ -5,6 +5,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.
  */
@@ -12,50 +13,66 @@
 #ifndef EXTERNALTEMPLATE_H
 #define EXTERNALTEMPLATE_H
 
-#include <boost/function.hpp>
-#include <boost/utility.hpp>
+#include "ExternalTransforms.h"
 
-#include <iosfwd>
-#include <map>
 #include <vector>
 
-class LyXLex;
-
 namespace lyx {
+
+namespace support { class FileName; }
+
+class Lexer;
+
+enum PreviewMode {
+       PREVIEW_OFF = 0,
+       PREVIEW_GRAPHICS,
+       PREVIEW_INSTANT
+};
+
 namespace external {
 
-///
-struct Template {
+class Template {
+public:
        /// We have to have default commands for safety reasons!
        Template();
        ///
-       void readTemplate(LyXLex &);
+       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;
+       };
+
        /// What is the name of this template in the LyX format?
        std::string lyxName;
        /// What will the button in the GUI say?
        std::string guiName;
        /// A short help text
-       std::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
        std::string fileRegExp;
-       /// What command should be executed to edit the file?
-       std::string editCommand;
        /// 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 Format {
-               /// This constructor has to default a command for safety reasons!
+       class Format {
+       public:
                Format();
                ///
-               void readFormat(LyXLex &);
+               void readFormat(Lexer &);
 
                /// The text that should be inserted into the exported file
                std::string product;
@@ -64,9 +81,20 @@ struct Template {
                /// The format of this file.
                std::string updateFormat;
                /// What features does this external inset require?
-               std::string requirement;
+               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;
        };
        ///
        typedef std::map<std::string, Format> Formats;
@@ -74,21 +102,20 @@ struct Template {
        Formats formats;
 };
 
-
 /**
-   A singleton class that manages the external inset templates
-*/
-class TemplateManager : 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<std::string, Template> Templates;
        /** Map from the LyX name of the preamble definition to the preamble
         *  definition itself.
         */
-       typedef std::map<std::string, std::string> PreambleDefs;
+       typedef std::map<std::string, docstring> PreambleDefs;
 
        static TemplateManager & get();
-       Templates & getTemplates();
+
        Templates const & getTemplates() const;
        /** return the template by LyX name.
         *  If it isn't found, return 0.
@@ -97,10 +124,14 @@ public:
        /** return the preamble definition by LyX name.
         *  If it isn't found, return an empty std::string.
         */
-       std::string const getPreambleDefByName(std::string const & name) const;
+       docstring getPreambleDefByName(std::string const & name) const;
+       /// noncopyable
+       TemplateManager(TemplateManager const &) = delete;
+       void operator=(TemplateManager const &) = delete;
 private:
        TemplateManager();
-       void readTemplates(std::string const & path);
+
+       void readTemplates(support::FileName const & path);
        void dumpTemplates(std::ostream &) const;
        void dumpPreambleDefs(std::ostream &) const;