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