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