kolourpaint/document/kpDocumentSaveOptions.cpp

   1
   2 /*
   3    Copyright (c) 2003-2007 Clarence Dang <dang@kde.org>
   4    All rights reserved.
   5
   6    Redistribution and use in source and binary forms, with or without
   7    modification, are permitted provided that the following conditions
   8    are met:
   9
  10    1. Redistributions of source code must retain the above copyright
  11       notice, this list of conditions and the following disclaimer.
  12    2. Redistributions in binary form must reproduce the above copyright
  13       notice, this list of conditions and the following disclaimer in the
  14       documentation and/or other materials provided with the distribution.
  15
  16    THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  17    IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18    OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19    IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  20    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21    NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25    THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26 */
  27
  28 #define DEBUG_KP_DOCUMENT_SAVE_OPTIONS 0
  29
  30
  31 #include <kpDocumentSaveOptions.h>
  32
  33 #include <qbitmap.h>
  34 #include <qpixmap.h>
  35 #include <qstring.h>
  36
  37 #include <kconfiggroup.h>
  38 #include <kdebug.h>
  39 #include <kglobal.h>
  40 #include <ksharedconfig.h>
  41
  42 #include <kpDefs.h>
  43 #include <kpPixmapFX.h>
  44
  45
  46 class kpDocumentSaveOptionsPrivate
  47 {
  48 public:
  49     QString m_mimeType;
  50     int m_colorDepth;
  51     bool m_dither;
  52     int m_quality;
  53 };
  54
  55
  56 kpDocumentSaveOptions::kpDocumentSaveOptions ()
  57     : d (new kpDocumentSaveOptionsPrivate ())
  58 {
  59     d->m_mimeType = invalidMimeType ();
  60     d->m_colorDepth = invalidColorDepth ();
  61     d->m_dither = initialDither ();
  62     d->m_quality = invalidQuality ();
  63 }
  64
  65 kpDocumentSaveOptions::kpDocumentSaveOptions (const kpDocumentSaveOptions &rhs)
  66     : d (new kpDocumentSaveOptionsPrivate ())
  67 {
  68     d->m_mimeType = rhs.mimeType ();
  69     d->m_colorDepth = rhs.colorDepth ();
  70     d->m_dither = rhs.dither ();
  71     d->m_quality = rhs.quality ();
  72 }
  73
  74 kpDocumentSaveOptions::kpDocumentSaveOptions (QString mimeType, int colorDepth, bool dither, int quality)
  75     : d (new kpDocumentSaveOptionsPrivate ())
  76 {
  77     d->m_mimeType = mimeType;
  78     d->m_colorDepth = colorDepth;
  79     d->m_dither = dither;
  80     d->m_quality = quality;
  81 }
  82
  83 kpDocumentSaveOptions::~kpDocumentSaveOptions ()
  84 {
  85     delete d;
  86 }
  87
  88
  89 // public
  90 bool kpDocumentSaveOptions::operator== (const kpDocumentSaveOptions &rhs) const
  91 {
  92     return (mimeType () == rhs.mimeType () &&
  93             colorDepth () == rhs.colorDepth () &&
  94             dither () == rhs.dither () &&
  95             quality () == rhs.quality ());
  96 }
  97
  98 // public
  99 bool kpDocumentSaveOptions::operator!= (const kpDocumentSaveOptions &rhs) const
 100 {
 101     return !(*this == rhs);
 102 }
 103
 104
 105 // public
 106 kpDocumentSaveOptions &kpDocumentSaveOptions::operator= (const kpDocumentSaveOptions &rhs)
 107 {
 108     setMimeType (rhs.mimeType ());
 109     setColorDepth (rhs.colorDepth ());
 110     setDither (rhs.dither ());
 111     setQuality (rhs.quality ());
 112
 113     return *this;
 114 }
 115
 116
 117 // public
 118 void kpDocumentSaveOptions::printDebug (const QString &prefix) const
 119 {
 120     const QString usedPrefix = !prefix.isEmpty () ?
 121                                    prefix + QLatin1String (": ") :
 122                                    QString();
 123
 124     kDebug () << usedPrefix
 125                << "mimeType=" << mimeType ()
 126                << " colorDepth=" << colorDepth ()
 127                << " dither=" << dither ()
 128                << " quality=" << quality ()
 129                << endl;
 130 }
 131
 132
 133 // public
 134 QString kpDocumentSaveOptions::mimeType () const
 135 {
 136     return d->m_mimeType;
 137 }
 138
 139 // public
 140 void kpDocumentSaveOptions::setMimeType (const QString &mimeType)
 141 {
 142     d->m_mimeType = mimeType;
 143 }
 144
 145
 146 // public static
 147 QString kpDocumentSaveOptions::invalidMimeType ()
 148 {
 149     return QString();
 150 }
 151
 152 // public static
 153 bool kpDocumentSaveOptions::mimeTypeIsInvalid (const QString &mimeType)
 154 {
 155     return (mimeType == invalidMimeType ());
 156 }
 157
 158 // public
 159 bool kpDocumentSaveOptions::mimeTypeIsInvalid () const
 160 {
 161     return mimeTypeIsInvalid (mimeType ());
 162 }
 163
 164
 165 // public
 166 int kpDocumentSaveOptions::colorDepth () const
 167 {
 168     return d->m_colorDepth;
 169 }
 170
 171 // public
 172 void kpDocumentSaveOptions::setColorDepth (int depth)
 173 {
 174     d->m_colorDepth = depth;
 175 }
 176
 177
 178 // public static
 179 int kpDocumentSaveOptions::invalidColorDepth ()
 180 {
 181     return -1;
 182 }
 183
 184 // public static
 185 bool kpDocumentSaveOptions::colorDepthIsInvalid (int colorDepth)
 186 {
 187     return (colorDepth != 1 && colorDepth != 8 && colorDepth != 32);
 188 }
 189
 190 // public
 191 bool kpDocumentSaveOptions::colorDepthIsInvalid () const
 192 {
 193     return colorDepthIsInvalid (colorDepth ());
 194 }
 195
 196
 197 // public
 198 bool kpDocumentSaveOptions::dither () const
 199 {
 200     return d->m_dither;
 201 }
 202
 203 // public
 204 void kpDocumentSaveOptions::setDither (bool dither)
 205 {
 206     d->m_dither = dither;
 207 }
 208
 209
 210 // public static
 211 int kpDocumentSaveOptions::initialDither ()
 212 {
 213     return false;  // to avoid accidental double dithering
 214 }
 215
 216
 217 // public
 218 int kpDocumentSaveOptions::quality () const
 219 {
 220     return d->m_quality;
 221 }
 222
 223 // public
 224 void kpDocumentSaveOptions::setQuality (int quality)
 225 {
 226     d->m_quality = quality;
 227 }
 228
 229
 230 // public static
 231 int kpDocumentSaveOptions::invalidQuality ()
 232 {
 233     return -2;
 234 }
 235
 236 // public static
 237 bool kpDocumentSaveOptions::qualityIsInvalid (int quality)
 238 {
 239     return (quality < -1 || quality > 100);
 240 }
 241
 242 // public
 243 bool kpDocumentSaveOptions::qualityIsInvalid () const
 244 {
 245     return qualityIsInvalid (quality ());
 246 }
 247
 248
 249 // public static
 250 QString kpDocumentSaveOptions::defaultMimeType (const KConfigGroup &config)
 251 {
 252     return config.readEntry (kpSettingForcedMimeType,
 253                               QString::fromLatin1 ("image/png"));
 254 }
 255
 256 // public static
 257 void kpDocumentSaveOptions::saveDefaultMimeType (KConfigGroup &config,
 258                                                  const QString &mimeType)
 259 {
 260     config.writeEntry (kpSettingForcedMimeType, mimeType);
 261 }
 262
 263
 264 // public static
 265 int kpDocumentSaveOptions::defaultColorDepth (const KConfigGroup &config)
 266 {
 267     int colorDepth =
 268         config.readEntry (kpSettingForcedColorDepth, -1);
 269
 270     if (colorDepthIsInvalid (colorDepth))
 271     {
 272         // (not screen depth, in case of transparency)
 273         colorDepth = 32;
 274     }
 275
 276     return colorDepth;
 277 }
 278
 279 // public static
 280 void kpDocumentSaveOptions::saveDefaultColorDepth (KConfigGroup &config, int colorDepth)
 281 {
 282     config.writeEntry (kpSettingForcedColorDepth, colorDepth);
 283 }
 284
 285
 286 // public static
 287 int kpDocumentSaveOptions::defaultDither (const KConfigGroup &config)
 288 {
 289     return config.readEntry (kpSettingForcedDither, initialDither ());
 290 }
 291
 292 // public static
 293 void kpDocumentSaveOptions::saveDefaultDither (KConfigGroup &config, bool dither)
 294 {
 295     config.writeEntry (kpSettingForcedDither, dither);
 296 }
 297
 298
 299 // public static
 300 int kpDocumentSaveOptions::defaultQuality (const KConfigGroup &config)
 301 {
 302     int val = config.readEntry (kpSettingForcedQuality, -1);
 303     if (qualityIsInvalid (val))
 304         val = -1;
 305
 306     return val;
 307 }
 308
 309 // public static
 310 void kpDocumentSaveOptions::saveDefaultQuality (KConfigGroup &config, int quality)
 311 {
 312     config.writeEntry (kpSettingForcedQuality, quality);
 313 }
 314
 315
 316 // public static
 317 kpDocumentSaveOptions kpDocumentSaveOptions::defaultDocumentSaveOptions (const KConfigGroup &config)
 318 {
 319     kpDocumentSaveOptions saveOptions;
 320     saveOptions.setMimeType (defaultMimeType (config));
 321     saveOptions.setColorDepth (defaultColorDepth (config));
 322     saveOptions.setDither (defaultDither (config));
 323     saveOptions.setQuality (defaultQuality (config));
 324
 325 #if DEBUG_KP_DOCUMENT_SAVE_OPTIONS
 326     saveOptions.printDebug ("kpDocumentSaveOptions::defaultDocumentSaveOptions()");
 327 #endif
 328
 329     return saveOptions;
 330 }
 331
 332 // public static
 333 bool kpDocumentSaveOptions::saveDefaultDifferences (KConfigGroup &config,
 334                                                     const kpDocumentSaveOptions &oldDocInfo,
 335                                                     const kpDocumentSaveOptions &newDocInfo)
 336 {
 337     bool savedSomething = false;
 338
 339 #if DEBUG_KP_DOCUMENT_SAVE_OPTIONS
 340     kDebug () << "kpDocumentSaveOptions::saveDefaultDifferences()";
 341     oldDocInfo.printDebug ("\told");
 342     newDocInfo.printDebug ("\tnew");
 343 #endif
 344
 345     if (newDocInfo.mimeType () != oldDocInfo.mimeType ())
 346     {
 347         saveDefaultMimeType (config, newDocInfo.mimeType ());
 348         savedSomething = true;
 349     }
 350
 351     if (newDocInfo.colorDepth () != oldDocInfo.colorDepth ())
 352     {
 353         saveDefaultColorDepth (config, newDocInfo.colorDepth ());
 354         savedSomething = true;
 355     }
 356
 357     if (newDocInfo.dither () != oldDocInfo.dither ())
 358     {
 359         saveDefaultDither (config, newDocInfo.dither ());
 360         savedSomething = true;
 361     }
 362
 363     if (newDocInfo.quality () != oldDocInfo.quality ())
 364     {
 365         saveDefaultQuality (config, newDocInfo.quality ());
 366         savedSomething = true;
 367     }
 368
 369     return savedSomething;
 370 }
 371
 372
 373 static QStringList mimeTypesSupportingProperty (const QString &property,
 374     const QStringList &defaultMimeTypesWithPropertyList)
 375 {
 376     QStringList mimeTypeList;
 377
 378     KConfigGroup cfg (KGlobal::config (), kpSettingsGroupMimeTypeProperties);
 379
 380     if (cfg.hasKey (property))
 381     {
 382         mimeTypeList = cfg.readEntry (property, QStringList ());
 383     }
 384     else
 385     {
 386         mimeTypeList = defaultMimeTypesWithPropertyList;
 387
 388         cfg.writeEntry (property, mimeTypeList);
 389         cfg.sync ();
 390     }
 391
 392     return mimeTypeList;
 393 }
 394
 395 static bool mimeTypeSupportsProperty (const QString &mimeType,
 396     const QString &property, const QStringList &defaultMimeTypesWithPropertyList)
 397 {
 398     const QStringList mimeTypeList = mimeTypesSupportingProperty (
 399         property, defaultMimeTypesWithPropertyList);
 400
 401     return mimeTypeList.contains (mimeType);
 402 }
 403
 404
 405 // SYNC: update mime info
 406 //
 407 // Only care about writable mimetypes.
 408 //
 409 // Run:
 410 //
 411 //     branches/kolourpaint/control/scripts/gen_mimetype_line.sh Write |
 412 //         branches/kolourpaint/control/scripts/split_mimetype_line.pl
 413 //
 414 // in the version of kdelibs/kimgio/ (e.g. KDE 4.0) KolourPaint is shipped with,
 415 // to check for any new mimetypes to add info for.  In the methods below,
 416 // you can specify this info (maximum color depth, whether it's lossy etc.).
 417 //
 418 // Update the below list and if you do change any of that info, bump up
 419 // "kpSettingsGroupMimeTypeProperties" in kpDefs.h.
 420 //
 421 // Currently, Depth and Quality settings are mutually exclusive with
 422 // Depth overriding Quality.  I've currently favoured Quality with the
 423 // below mimetypes (i.e. all lossy mimetypes are only given Quality settings,
 424 // no Depth settings).
 425 //
 426 // Mimetypes done:
 427 //  image/bmp
 428 //  image/jpeg
 429 //  image/jpeg2000 [COULD NOT TEST]
 430 //  image/png
 431 //  image/tiff
 432 //  image/x-eps
 433 //  image/x-pcx
 434 //  image/x-portable-bitmap
 435 //  image/x-portable-graymap
 436 //  image/x-portable-pixmap
 437 //  image/x-rgb
 438 //  image/x-tga
 439 //  image/x-xbitmap
 440 //  image/x-xpixmap
 441 //  video/x-mng [COULD NOT TEST]
 442 //
 443 // To test whether depth is configurable, write an image in the new
 444 // mimetype with all depths and read each one back.  See what
 445 // kpDocument thinks the depth is when it gets QImage to read it.
 446
 447
 448 // public static
 449 int kpDocumentSaveOptions::mimeTypeMaximumColorDepth (const QString &mimeType)
 450 {
 451     QStringList defaultList;
 452
 453     // SYNC: update mime info here
 454
 455     // Grayscale actually (unenforced since depth not set to configurable)
 456     defaultList << QLatin1String ("image/x-eps:32");
 457
 458     defaultList << QLatin1String ("image/x-portable-bitmap:1");
 459
 460     // Grayscale actually (unenforced since depth not set to configurable)
 461     defaultList << QLatin1String ("image/x-portable-graymap:8");
 462
 463     defaultList << QLatin1String ("image/x-xbitmap:1");
 464
 465     const QStringList mimeTypeList = mimeTypesSupportingProperty (
 466         kpSettingMimeTypeMaximumColorDepth, defaultList);
 467
 468     const QString mimeTypeColon = mimeType + QLatin1String (":");
 469     for (QStringList::const_iterator it = mimeTypeList.begin ();
 470          it != mimeTypeList.end ();
 471          it++)
 472     {
 473         if ((*it).startsWith (mimeTypeColon))
 474         {
 475             int number = (*it).mid (mimeTypeColon.length ()).toInt ();
 476             if (!colorDepthIsInvalid (number))
 477             {
 478                 return number;
 479             }
 480         }
 481     }
 482
 483     return 32;
 484 }
 485
 486 // public
 487 int kpDocumentSaveOptions::mimeTypeMaximumColorDepth () const
 488 {
 489     return mimeTypeMaximumColorDepth (mimeType ());
 490 }
 491
 492
 493 // public static
 494 bool kpDocumentSaveOptions::mimeTypeHasConfigurableColorDepth (const QString &mimeType)
 495 {
 496     QStringList defaultMimeTypes;
 497
 498     // SYNC: update mime info here
 499     defaultMimeTypes << QLatin1String ("image/png");
 500     defaultMimeTypes << QLatin1String ("image/bmp");
 501     defaultMimeTypes << QLatin1String ("image/x-pcx");
 502
 503     // TODO: Only 1, 24 not 8; Qt only sees 32 but "file" cmd realises
 504     //       it's either 1 or 24.
 505     defaultMimeTypes << QLatin1String ("image/x-rgb");
 506
 507     // TODO: Only 8 and 24 - no 1.
 508     defaultMimeTypes << QLatin1String ("image/x-xpixmap");
 509
 510     return mimeTypeSupportsProperty (mimeType,
 511         kpSettingMimeTypeHasConfigurableColorDepth,
 512         defaultMimeTypes);
 513 }
 514
 515 // public
 516 bool kpDocumentSaveOptions::mimeTypeHasConfigurableColorDepth () const
 517 {
 518     return mimeTypeHasConfigurableColorDepth (mimeType ());
 519 }
 520
 521
 522 // public static
 523 bool kpDocumentSaveOptions::mimeTypeHasConfigurableQuality (const QString &mimeType)
 524 {
 525     QStringList defaultMimeTypes;
 526
 527     // SYNC: update mime info here
 528     defaultMimeTypes << QLatin1String ("image/jpeg2000");
 529     defaultMimeTypes << QLatin1String ("image/jpeg");
 530
 531     return mimeTypeSupportsProperty (mimeType,
 532         kpSettingMimeTypeHasConfigurableQuality,
 533         defaultMimeTypes);
 534 }
 535
 536 // public
 537 bool kpDocumentSaveOptions::mimeTypeHasConfigurableQuality () const
 538 {
 539     return mimeTypeHasConfigurableQuality (mimeType ());
 540 }
 541
 542
 543 // public
 544 int kpDocumentSaveOptions::isLossyForSaving (const QPixmap &pixmap) const
 545 {
 546     int ret = 0;
 547
 548     if (mimeTypeMaximumColorDepth () < pixmap.depth ())
 549     {
 550         ret |= MimeTypeMaximumColorDepthLow;
 551     }
 552
 553     if (mimeTypeHasConfigurableColorDepth () &&
 554         !colorDepthIsInvalid () /*REFACTOR: guarantee it is valid*/ &&
 555         (colorDepth () < pixmap.depth () ||
 556          colorDepth () < 32 && kpPixmapFX::hasMask (pixmap)))
 557     {
 558         ret |= ColorDepthLow;
 559     }
 560
 561     if (mimeTypeHasConfigurableQuality () &&
 562         !qualityIsInvalid ())
 563     {
 564         ret |= Quality;
 565     }
 566
 567     return ret;
 568 }
 569