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