src/graphics/GraphicsImage.h

   1 // -*- C++ -*-
   2 /**
   3  * \file GraphicsImage.h
   4  * This file is part of LyX, the document processor.
   5  * Licence details can be found in the file COPYING.
   6  *
   7  * \author Baruch Even
   8  * \author Angus Leeming
   9  *
  10  * Full author contact details are available in file CREDITS.
  11  *
  12  * An abstract base class for the images themselves.
  13  * Allows the user to retrieve the pixmap, once loaded and to issue commands
  14  * to modify it.
  15  *
  16  * The boost::functions newImage and loadableFormats are connected to the
  17  * appropriate derived classes elsewhere, allowing the graphics cache to
  18  * access them without knowing anything about their instantiation.
  19  *
  20  * The loading process can be asynchronous, but cropping, rotating and
  21  * scaling block execution.
  22  */
  23
  24 #ifndef GRAPHICSIMAGE_H
  25 #define GRAPHICSIMAGE_H
  26
  27 #include "support/std_string.h"
  28
  29 #include <boost/shared_ptr.hpp>
  30 #include <boost/function/function0.hpp>
  31 #include <boost/signals/signal1.hpp>
  32
  33 #include <vector>
  34 #include <utility>
  35
  36 namespace lyx {
  37 namespace graphics {
  38
  39 class Params;
  40
  41 class Image {
  42 public:
  43         /** This is to be connected to a function that will return a new
  44          *  instance of a viable derived class.
  45          */
  46         typedef boost::shared_ptr<Image> ImagePtr;
  47         ///
  48         static boost::function0<ImagePtr> newImage;
  49
  50         /// Return the list of loadable formats.
  51         typedef std::vector<string> FormatList;
  52         ///
  53         static boost::function0<FormatList> loadableFormats;
  54
  55         ///
  56         virtual ~Image() {}
  57
  58         /// Create a copy
  59         Image * clone() const;
  60
  61         /// Get the image width
  62         unsigned int getWidth() const;
  63
  64         /// Get the image height
  65         unsigned int getHeight() const;
  66
  67         /// Is the image drawable ?
  68         bool isDrawable() const;
  69
  70         /** At the end of the loading process inform the outside world
  71          *  by emitting a signal.
  72          */
  73         typedef boost::signal1<void, bool> SignalType;
  74         ///
  75         SignalType finishedLoading;
  76
  77         /** Start loading the image file.
  78          *  The caller should expect this process to be asynchronous and
  79          *  so should connect to the "finished" signal above.
  80          */
  81         void load(string const & filename);
  82
  83         /** Generate the pixmap.
  84          *  Uses the params to decide on color, grayscale etc.
  85          *  Returns true if the pixmap is created.
  86          */
  87         bool setPixmap(Params const & params);
  88
  89         /// Clip the image using params.
  90         void clip(Params const & params);
  91
  92         /// Rotate the image using params.
  93         void rotate(Params const & params);
  94
  95         /// Scale the image using params.
  96         void scale(Params const & params);
  97
  98 protected:
  99         /// Must define default c-tor explicitly as we define a copy c-tor.
 100         Image() {}
 101         /// Don't copy the signal finishedLoading
 102         Image(Image const &) {}
 103
 104         /** Uses the params to ascertain the dimensions of the scaled image.
 105          *  Returned as make_pair(width, height).
 106          *  If something goes wrong, returns make_pair(getWidth(), getHeight())
 107          */
 108         std::pair<unsigned int, unsigned int>
 109         getScaledDimensions(Params const & params) const;
 110
 111 private:
 112         /// Create a copy
 113         virtual Image * clone_impl() const = 0;
 114         /// Get the image width
 115         virtual unsigned int getWidth_impl() const = 0;
 116
 117         /// Get the image height
 118         virtual unsigned int getHeight_impl() const = 0;
 119
 120         /// is the image drawable ?
 121         virtual bool isDrawable_impl() const = 0;
 122
 123         /** Start loading the image file.
 124          *  The caller should expect this process to be asynchronous and
 125          *  so should connect to the "finished" signal above.
 126          */
 127         virtual void load_impl(string const & filename) = 0;
 128
 129         /** Generate the pixmap.
 130          *  Uses the params to decide on color, grayscale etc.
 131          *  Returns true if the pixmap is created.
 132          */
 133         virtual bool setPixmap_impl(Params const & params) = 0;
 134
 135         /// Clip the image using params.
 136         virtual void clip_impl(Params const & params) = 0;
 137
 138         /// Rotate the image using params.
 139         virtual void rotate_impl(Params const & params) = 0;
 140
 141         /// Scale the image using params.
 142         virtual void scale_impl(Params const & params) = 0;
 143 };
 144
 145
 146 inline
 147 Image * Image::clone() const
 148 {
 149         return clone_impl();
 150 }
 151
 152
 153 inline
 154 unsigned int Image::getWidth() const
 155 {
 156         return getWidth_impl();
 157 }
 158
 159
 160 inline
 161 unsigned int Image::getHeight() const
 162 {
 163         return getHeight_impl();
 164 }
 165
 166
 167 inline
 168 bool Image::isDrawable() const
 169 {
 170         return isDrawable_impl();
 171 }
 172
 173
 174 inline
 175 void Image::load(string const & filename)
 176 {
 177         return load_impl(filename);
 178 }
 179
 180
 181 inline
 182 bool Image::setPixmap(Params const & params)
 183 {
 184         return setPixmap_impl(params);
 185 }
 186
 187
 188 inline
 189 void Image::clip(Params const & params)
 190 {
 191         return clip_impl(params);
 192 }
 193
 194
 195 inline
 196 void Image::rotate(Params const & params)
 197 {
 198         return rotate_impl(params);
 199 }
 200
 201
 202 inline
 203 void Image::scale(Params const & params)
 204 {
 205         return scale_impl(params);
 206 }
 207
 208 } // namespace graphics
 209 } // namespace lyx
 210
 211 #endif // GRAPHICSIMAGE_H