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