workspace/libs/plasma/svg.cpp

   1 /*
   2  *   Copyright 2006-2007 Aaron Seigo <aseigo@kde.org>
   3  *
   4  *   This program is free software; you can redistribute it and/or modify
   5  *   it under the terms of the GNU Library General Public License as
   6  *   published by the Free Software Foundation; either version 2, or
   7  *   (at your option) any later version.
   8  *
   9  *   This program is distributed in the hope that it will be useful,
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *   GNU General Public License for more details
  13  *
  14  *   You should have received a copy of the GNU Library General Public
  15  *   License along with this program; if not, write to the
  16  *   Free Software Foundation, Inc.,
  17  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18  */
  19
  20 #include "svg.h"
  21
  22 #include <QDir>
  23 #include <QMatrix>
  24 #include <QPainter>
  25 #include <QPixmapCache>
  26 #include <QSharedData>
  27
  28 #include <KDebug>
  29 #include <KSharedPtr>
  30 #include <KSvgRenderer>
  31 #include <KColorScheme>
  32 #include <KIconEffect>
  33 #include <KGlobalSettings>
  34
  35 #include "theme.h"
  36
  37 namespace Plasma
  38 {
  39
  40 class SharedSvgRenderer : public KSvgRenderer, public QSharedData
  41 {
  42     public:
  43         typedef KSharedPtr<SharedSvgRenderer> Ptr;
  44
  45         SharedSvgRenderer(QObject *parent = 0)
  46             : KSvgRenderer(parent)
  47         {}
  48
  49         SharedSvgRenderer(const QString &filename, QObject *parent = 0)
  50             : KSvgRenderer(filename, parent)
  51         {}
  52
  53         SharedSvgRenderer(const QByteArray &contents, QObject *parent = 0)
  54             : KSvgRenderer(contents, parent)
  55         {}
  56
  57         ~SharedSvgRenderer()
  58         {
  59             //kDebug() << "leaving this world for a better one.";
  60         }
  61 };
  62
  63 class Svg::Private
  64 {
  65     public:
  66         Private(const QString& imagePath, Svg *q)
  67             : renderer(0),
  68               contentType(Svg::SingleImage),
  69               themed(false)
  70         {
  71             setImagePath(imagePath, q);
  72         }
  73
  74         ~Private()
  75         {
  76             eraseRenderer();
  77         }
  78
  79         void setImagePath(const QString &imagePath, Svg *q)
  80         {
  81             if (themed) {
  82                 disconnect(Plasma::Theme::self(), SIGNAL(changed()), q, SLOT(themeChanged()));
  83                 disconnect(KGlobalSettings::self(), SIGNAL(kdisplayPaletteChanged()), q, SLOT(colorsChanged()));
  84             }
  85
  86             themed = !QDir::isAbsolutePath(imagePath);
  87             path = themePath = QString();
  88
  89             if (themed) {
  90                 themePath = imagePath;
  91                 connect(Plasma::Theme::self(), SIGNAL(changed()), q, SLOT(themeChanged()));
  92
  93                 // check if svg wants colorscheme applied
  94                 createRenderer();
  95                 applyColors = renderer->elementExists("hint-apply-color-scheme");
  96                 if (applyColors && !Theme::self()->colors()) {
  97                     connect(KGlobalSettings::self(), SIGNAL(kdisplayPaletteChanged()), q, SLOT(colorsChanged()));
  98                 }
  99
 100             } else {
 101                 path = imagePath;
 102
 103                 if (!QFile::exists(path)) {
 104                     kDebug() << "Plasma::Svg: file '" << path << "' does not exist!";
 105                 }
 106             }
 107         }
 108
 109         void removeFromCache() {
 110             if (ids.isEmpty()) {
 111                 return;
 112             }
 113
 114             foreach (const QString &id, ids) {
 115                 QPixmapCache::remove(id);
 116             }
 117
 118             ids.clear();
 119         }
 120
 121         void findInCache(QPixmap& p, const QString& elementId)
 122         {
 123             createRenderer();
 124             QString id = QString::fromLatin1("%3_%2_%1_").arg(size.width())
 125                                                          .arg(size.height())
 126                                                          .arg(path);
 127
 128             if (!elementId.isEmpty()) {
 129                 id.append(elementId);
 130             }
 131             //kDebug() << "id is " << id;
 132
 133             if (!ids.contains(id)) {
 134                 ids.append(id);
 135             }
 136
 137             if (QPixmapCache::find(id, p)) {
 138                 //kDebug() << "found cached version of " << id;
 139                 return;
 140             } else {
 141                 //kDebug() << "didn't find cached version of " << id << ", so re-rendering";
 142             }
 143
 144             // we have to re-render this puppy
 145             QSize s;
 146             if (elementId.isEmpty() || contentType == Svg::ImageSet) {
 147                 s = size.toSize();
 148             } else {
 149                 s = elementSize(elementId);
 150             }
 151             //kDebug() << "size for " << elementId << " is " << s;
 152
 153             p = QPixmap(s);
 154             p.fill(Qt::transparent);
 155             QPainter renderPainter(&p);
 156
 157             if (elementId.isEmpty()) {
 158                 renderer->render(&renderPainter);
 159             } else {
 160                 renderer->render(&renderPainter, elementId);
 161             }
 162
 163             renderPainter.end();
 164
 165             // Apply current color scheme if the svg asks for it
 166             if (applyColors) {
 167                 QImage itmp = p.toImage();
 168                 KIconEffect::colorize(itmp, Theme::self()->backgroundColor(), 0.9);
 169                 p = p.fromImage(itmp);
 170             }
 171
 172             if (!QPixmapCache::insert( id, p )) {
 173                 kDebug() << "pixmap cache is too small for inserting" << id << "of size" << s;
 174             }
 175         }
 176
 177         void createRenderer()
 178         {
 179             if (renderer) {
 180                 return;
 181             }
 182
 183             if (themed && path.isEmpty()) {
 184                 path = Plasma::Theme::self()->image(themePath);
 185             }
 186
 187             QHash<QString, SharedSvgRenderer::Ptr>::const_iterator it = renderers.find(path);
 188
 189             if (it != renderers.end()) {
 190                 //kDebug() << "gots us an existing one!";
 191                 renderer = it.value();
 192             } else {
 193                 renderer = new SharedSvgRenderer(path);
 194                 renderers[path] = renderer;
 195             }
 196
 197             size = renderer->defaultSize();
 198         }
 199
 200         void eraseRenderer()
 201         {
 202             if (renderer.count() == 2) {
 203                 // this and the cache reference it; and boy is this not thread safe ;)
 204                 renderers.erase(renderers.find(themePath));
 205             }
 206
 207             renderer = 0;
 208         }
 209
 210         QSize elementSize(const QString& elementId)
 211         {
 212             createRenderer();
 213             QSizeF elementSize = renderer->boundsOnElement(elementId).size();
 214             QSizeF naturalSize = renderer->defaultSize();
 215             qreal dx = size.width() / naturalSize.width();
 216             qreal dy = size.height() / naturalSize.height();
 217             elementSize.scale(elementSize.width() * dx, elementSize.height() * dy, Qt::IgnoreAspectRatio);
 218
 219             return elementSize.toSize();
 220         }
 221
 222         QRect elementRect(const QString& elementId)
 223         {
 224             createRenderer();
 225             QRectF elementRect = renderer->boundsOnElement(elementId);
 226             QSizeF naturalSize = renderer->defaultSize();
 227             qreal dx = size.width() / naturalSize.width();
 228             qreal dy = size.height() / naturalSize.height();
 229
 230             return QRect(elementRect.x() * dx, elementRect.y() * dy,
 231                          elementRect.width() * dx, elementRect.height() * dy);
 232         }
 233
 234         QMatrix matrixForElement(const QString& elementId)
 235         {
 236             createRenderer();
 237             return renderer->matrixForElement(elementId);
 238         }
 239
 240         static QHash<QString, SharedSvgRenderer::Ptr> renderers;
 241         SharedSvgRenderer::Ptr renderer;
 242         QString themePath;
 243         QString path;
 244         QList<QString> ids;
 245         QSizeF size;
 246         bool themed;
 247         bool applyColors;
 248         Svg::ContentType contentType;
 249 };
 250
 251 QHash<QString, SharedSvgRenderer::Ptr> Svg::Private::renderers;
 252
 253 Svg::Svg(const QString& imagePath, QObject* parent)
 254     : QObject(parent),
 255       d(new Private(imagePath, this))
 256 {
 257 }
 258
 259 Svg::~Svg()
 260 {
 261     delete d;
 262 }
 263
 264 void Svg::paint(QPainter* painter, const QPointF& point, const QString& elementID)
 265 {
 266     QPixmap pix;
 267     d->findInCache(pix, elementID);
 268     //kDebug() << "pix size is " << pix.size();
 269     painter->drawPixmap(QRectF(point, pix.size()), pix, QRectF(QPointF(0,0), pix.size()));
 270 }
 271
 272 void Svg::paint(QPainter* painter, int x, int y, const QString& elementID)
 273 {
 274     paint(painter, QPointF(x, y), elementID);
 275 }
 276
 277 void Svg::paint(QPainter* painter, const QRectF& rect, const QString& elementID)
 278 {
 279     QPixmap pix;
 280     d->findInCache(pix, elementID);
 281     //kDebug() << "pix size is " << pix.size();
 282     painter->drawPixmap(rect, pix, QRectF(QPointF(0,0), pix.size()));
 283 }
 284
 285 void Svg::resize( int width, int height )
 286 {
 287     resize( QSize( width, height ) );
 288 }
 289
 290 void Svg::resize( const QSizeF& size )
 291 {
 292     d->createRenderer();
 293     d->size = size;
 294 }
 295
 296 void Svg::resize()
 297 {
 298     d->createRenderer();
 299     d->size = d->renderer->defaultSize();
 300 }
 301
 302 QSize Svg::elementSize(const QString& elementId) const
 303 {
 304     return d->elementSize(elementId);
 305 }
 306
 307 QRect Svg::elementRect(const QString& elementId) const
 308 {
 309     return d->elementRect(elementId);
 310 }
 311
 312 bool Svg::elementExists(const QString& elementId) const
 313 {
 314     d->createRenderer();
 315     return d->renderer->elementExists(elementId);
 316 }
 317
 318 QString Svg::elementAtPoint(const QPoint &point) const
 319 {
 320     d->createRenderer();
 321     QSizeF naturalSize = d->renderer->defaultSize();
 322     qreal dx = d->size.width() / naturalSize.width();
 323     qreal dy = d->size.height() / naturalSize.height();
 324     //kDebug() << point << "is really" << QPoint(point.x() *dx, naturalSize.height() - point.y() * dy);
 325
 326     return QString(); // d->renderer->elementAtPoint(QPoint(point.x() *dx, naturalSize.height() - point.y() * dy));
 327 }
 328
 329 QMatrix Svg::matrixForElement(const QString& elementId) const
 330 {
 331     d->createRenderer();
 332     return d->renderer->matrixForElement(elementId);
 333 }
 334
 335 bool Svg::isValid() const
 336 {
 337     d->createRenderer();
 338     return d->renderer->isValid();
 339 }
 340
 341 QSize Svg::size() const
 342 {
 343     return d->size.toSize();
 344 }
 345
 346 void Svg::setContentType(ContentType contentType)
 347 {
 348     d->contentType = contentType;
 349 }
 350
 351 Svg::ContentType Svg::contentType()
 352 {
 353     return d->contentType;
 354 }
 355
 356 void Svg::setFile(const QString &svgFilePath)
 357 {
 358    d->setImagePath(svgFilePath, this);
 359    d->eraseRenderer();
 360 }
 361
 362 QString Svg::file() const
 363 {
 364    return d->themed ? d->themePath : d->path;
 365 }
 366
 367 void Svg::themeChanged()
 368 {
 369     if (!d->themed) {
 370         return;
 371     }
 372
 373     QString newPath = Theme::self()->image(d->themePath);
 374
 375     if (d->path == newPath) {
 376         return;
 377     }
 378
 379     d->removeFromCache();
 380     d->path = newPath;
 381     //delete d->renderer; we're a KSharedPtr
 382     d->eraseRenderer();
 383     emit repaintNeeded();
 384 }
 385
 386 void Svg::colorsChanged()
 387 {
 388     if (!d->applyColors) {
 389         return;
 390     }
 391
 392     d->removeFromCache();
 393     d->eraseRenderer();
 394     emit repaintNeeded();
 395 }
 396
 397 } // Plasma namespace
 398
 399 #include "svg.moc"
 400