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