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