workspace/plasma/containments/desktop/backgroundpackage.cpp

   1 /*
   2  *   Copyright (c) 2007 Paolo Capriotti <p.capriotti@gmail.com>
   3  *
   4  *   This program is free software; you can redistribute it and/or modify
   5  *   it under the terms of the GNU General Public License version 2,
   6  *   or (at your option) any later version.
   7  *
   8  *   This program is distributed in the hope that it will be useful,
   9  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  *   GNU General Public License for more details
  12  *
  13  *   You should have received a copy of the GNU Library General Public
  14  *   License along with this program; if not, write to the
  15  *   Free Software Foundation, Inc.,
  16  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  17  */
  18
  19 #include "backgroundpackage.h"
  20 #include <cmath>
  21 // <cmath> does not define fabs (by the standard, even if it does with gcc)
  22 #include <math.h>
  23
  24 #include <QFileInfo>
  25 #include <QPainter>
  26 #include <KDebug>
  27 #include <KLocalizedString>
  28 #include <KStandardDirs>
  29 #include <KSvgRenderer>
  30 #include <plasma/packagestructure.h>
  31 #include <plasma/packagemetadata.h>
  32 #include <ThreadWeaver/Weaver>
  33
  34 using namespace Plasma;
  35
  36 class ResizeThread : public ThreadWeaver::Job
  37 {
  38 public:
  39     ResizeThread(const QString &path, float ratio, QObject *parent = 0);
  40     virtual ~ResizeThread();
  41
  42     virtual void start(QPersistentModelIndex index);
  43     virtual void run();
  44
  45     QImage result() const;
  46     QPersistentModelIndex index() const;
  47     bool isInitialized() const;
  48 private:
  49     QString m_path;
  50     QImage m_result;
  51     float m_ratio;
  52     QPersistentModelIndex m_index;
  53 };
  54
  55 ResizeThread::ResizeThread(const QString &path, float ratio, QObject *parent)
  56 : ThreadWeaver::Job(parent)
  57 , m_path(path)
  58 , m_ratio(ratio)
  59 {
  60 }
  61
  62 ResizeThread::~ResizeThread() {
  63 }
  64
  65 void ResizeThread::start(QPersistentModelIndex index)
  66 {
  67     m_index = index;
  68     ThreadWeaver::Weaver::instance()->enqueue(this);
  69 }
  70
  71 bool ResizeThread::isInitialized() const
  72 {
  73     return m_index.isValid();
  74 }
  75
  76 void ResizeThread::run()
  77 {
  78     m_result = Background::createScreenshot(m_path, m_ratio);
  79 }
  80
  81 QImage ResizeThread::result() const
  82 {
  83     if (isFinished()) {
  84         return m_result;
  85     }
  86     else {
  87         return QImage();
  88     }
  89 }
  90
  91 QPersistentModelIndex ResizeThread::index() const
  92 {
  93     return m_index;
  94 }
  95
  96 Background::~Background()
  97 {
  98 }
  99
 100 QImage Background::createScreenshot(const QString &path, float ratio)
 101 {
 102     if (path.endsWith("svg") || path.endsWith("svgz")) {
 103         KSvgRenderer renderer(path);
 104         QImage img(QSize(int(SCREENSHOT_HEIGHT * ratio), SCREENSHOT_HEIGHT),
 105                    QImage::Format_ARGB32_Premultiplied);
 106         img.fill(0);
 107         QPainter p(&img);
 108         renderer.render(&p);
 109         return img;
 110     }
 111     else {
 112         QImage img(path);
 113         if (!img.isNull()) {
 114             return img.scaled(int(SCREENSHOT_HEIGHT * ratio),
 115                             SCREENSHOT_HEIGHT,
 116                             Qt::KeepAspectRatio);
 117         }
 118         else {
 119             return defaultScreenshot();
 120         }
 121     }
 122
 123 }
 124
 125 QImage Background::defaultScreenshot()
 126 {
 127     static QImage defaultScreenshotImage;
 128
 129     if (defaultScreenshotImage.isNull()) {
 130         QImage img(QSize(SCREENSHOT_HEIGHT, SCREENSHOT_HEIGHT), QImage::Format_ARGB32_Premultiplied);
 131         img.fill(Qt::white);
 132         QPainter p(&img);
 133         p.drawText(QRect(0, 0, SCREENSHOT_HEIGHT, SCREENSHOT_HEIGHT),
 134                    Qt::AlignHCenter | Qt::AlignVCenter,
 135                    "Preview\nnot\navailable");
 136         defaultScreenshotImage = img;
 137     }
 138     return defaultScreenshotImage;
 139 }
 140
 141
 142 class BackgroundPackageStructure : public PackageStructure
 143 {
 144 public:
 145     static const PackageStructure::Ptr self();
 146 private:
 147     BackgroundPackageStructure(); // should be used as a singleton
 148     void addResolution(const char *res);
 149 };
 150
 151 BackgroundPackageStructure::BackgroundPackageStructure()
 152 : PackageStructure(0, "Background")
 153 {
 154     QStringList mimetypes;
 155     mimetypes << "image/svg" << "image/png" << "image/jpeg" << "image/jpg";
 156     setDefaultMimetypes(mimetypes);
 157
 158     addDirectoryDefinition("images", "images", i18n("Images"));
 159     addFileDefinition("screenshot", "screenshot.png", i18n("Screenshot"));
 160 }
 161
 162
 163 const PackageStructure::Ptr BackgroundPackageStructure::self()
 164 {
 165     static BackgroundPackageStructure::Ptr instance(0);
 166
 167     if (!instance) {
 168         instance = new BackgroundPackageStructure;
 169     }
 170
 171     return instance;
 172 }
 173
 174
 175
 176 BackgroundPackage::BackgroundPackage(const QString &path, float ratio)
 177 : Package(path, BackgroundPackageStructure::self())
 178 , m_path(path)
 179 , m_ratio(ratio)
 180 {
 181 }
 182
 183 QString BackgroundPackage::resString(const QSize &size) const
 184 {
 185     return QString::number(size.width()) + 'x' + QString::number(size.height());
 186 }
 187
 188 QSize BackgroundPackage::resSize(const QString &str) const
 189 {
 190     int index = str.indexOf('x');
 191     if (index != -1) {
 192         return QSize(str.left(index).toInt(),
 193                      str.mid(index + 1).toInt());
 194     }
 195     else {
 196         return QSize();
 197     }
 198 }
 199
 200 QString BackgroundPackage::findBackground(const QSize &size,
 201                                           ResizeMethod method) const
 202 {
 203     QStringList images = entryList("images");
 204     if (images.empty()) {
 205         return QString();
 206     }
 207
 208     // choose the nearest resolution
 209     float best;
 210     QString bestImage;
 211     foreach (const QString &entry, images) {
 212         QSize candidate = resSize(QFileInfo(entry).baseName());
 213         if (candidate == QSize()) {
 214             continue;
 215         }
 216
 217         double dist = distance(candidate, size, method);
 218         kDebug() << "candidate" << candidate << "distance" << dist;
 219         if (bestImage.isNull() || dist < best) {
 220             bestImage = filePath("images", entry);
 221             best = dist;
 222             kDebug() << "best" << bestImage;
 223         }
 224     }
 225
 226     kDebug() << "best image" << bestImage;
 227     return bestImage;
 228 }
 229
 230 float BackgroundPackage::distance(const QSize& size,
 231                                    const QSize& desired,
 232                                    ResizeMethod method) const
 233 {
 234     // compute difference of areas
 235     float delta = size.width() * size.height() -
 236                   desired.width() * desired.height();
 237     // scale down to about 1.0
 238     delta /= 1000000.0;
 239
 240     switch (method) {
 241     case Scale: {
 242         // Consider first the difference in aspect ratio,
 243         // then in areas. Prefer scaling down.
 244         float deltaRatio = size.width() / size.height() -
 245                            desired.width() / desired.height();
 246         return fabs(deltaRatio) * 3.0 +
 247             (delta >= 0.0 ? delta : -delta + 5.0);
 248     }
 249     case ScaleCrop:
 250         // Difference of areas, slight preference to scale down
 251         return delta >= 0.0 ? delta : -delta + 2.0;
 252     case Center:
 253     default:
 254         // Difference in areas
 255         return fabs(delta);
 256     }
 257 }
 258
 259 QPixmap BackgroundPackage::screenshot() const
 260 {
 261     if (m_screenshot.isNull()) {
 262         QString screenshotPath = filePath("screenshot");
 263         if (!screenshotPath.isEmpty()) {
 264             QImage img = createScreenshot(screenshotPath, m_ratio);
 265             m_screenshot = QPixmap::fromImage(img);
 266         }
 267     }
 268
 269     return m_screenshot;
 270 }
 271
 272 bool BackgroundPackage::screenshotGenerationStarted() const
 273 {
 274     return true;
 275 }
 276
 277 void BackgroundPackage::generateScreenshot(QPersistentModelIndex) const
 278 {
 279 }
 280
 281 QString BackgroundPackage::title() const
 282 {
 283     return metadata()->name();
 284 }
 285
 286 QString BackgroundPackage::author() const
 287 {
 288     return metadata()->author();
 289 }
 290
 291 QString BackgroundPackage::email() const
 292 {
 293     return metadata()->email();
 294 }
 295
 296 QString BackgroundPackage::license() const
 297 {
 298     return metadata()->license();
 299 }
 300
 301 bool BackgroundPackage::isValid() const
 302 {
 303     return Package::isValid();
 304 }
 305
 306 QString BackgroundPackage::path() const
 307 {
 308     return m_path;
 309 }
 310
 311
 312 BackgroundFile::BackgroundFile(const QString &file, float ratio)
 313 : m_file(file)
 314 , m_ratio(ratio)
 315 , m_resizer_started(false)
 316 {
 317 }
 318
 319 BackgroundFile::~BackgroundFile()
 320 {
 321 }
 322
 323 QString BackgroundFile::findBackground(const QSize &,
 324                                        ResizeMethod) const
 325 {
 326     return m_file;
 327 }
 328
 329 QPixmap BackgroundFile::screenshot() const
 330 {
 331     return m_screenshot;
 332 }
 333
 334 bool BackgroundFile::screenshotGenerationStarted() const
 335 {
 336     return m_resizer_started;
 337 }
 338
 339 void BackgroundFile::generateScreenshot(QPersistentModelIndex index) const
 340 {
 341     ResizeThread *resizer = new ResizeThread(m_file, m_ratio);
 342     connect(resizer, SIGNAL(done(ThreadWeaver::Job *)),
 343             this, SLOT(updateScreenshot(ThreadWeaver::Job *)));
 344     m_resizer_started = true;
 345     resizer->start(index);
 346 }
 347
 348 void BackgroundFile::updateScreenshot(ThreadWeaver::Job *job)
 349 {
 350     ResizeThread *resizer = static_cast<ResizeThread *>(job);
 351     m_screenshot = QPixmap::fromImage(resizer->result());
 352     emit screenshotDone(resizer->index());
 353     resizer->deleteLater();
 354 }
 355
 356 QString BackgroundFile::author() const
 357 {
 358     return QString();
 359 }
 360
 361 QString BackgroundFile::title() const
 362 {
 363     return QFileInfo(m_file).baseName();
 364 }
 365
 366 QString BackgroundFile::email() const
 367 {
 368     return QString();
 369 }
 370
 371 QString BackgroundFile::license() const
 372 {
 373     return QString();
 374 }
 375
 376 bool BackgroundFile::isValid() const
 377 {
 378     return true;
 379 }
 380
 381 QString BackgroundFile::path() const
 382 {
 383     return m_file;
 384 }