kolourpaint/document/kpDocument_Open.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
  29 #define DEBUG_KP_DOCUMENT 0
  30
  31
  32 #include <kpDocument.h>
  33 #include <kpDocumentPrivate.h>
  34
  35 #include <math.h>
  36
  37 #include <qcolor.h>
  38 #include <qbitmap.h>
  39 #include <qbrush.h>
  40 #include <qfile.h>
  41 #include <qimage.h>
  42 #include <qlist.h>
  43 #include <qpixmap.h>
  44 #include <qpainter.h>
  45 #include <qrect.h>
  46 #include <qsize.h>
  47 #include <qmatrix.h>
  48
  49 #include <kdebug.h>
  50 #include <kglobal.h>
  51 #include <kimageio.h>
  52 #include <kio/netaccess.h>
  53 #include <klocale.h>
  54 #include <kmessagebox.h>
  55 #include <kmimetype.h>  // TODO: isn't this in KIO?
  56 #include <ktemporaryfile.h>
  57
  58 #include <kpColor.h>
  59 #include <kpColorToolBar.h>
  60 #include <kpDefs.h>
  61 #include <kpDocumentEnvironment.h>
  62 #include <kpDocumentSaveOptions.h>
  63 #include <kpDocumentMetaInfo.h>
  64 #include <kpEffectReduceColors.h>
  65 #include <kpPixmapFX.h>
  66 #include <kpTool.h>
  67 #include <kpToolToolBar.h>
  68 #include <kpUrlFormatter.h>
  69 #include <kpViewManager.h>
  70
  71
  72 QPixmap kpDocument::convertToPixmapAsLosslessAsPossible (
  73         const QImage &image,
  74         const kpPixmapFX::WarnAboutLossInfo &wali,
  75
  76         kpDocumentSaveOptions *saveOptions,
  77         kpDocumentMetaInfo *metaInfo)
  78 {
  79     if (image.isNull ())
  80         return QPixmap ();
  81
  82 #if DEBUG_KP_DOCUMENT
  83     kDebug () << "\timage: depth=" << image.depth ()
  84                 << " (X display=" << QPixmap::defaultDepth () << ")"
  85                 << " hasAlphaChannel=" << image.hasAlphaChannel ()
  86                 << endl;
  87 #endif
  88
  89     if (saveOptions)
  90     {
  91         saveOptions->setColorDepth (image.depth ());
  92         saveOptions->setDither (false);  // avoid double dithering when saving
  93     }
  94
  95     if (metaInfo)
  96     {
  97         metaInfo->setDotsPerMeterX (image.dotsPerMeterX ());
  98         metaInfo->setDotsPerMeterY (image.dotsPerMeterY ());
  99         metaInfo->setOffset (image.offset ());
 100
 101         QList <QString> keyList = image.textKeys ();
 102         for (QList <QString>::const_iterator it = keyList.constBegin ();
 103              it != keyList.constEnd ();
 104              it++)
 105         {
 106             metaInfo->setText (*it, image.text (*it));
 107         }
 108
 109     #if DEBUG_KP_DOCUMENT
 110         metaInfo->printDebug ("\tmetaInfo");
 111     #endif
 112     }
 113
 114 #if DEBUG_KP_DOCUMENT && 1
 115 {
 116     if (image.width () <= 16 && image.height () <= 16)
 117     {
 118         kDebug () << "Image dump:";
 119
 120         for (int y = 0; y < image.height (); y++)
 121         {
 122             for (int x = 0; x < image.width (); x++)
 123             {
 124                 const QRgb rgb = image.pixel (x, y);
 125                 fprintf (stderr, " %08X", rgb);
 126             }
 127             fprintf (stderr, "\n");
 128         }
 129     }
 130 }
 131 #endif
 132
 133
 134     QPixmap newPixmap = kpPixmapFX::convertToPixmapAsLosslessAsPossible (image, wali);
 135
 136
 137 #if DEBUG_KP_DOCUMENT && 1
 138 {
 139     const QImage image2 = kpPixmapFX::convertToQImage (newPixmap);
 140     kDebug () << "(Converted to pixmap) Image dump:";
 141
 142     bool differsFromOrgImage = false;
 143     unsigned long hash = 0;
 144     int numDiff = 0;
 145     for (int y = 0; y < image2.height (); y++)
 146     {
 147         for (int x = 0; x < image2.width (); x++)
 148         {
 149             const QRgb rgb = image2.pixel (x, y);
 150             hash += ((x % 2) + 1) * rgb;
 151             if (rgb != image.pixel (x, y))
 152             {
 153                 differsFromOrgImage = true;
 154                 numDiff++;
 155             }
 156             if (image2.width () <= 16 && image2.height () <= 16)
 157                 fprintf (stderr, " %08X", rgb);
 158         }
 159         if (image2.width () <= 16 && image2.height () <= 16)
 160             fprintf (stderr, "\n");
 161     }
 162
 163     kDebug () << "\tdiffersFromOrgImage="
 164                << differsFromOrgImage
 165                << " numDiff="
 166                << numDiff
 167                << " hash=" << hash << endl;
 168 }
 169 #endif
 170
 171     return newPixmap;
 172 }
 173
 174 // public static
 175 QPixmap kpDocument::getPixmapFromFile (const KUrl &url, bool suppressDoesntExistDialog,
 176                                        QWidget *parent,
 177                                        kpDocumentSaveOptions *saveOptions,
 178                                        kpDocumentMetaInfo *metaInfo)
 179 {
 180 #if DEBUG_KP_DOCUMENT
 181     kDebug () << "kpDocument::getPixmapFromFile(" << url << "," << parent << ")";
 182 #endif
 183
 184     if (saveOptions)
 185         *saveOptions = kpDocumentSaveOptions ();
 186
 187     if (metaInfo)
 188         *metaInfo = kpDocumentMetaInfo ();
 189
 190
 191     QString tempFile;
 192     if (url.isEmpty () || !KIO::NetAccess::download (url, tempFile, parent))
 193     {
 194         if (!suppressDoesntExistDialog)
 195         {
 196             // TODO: Use "Cannot" instead of "Could not" in all dialogs in KolourPaint.
 197             //       Or at least choose one consistently.
 198             //
 199             // TODO: Have captions for all dialogs in KolourPaint.
 200             KMessageBox::sorry (parent,
 201                                 i18n ("Could not open \"%1\".",
 202                                       kpUrlFormatter::PrettyFilename (url)));
 203         }
 204
 205         return QPixmap ();
 206     }
 207
 208
 209     QImage image;
 210
 211     // sync: remember to "KIO::NetAccess::removeTempFile (tempFile)" in all exit paths
 212     {
 213         QString detectedMimeType;
 214
 215         KMimeType::Ptr detectedMimeTypePtr = KMimeType::findByUrl (url);
 216         if(detectedMimeTypePtr &&
 217             detectedMimeTypePtr != KMimeType::defaultMimeTypePtr ())
 218         {
 219             detectedMimeType = detectedMimeTypePtr->name ();
 220         }
 221
 222         if (saveOptions)
 223             saveOptions->setMimeType (detectedMimeType);
 224
 225     #if DEBUG_KP_DOCUMENT
 226         kDebug () << "\ttempFile=" << tempFile;
 227         kDebug () << "\tmimetype=" << detectedMimeType;
 228         kDebug () << "\tsrc=" << url.path ();
 229     #endif
 230
 231         if (detectedMimeType.isEmpty ())
 232         {
 233             KMessageBox::sorry (parent,
 234                                 i18n ("Could not open \"%1\" - unknown mimetype.",
 235                                     kpUrlFormatter::PrettyFilename (url)));
 236             KIO::NetAccess::removeTempFile (tempFile);
 237             return QPixmap ();
 238         }
 239
 240
 241         // TODO: <detectedMimeType> might be different.
 242         //       Should we feed it into QImage to solve this problem?
 243         //
 244         //       If so, should we have used KMimeType::findByContent()
 245         //       instead?  Are some image types not detectable by findByContent()
 246         //       (e.g. image types that are only detected by extension)?
 247         //
 248         //       Currently, opening a PNG with a ".jpg" extension does not
 249         //       work -- QImage and findByUrl() both think it's a JPG based
 250         //       on the extension, but findByContent() correctly detects
 251         //       it as a PNG.
 252         image = QImage (tempFile);
 253         KIO::NetAccess::removeTempFile (tempFile);
 254     }
 255
 256     if (image.isNull ())
 257     {
 258         KMessageBox::sorry (parent,
 259                             i18n ("Could not open \"%1\" - unsupported image format.\n"
 260                                   "The file may be corrupt.",
 261                                   kpUrlFormatter::PrettyFilename (url)));
 262         return QPixmap ();
 263     }
 264
 265     const QPixmap newPixmap = kpDocument::convertToPixmapAsLosslessAsPossible (image,
 266         kpPixmapFX::WarnAboutLossInfo (
 267              ki18n ("<qt><p>The image \"%1\""
 268                     " may have more colors than the current screen mode can support."
 269                     " In order to display it, some color information may be removed.</p>"
 270
 271                     "<p><b>If you save this image, any color loss will become"
 272                     " permanent.</b></p>"
 273
 274                     "<p>To avoid this issue, increase your screen depth to at"
 275                     " least %2bpp and then restart KolourPaint.</p>"
 276
 277                     "<hr/>"
 278
 279                     "<p>It also"
 280
 281                     " contains translucency which is not fully"
 282                     " supported. The translucency data will be"
 283                     " approximated with a 1-bit transparency mask.</p>"
 284
 285                     "<p><b>If you save this image, this loss of translucency will"
 286                     " become permanent.</b></p></qt>")
 287                 .subs (kpUrlFormatter::PrettyFilename (url)),
 288              ki18n ("<qt><p>The image \"%1\""
 289                     " may have more colors than the current screen mode can support."
 290                     " In order to display it, some color information may be removed.</p>"
 291
 292                     "<p><b>If you save this image, any color loss will become"
 293                     " permanent.</b></p>"
 294
 295                     "<p>To avoid this issue, increase your screen depth to at"
 296                     " least %2bpp and then restart KolourPaint.</p></qt>")
 297                 .subs (kpUrlFormatter::PrettyFilename (url)),
 298              i18n ("<qt><p>The image \"%1\""
 299                    " contains translucency which is not fully"
 300                    " supported. The translucency data will be"
 301                    " approximated with a 1-bit transparency mask.</p>"
 302
 303                    "<p><b>If you save this image, this loss of translucency will"
 304                    " become permanent.</b></p></qt>",
 305                    kpUrlFormatter::PrettyFilename (url)),
 306             "docOpen",
 307             parent),
 308         saveOptions,
 309         metaInfo);
 310
 311     if (newPixmap.isNull ())
 312     {
 313         KMessageBox::sorry (parent,
 314                             i18n ("Could not open \"%1\" - out of graphics memory.",
 315                                   kpUrlFormatter::PrettyFilename (url)));
 316         return QPixmap ();
 317     }
 318
 319 #if DEBUG_KP_DOCUMENT
 320     kDebug () << "\tpixmap: depth=" << newPixmap.depth ()
 321                 << " hasAlphaChannelOrMask=" << newPixmap.hasAlpha ()
 322                 << " hasAlphaChannel=" << newPixmap.hasAlphaChannel ()
 323                 << endl;
 324 #endif
 325
 326
 327     return newPixmap;
 328 }
 329
 330 void kpDocument::openNew (const KUrl &url)
 331 {
 332 #if DEBUG_KP_DOCUMENT
 333     kDebug () << "kpDocument::openNew (" << url << ")";
 334 #endif
 335
 336     m_image->fill (Qt::white);
 337
 338     setURL (url, false/*not from url*/);
 339     // TODO: Maybe we should guess the mimetype from "url"'s filename
 340     //       extension.
 341     //
 342     //       That way "kolourpaint doesnotexist.bmp" would automatically
 343     //       select the BMP file format when the save dialog comes up for
 344     //       the first time.
 345     *m_saveOptions = kpDocumentSaveOptions ();
 346     *m_metaInfo = kpDocumentMetaInfo ();
 347     m_modified = false;
 348
 349     emit documentOpened ();
 350 }
 351
 352 bool kpDocument::open (const KUrl &url, bool newDocSameNameIfNotExist)
 353 {
 354 #if DEBUG_KP_DOCUMENT
 355     kDebug () << "kpDocument::open (" << url << ")";
 356 #endif
 357
 358     kpDocumentSaveOptions newSaveOptions;
 359     kpDocumentMetaInfo newMetaInfo;
 360     QPixmap newPixmap = kpDocument::getPixmapFromFile (url,
 361         newDocSameNameIfNotExist/*suppress "doesn't exist" dialog*/,
 362         d->environ->dialogParent (),
 363         &newSaveOptions,
 364         &newMetaInfo);
 365
 366     if (!newPixmap.isNull ())
 367     {
 368         delete m_image;
 369         m_image = new kpImage (newPixmap);
 370
 371         setURL (url, true/*is from url*/);
 372         *m_saveOptions = newSaveOptions;
 373         *m_metaInfo = newMetaInfo;
 374         m_modified = false;
 375
 376         emit documentOpened ();
 377         return true;
 378     }
 379
 380     if (newDocSameNameIfNotExist)
 381     {
 382         if (!url.isEmpty () &&
 383             // not just a permission error?
 384             !KIO::NetAccess::exists (url, KIO::NetAccess::SourceSide/*open*/, d->environ->dialogParent ()))
 385         {
 386             openNew (url);
 387         }
 388         else
 389         {
 390             openNew (KUrl ());
 391         }
 392
 393         return true;
 394     }
 395     else
 396     {
 397         return false;
 398     }
 399 }
 400