src/insets/ExternalTransforms.h

   1 // -*- C++ -*-
   2 /**
   3  * \file ExternalTransforms.h
   4  * This file is part of LyX, the document processor.
   5  * Licence details can be found in the file COPYING.
   6  *
   7  * \author Angus Leeming
   8  *
   9  * Full author contact details are available in file CREDITS.
  10  */
  11
  12 #ifndef EXTERNALTRANSFORMS_H
  13 #define EXTERNALTRANSFORMS_H
  14
  15 #include "Length.h"
  16
  17 #include "graphics/GraphicsParams.h"
  18
  19 #include "support/unique_ptr.h"
  20
  21 #include <boost/any.hpp>
  22 #include <boost/function.hpp>
  23
  24 #include <string>
  25 #include <map>
  26 #include <memory>
  27
  28 namespace lyx {
  29
  30 class Lexer;
  31
  32 namespace external {
  33
  34 /*
  35  * The data containers
  36  */
  37 class ClipData {
  38 public:
  39         ClipData() : clip(false) {}
  40
  41         /// The bounding box
  42         graphics::BoundingBox bbox;
  43         /// clip image
  44         bool clip;
  45 };
  46
  47
  48 class ExtraData {
  49 public:
  50         std::string const get(std::string const & id) const;
  51         void set(std::string const & id, std::string const & contents);
  52
  53         typedef std::map<std::string, std::string>::const_iterator const_iterator;
  54         const_iterator begin() const { return data_.begin(); }
  55         const_iterator end() const { return data_.end(); }
  56
  57 private:
  58         std::map<std::string, std::string> data_;
  59 };
  60
  61
  62 class ResizeData {
  63 public:
  64         ResizeData() : scale(), keepAspectRatio(false) {}
  65         bool no_resize() const;
  66
  67         bool usingScale() const;
  68
  69         std::string scale;
  70         Length width;
  71         Length height;
  72         bool keepAspectRatio;
  73 };
  74
  75
  76 class RotationData {
  77 public:
  78         enum OriginType {
  79                 DEFAULT,
  80                 TOPLEFT,
  81                 BOTTOMLEFT,
  82                 BASELINELEFT,
  83                 CENTER,
  84                 TOPCENTER,
  85                 BOTTOMCENTER,
  86                 BASELINECENTER,
  87                 TOPRIGHT,
  88                 BOTTOMRIGHT,
  89                 BASELINERIGHT
  90         };
  91
  92         RotationData() : angle("0"), origin_(DEFAULT) {}
  93         bool no_rotation() const;
  94
  95         std::string const adjAngle() const;
  96         std::string angle;
  97
  98         void origin(OriginType o) { origin_ = o; }
  99         OriginType origin() const { return origin_; }
 100
 101         void origin(std::string const &);
 102         std::string const originString() const;
 103
 104 private:
 105         OriginType origin_;
 106 };
 107
 108
 109 /** \c RotationDataType is a wrapper for RotationData::OriginType
 110  *  It can be forward-declared and passed as a function argument without
 111  *  having to expose this header file.
 112  */
 113 class RotationDataType {
 114         RotationData::OriginType val_;
 115 public:
 116         RotationDataType(RotationData::OriginType val) : val_(val) {}
 117         operator RotationData::OriginType() const { return val_; }
 118 };
 119
 120
 121 /*
 122  * Transformers generating commands
 123  */
 124 class TransformCommand {
 125 public:
 126         typedef unique_ptr<TransformCommand const> ptr_type;
 127         virtual ~TransformCommand() {}
 128
 129         /// The string from the External Template that we seek to replace.
 130         std::string const front_placeholder() const
 131                 { return front_placeholder_impl(); }
 132         std::string const back_placeholder() const
 133                 { return back_placeholder_impl(); }
 134
 135         /// The appropriate replacements for the placeholder strings.
 136         std::string const front() const { return front_impl(); }
 137         std::string const back() const { return back_impl(); }
 138
 139 private:
 140         virtual std::string const front_placeholder_impl() const = 0;
 141         virtual std::string const back_placeholder_impl() const = 0;
 142
 143         virtual std::string const front_impl() const = 0;
 144         virtual std::string const back_impl() const = 0;
 145 };
 146
 147
 148 class ResizeCommand : public TransformCommand {
 149 protected:
 150         ResizeData data;
 151         ResizeCommand(ResizeData const & data_) : data(data_) {}
 152
 153 private:
 154         virtual std::string const front_placeholder_impl() const
 155                 { return "$$ResizeFront"; }
 156         virtual std::string const back_placeholder_impl() const
 157                 { return "$$ResizeBack"; }
 158 };
 159
 160
 161 class ResizeLatexCommand : public ResizeCommand {
 162 public:
 163         static ptr_type factory(ResizeData const & data)
 164                 { return ptr_type(new ResizeLatexCommand(data)); }
 165
 166 private:
 167         ResizeLatexCommand(ResizeData const & data_)
 168                 : ResizeCommand(data_) {}
 169         virtual std::string const front_impl() const;
 170         virtual std::string const back_impl() const;
 171 };
 172
 173
 174 class RotationCommand : public TransformCommand {
 175 protected:
 176         RotationData data;
 177         RotationCommand(RotationData const & data_) : data(data_) {}
 178
 179 private:
 180         virtual std::string const front_placeholder_impl() const
 181                 { return "$$RotateFront"; }
 182         virtual std::string const back_placeholder_impl() const
 183                 { return "$$RotateBack"; }
 184 };
 185
 186
 187 class RotationLatexCommand : public RotationCommand {
 188 public:
 189         static ptr_type factory(RotationData const & data)
 190                 { return ptr_type(new RotationLatexCommand(data)); }
 191
 192 private:
 193         RotationLatexCommand(RotationData const & data_)
 194                 : RotationCommand(data_) {}
 195         virtual std::string const front_impl() const;
 196         virtual std::string const back_impl() const;
 197 };
 198
 199
 200 /*
 201  * Transformers generating options
 202  */
 203 class TransformOption {
 204 public:
 205         typedef unique_ptr<TransformOption const> ptr_type;
 206         virtual ~TransformOption() {}
 207
 208         /// The string from the External Template that we seek to replace.
 209         std::string const placeholder() const { return placeholder_impl(); }
 210
 211         /// The appropriate replacement for the placeholder string.
 212         std::string const option() const { return option_impl(); }
 213
 214 private:
 215         virtual std::string const placeholder_impl() const = 0;
 216         virtual std::string const option_impl() const = 0;
 217 };
 218
 219
 220 class ClipOption : public TransformOption {
 221 protected:
 222         ClipData data;
 223         ClipOption(ClipData const & data_) : data(data_) {}
 224
 225 private:
 226         virtual std::string const placeholder_impl() const
 227                 { return "$$Clip"; }
 228 };
 229
 230
 231 class ClipLatexOption : public ClipOption {
 232 public:
 233         static ptr_type factory(ClipData const & data)
 234                 { return ptr_type(new ClipLatexOption(data)); }
 235
 236 private:
 237         ClipLatexOption(ClipData const & data_)
 238                 : ClipOption(data_) {}
 239         virtual std::string const option_impl() const;
 240 };
 241
 242
 243 class ExtraOption : public TransformOption {
 244 public:
 245         static ptr_type factory(std::string const & data)
 246                 { return ptr_type(new ExtraOption(data)); }
 247
 248 private:
 249         ExtraOption(std::string const & data_) : data(data_) {}
 250
 251         virtual std::string const placeholder_impl() const
 252                 { return "$$Extra"; }
 253         virtual std::string const option_impl() const
 254                 { return data; }
 255         std::string data;
 256 };
 257
 258
 259 class ResizeOption : public TransformOption {
 260 protected:
 261         ResizeData data;
 262         ResizeOption(ResizeData const & data_) : data(data_) {}
 263
 264 private:
 265         virtual std::string const placeholder_impl() const
 266                 { return "$$Resize"; }
 267 };
 268
 269
 270 class ResizeLatexOption : public ResizeOption {
 271 public:
 272         static ptr_type factory(ResizeData const & data)
 273                 { return ptr_type(new ResizeLatexOption(data)); }
 274
 275 private:
 276         ResizeLatexOption(ResizeData const & data_)
 277                 : ResizeOption(data_) {}
 278         virtual std::string const option_impl() const;
 279 };
 280
 281
 282 class RotationOption : public TransformOption {
 283 protected:
 284         RotationData data;
 285         RotationOption(RotationData const & data_) : data(data_) {}
 286
 287 private:
 288         virtual std::string const placeholder_impl() const
 289                 { return "$$Rotate"; }
 290 };
 291
 292
 293 class RotationLatexOption : public RotationOption {
 294 public:
 295         static ptr_type factory(RotationData const & data)
 296                 { return ptr_type(new RotationLatexOption(data)); }
 297
 298 private:
 299         RotationLatexOption(RotationData const & data_)
 300                 : RotationOption(data_) {}
 301         virtual std::string const option_impl() const;
 302 };
 303
 304
 305 /*
 306  * Option sanitizers
 307  */
 308 std::string const sanitizeLatexOption(std::string const & input);
 309 std::string const sanitizeDocBookOption(std::string const & input);
 310
 311
 312 enum TransformID {
 313         Rotate,
 314         Resize,
 315         Clip,
 316         Extra
 317 };
 318
 319
 320 typedef boost::function<TransformOption::ptr_type(ClipData)>
 321         ClipOptionFactory;
 322 typedef boost::function<TransformOption::ptr_type(std::string)>
 323         ExtraOptionFactory;
 324 typedef boost::function<TransformOption::ptr_type(ResizeData)>
 325         ResizeOptionFactory;
 326 typedef boost::function<TransformOption::ptr_type(RotationData)>
 327         RotationOptionFactory;
 328 typedef boost::function<TransformCommand::ptr_type(ResizeData)>
 329         ResizeCommandFactory;
 330 typedef boost::function<TransformCommand::ptr_type(RotationData)>
 331         RotationCommandFactory;
 332
 333
 334 class TransformStore
 335 {
 336 public:
 337         TransformStore() {}
 338
 339         /** Stores \c factory and a reminder of what \c data this \c factory
 340          *  operates on.
 341          */
 342         template <typename Factory>
 343         TransformStore(TransformID id_, Factory const & factory)
 344                 : id(id_), any_factory(boost::any(factory)) {}
 345
 346         typedef TransformCommand::ptr_type ComPtr;
 347         typedef TransformOption::ptr_type  OptPtr;
 348
 349         ComPtr getCommandTransformer(RotationData const &) const;
 350         ComPtr getCommandTransformer(ResizeData const &) const;
 351         OptPtr getOptionTransformer(RotationData const &) const;
 352         OptPtr getOptionTransformer(ResizeData const &) const;
 353         OptPtr getOptionTransformer(ClipData const &) const;
 354         OptPtr getOptionTransformer(std::string const &) const;
 355
 356 private:
 357         TransformID id;
 358         boost::any any_factory;
 359 };
 360
 361 } // namespace external
 362 } // namespace lyx
 363
 364 #endif // NOT EXTERNALTRANSFORMS_H