src/loader/image.h

   1 /*
   2   Copyright (c) 2006 Paolo Capriotti <p.capriotti@sns.it>
   3             (c) 2006 Maurizio Monge <maurizio.monge@kdemail.net>
   4
   5   This program is free software; you can redistribute it and/or modify
   6   it under the terms of the GNU General Public License as published by
   7   the Free Software Foundation; either version 2 of the License, or
   8   (at your option) any later version.
   9 */
  10
  11 #ifndef LOADER__IMAGE_H
  12 #define LOADER__IMAGE_H
  13
  14 #include <QColor>
  15 #include <QMatrix>
  16 #include <QBrush>
  17 #include <QFont>
  18 #include <QImage>
  19
  20 class QPainter;
  21
  22 /**
  23   * @namespace Loader
  24   * @brief Namespace holding image (and more generally resource) loading functions
  25   */
  26 namespace Loader {
  27
  28
  29 class Context;
  30
  31
  32 /**
  33   * @class Image <loader/image.h>
  34   * @brief The image class to be used with lua
  35   */
  36 class Image {
  37 public:
  38   QImage  m_image;
  39   QMatrix m_draw_matrix;
  40   double  m_draw_opacity;
  41   bool    m_draw_over;
  42
  43   void init_painter(QPainter*);
  44
  45 public:
  46
  47   /**
  48    * Creates an image. Image data will be undefined.
  49    * @param width The width of the image.
  50    * @param height The height of the image.
  51    */
  52   Image(int width,
  53         int height);
  54
  55
  56   /**
  57    * Creates an image from a file. If the files is not found or could not be
  58    * loaded, the resulting image will have width and height equal to 0
  59    * @param ctx The current context (theme) reference (should be implicit in lua)
  60    * @param file The file name.
  61    */
  62   Image(Context* ctx,
  63         const QString& file);
  64
  65
  66   /** Returns the width of the image */
  67   int width() {
  68     return m_image.width();
  69   }
  70
  71
  72   /** Returns the height of the image */
  73   int height() {
  74     return m_image.height();
  75   }
  76
  77
  78   /**
  79    * Sets the transformation matrix
  80    */
  81   void setMatrix(const QMatrix& m) {
  82     m_draw_matrix = m;
  83   }
  84
  85
  86   /**
  87    * Resets the transformation matrix
  88    */
  89   void resetMatrix() {
  90     m_draw_matrix.reset();
  91   }
  92
  93
  94   /**
  95    * Scales the transformation matrix
  96    */
  97   void scale(double x, double y) {
  98     m_draw_matrix = m_draw_matrix * QMatrix().scale(x,y);
  99   }
 100
 101
 102   /**
 103    * Rotates the transformation matrix
 104    */
 105   void rotate(double angle) {
 106     m_draw_matrix = m_draw_matrix * QMatrix().rotate(angle);
 107   }
 108
 109
 110   /**
 111    * Translates the transformation matrix
 112    */
 113   void translate(double x, double y) {
 114     m_draw_matrix = m_draw_matrix * QMatrix().translate(x,y);
 115   }
 116
 117
 118   /**
 119    * Returns the transformation matrix
 120    */
 121   QMatrix matrix() {
 122     return m_draw_matrix;
 123   }
 124
 125
 126   /**
 127    * Sets the opacity of the drawing operations
 128    */
 129   void setOpacity(double o) {
 130     m_draw_opacity = o;
 131   }
 132
 133
 134   /**
 135    * Returns the opacity of the drawing operations
 136    */
 137   double opacity() {
 138     return m_draw_opacity;
 139   }
 140
 141
 142   /**
 143    * Sets the composition mode
 144    * @param over If true the painting operations will paint over,
 145    *               if false will replace the destination color.
 146    */
 147   void setPaintOver(bool over) {
 148     m_draw_over = over;
 149   }
 150
 151
 152   /**
 153    * Clears the image.
 154    * @param color The color to fill the image with (default transparent)
 155    */
 156   void clear(const QColor& color = Qt::transparent);
 157
 158
 159   /**
 160    * Fills a rectangle.
 161    * @param rect The rectangle
 162    * @param brush The fill brush
 163    */
 164   void fillRect(const QRectF& rect,
 165                 const QBrush& brush);
 166
 167
 168   /**
 169    * Draws a line.
 170    * @param from The starting point
 171    * @param to The end point
 172    * @param col The pen color
 173    * @param width The pen width
 174    */
 175   void drawLine(const QPointF& from,
 176                 const QPointF& to,
 177                 const QColor& col,
 178                 double width);
 179
 180
 181   /**
 182    * Draws an image on the over the current one.
 183    * @param dest The destination rectangle.
 184    * @param src_img The source image.
 185    * @param src The source rectangle.
 186    */
 187   void drawImage(const QRectF& dest,
 188                  const Image& src_img,
 189                  const QRectF& src = QRectF(0.0,0.0,0.0,0.0));
 190
 191
 192   /**
 193    * Draws an image on the over the current one (overload).
 194    * @param ctx The current context (theme) reference (should be implicit in lua)
 195    * @param dest The destination rectangle.
 196    * @param src_img The source image file.
 197    * @param src The source rectangle, WITH RELATIVE COORDINATES 0.0 - 1.0 (of course).
 198    * @return True if it was possible to load the image file.
 199    */
 200   bool drawImage(Context* ctx,
 201                  const QRectF& dest,
 202                  const QString& src_img,
 203                  const QRectF& src = QRectF(0.0,0.0,0.0,0.0));
 204
 205
 206   /**
 207    * Draws an SVG file over the image.
 208    * @param ctx The current context (theme) reference (should be implicit in lua)
 209    * @param dest The destination rectangle.
 210    * @param file The file to load.
 211    * @return True if it was possible to load the SVG file.
 212    * TODO: add css support (When Qt will support it)
 213    */
 214   bool drawSVG(Context* ctx,
 215                const QRectF& dest,
 216                const QString& file);
 217
 218
 219   /**
 220    * Draws a font glyph over the image.
 221    * @param ctx The current context (theme) reference (should be implicit in lua)
 222    * @param dest The destination rectangle.
 223    * @param font The font file to load.
 224    * @param glyph The unicode glyph code.
 225    * @param fg The foreground color.
 226    * @param bg The background color.
 227    * @param border The background expansion.
 228    * @param draw_inner_bg If true the 'inner part' (detected with a flood fill
 229                           algorithm) will be filled with the background brush.
 230    * @return True if it was possible to load the font file and find the glyph.
 231    */
 232   bool drawGlyph(Context* ctx,
 233                  const QRectF& dest,
 234                  const QString& font,
 235                  unsigned int glyph,
 236                  const QBrush& fg = Qt::black,
 237                  const QBrush& bg = Qt::white,
 238                  double border = 0.0,
 239                  bool draw_inner_bg = true);
 240
 241   /**
 242    * Returns a shadow image for the current image.
 243    * @param radius The shadow radius.
 244    * @param color  The shadow color.
 245    * @param grow   How bigger the output image will be.
 246    * @param offset Position of the shadow (relatively from being centered in the output).
 247    */
 248   Image createShadow(double radius,
 249                      const QColor& color,
 250                      const QPoint& grow = QPoint(),
 251                      const QPointF& offset = QPointF() );
 252 };
 253
 254 /**
 255   * @class Glyph <loader/image.h>
 256   * @brief A simple class that represents a glyph in a font to be used with lua
 257   */
 258 class Glyph {
 259 public:
 260   bool m_font_valid;
 261   QFont m_font;
 262   QChar m_char;
 263   int m_delta;
 264   Glyph(Context* ctx, const QString&, QChar, int = 0);
 265   Glyph(QChar = QChar());
 266 };
 267
 268 } //end namespace Loader
 269
 270 #endif //LOADER__IMAGE_H