kolourpaint/pixmapfx/kpPixmapFX_MaskOps.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_PIXMAP_FX 0
  30
  31
  32 #include <kpPixmapFX.h>
  33
  34 #include <cstdlib>
  35 #include <cmath>
  36 #include <sys/types.h>
  37 #include <sys/wait.h>
  38 #include <unistd.h>
  39
  40 #include <qapplication.h>
  41 #include <qbitmap.h>
  42 #include <qdatetime.h>
  43 #include <qimage.h>
  44 #include <qpainter.h>
  45 #include <qpainterpath.h>
  46 #include <qpixmap.h>
  47 #include <qpoint.h>
  48 #include <qpolygon.h>
  49 #include <qrect.h>
  50
  51 #include <KApplication>
  52 #include <kconfig.h>
  53 #include <kconfiggroup.h>
  54 #include <kdebug.h>
  55 #include <kglobal.h>
  56 #include <klocale.h>
  57 #include <kmessagebox.h>
  58
  59 #include <kpAbstractSelection.h>
  60 #include <kpColor.h>
  61 #include <kpDefs.h>
  62 #include <kpTool.h>
  63
  64
  65 #if DEBUG_KP_PIXMAP_FX
  66     #define KP_PRINTF if (1) printf
  67 #else
  68     #define KP_PRINTF if (0) (void)
  69 #endif
  70
  71
  72 #ifdef Q_WS_X11
  73 // Same as QPixmap::defaultDepth(), but returns a meaningful answer when
  74 // called before QApplication has been constructed, rather than always 32.
  75 // After QApplication has been constructed, you must use QPixmap::defaultDepth()
  76 // instead.
  77 //
  78 // Returns 0 if it encounters an error.
  79 //
  80 // Internally, this method forks the process.  In the child, a KApplication
  81 // is constructed, QPixmap::defaultDepth() is called and the result is sent to
  82 // the parent.  The child is then killed.
  83 static int QPixmapCalculateDefaultDepthWithoutQApplication ()
  84 {
  85     KP_PRINTF (("QPixmapCalculateDefaultDepthWithoutQApplication()\n"));
  86
  87     // [0] = read
  88     // [1] = write
  89     enum
  90     {
  91         Read = 0, Write = 1
  92     };
  93     int fds [2];
  94     if (pipe (fds) != 0)
  95     {
  96         perror ("pipe");
  97         return 0;
  98     }
  99
 100     pid_t pid = fork ();
 101     if (pid == -1)
 102     {
 103         perror ("fork");
 104         close (fds [Read]);
 105         close (fds [Write]);
 106         return 0;
 107     }
 108
 109     // In child?
 110     if (pid == 0)
 111     {
 112         KP_PRINTF ("Child: created\n");
 113         close (fds [Read]);
 114
 115         KApplication app;
 116
 117         const int depth = QPixmap::defaultDepth ();
 118         KP_PRINTF (("Child: writing default depth\n"));
 119         write (fds [Write], &depth, sizeof (depth));
 120         KP_PRINTF (("Child: wrote default depth\n"));
 121
 122         close (fds [Write]);
 123         KP_PRINTF ("Child: exit\n");
 124         exit (0);
 125     }
 126     // In parent?
 127     else
 128     {
 129         KP_PRINTF ("Parent: in here\n");
 130         close (fds [Write]);
 131
 132         int depth = 0;
 133         KP_PRINTF ("Parent: reading default depth\n");
 134         read (fds [Read], &depth, sizeof (depth));
 135         KP_PRINTF ("Parent: read default depth %d\n", depth);
 136
 137         close (fds [Read]);
 138
 139         // Kill zombie child.
 140         KP_PRINTF ("Parent: waiting for child\n");
 141         int status;
 142         (void) waitpid (pid, &status, 0/*options*/);
 143
 144         KP_PRINTF ("Parent: complete\n");
 145         return depth;
 146     }
 147 }
 148 #endif
 149
 150
 151 // public static
 152 // (KApplication has not been constructed yet)
 153 void kpPixmapFX::initMaskOpsPre ()
 154 {
 155 #ifdef Q_WS_X11
 156     const int defaultDepth = QPixmapCalculateDefaultDepthWithoutQApplication ();
 157
 158     // This is important for diagnosing KolourPaint bugs so always print it
 159     // -- even in release mode.
 160     printf ("Starting KolourPaint on a %d-bit screen...\n", defaultDepth);
 161
 162     if (defaultDepth == 32)
 163     {
 164         KP_PRINTF ("\tCannot handle alpha channel - disabling XRENDER\n");
 165
 166         // SYNC: Might break with Qt upgrades.
 167         setenv ("QT_X11_NO_XRENDER", "1", 1/*overwrite value*/);
 168     }
 169 #else
 170 #ifdef __GNUC__
 171     #warning "KolourPaint is heavily dependent on the behavior of QPixmap under X11."
 172     #warning "Until KolourPaint gets a proper image library, it is unlikely to work under non-X11."
 173 #endif
 174 #endif
 175 }
 176
 177 // public static
 178 void kpPixmapFX::initMaskOpsPost ()
 179 {
 180 #if DEBUG_KP_PIXMAP_FX
 181     kDebug () << "kpPixmapFX::initMaskOpsPost():"
 182               << "QPixmap().depth()=" << QPixmap ().depth ()
 183               << "QPixmap::defaultDepth()=" << QPixmap::defaultDepth ();
 184 #endif
 185
 186     // Check KolourPaint invariant.
 187     KP_PFX_CHECK_NO_ALPHA_CHANNEL (QPixmap ());
 188     KP_PFX_CHECK_NO_ALPHA_CHANNEL (QPixmap (1, 1));
 189     Q_ASSERT (QPixmap (1, 1).depth () == QPixmap::defaultDepth ());
 190
 191     // initMaskOpsPre() should have ensured this (if it was 32 previously, it
 192     // should now be 24 due to the disabling of XRENDER).
 193     Q_ASSERT (QPixmap::defaultDepth () < 32);
 194 }
 195
 196
 197 // public static
 198 bool kpPixmapFX::hasMask (const QPixmap &pixmap)
 199 {
 200     return pixmap.hasAlpha ();
 201 }
 202
 203 // public static
 204 bool kpPixmapFX::hasAlphaChannel (const QPixmap &pixmap)
 205 {
 206     return pixmap.hasAlphaChannel ();
 207 }
 208
 209 // public static
 210 bool kpPixmapFX::checkNoAlphaChannelInternal (const QPixmap &pixmap)
 211 {
 212     if (!kpPixmapFX::hasAlphaChannel (pixmap))
 213         return true;
 214
 215 #if 1
 216     kError () << "Pixmap has alpha channel.  See the .h doc for"
 217                  " kpPixmapFX::ensureNoAlphaChannel() to fix this.";
 218     // Ignore bug rather than crashing the program because I bet developers
 219     // will inadvertently trigger this, when changing the code.  The bug has
 220     // very annoying effects under XRENDER but only causes serious failure
 221     // without XRENDER (which is not so common).
 222     return true;
 223 #else
 224     // Assert-crash the program.
 225     return false;
 226 #endif
 227 }
 228
 229
 230 // public static
 231 void kpPixmapFX::ensureNoAlphaChannel (QPixmap *destPixmapPtr)
 232 {
 233     Q_ASSERT (destPixmapPtr);
 234
 235     if (kpPixmapFX::hasAlphaChannel (*destPixmapPtr))
 236     {
 237         // We need to change <destPixmapPtr> from 32-bit (RGBA
 238         // i.e. hasAlphaChannel() returns true -- regardless of whether the
 239         // channel has any actual content -- which causes trouble) to 24-bit
 240         // (RGB with possible mask).
 241         //
 242         // "destPixmapPtr->setMask (destPixmapPtr->mask())" is not
 243         //  sufficient so do it a long way:
 244
 245         QPixmap oldPixmap = *destPixmapPtr;
 246
 247         QBitmap oldMask = oldPixmap.mask ();
 248         // Kill RGB source mask in case it causes alpha channel / composition
 249         // operations in the following copy.
 250         oldPixmap.setMask (QBitmap ());
 251
 252         // Copy RGB layer.
 253         *destPixmapPtr = QPixmap (oldPixmap.width (), oldPixmap.height ());
 254         QPainter p (destPixmapPtr);
 255         p.drawPixmap (QPoint (0, 0), oldPixmap);
 256         p.end ();
 257
 258         // Copy mask layer (if any).
 259         destPixmapPtr->setMask (oldMask);
 260     }
 261
 262     // Note that we don't check this on function entry as the purpose of
 263     // this function is to force the pixmap to satisfy this invariant.
 264     KP_PFX_CHECK_NO_ALPHA_CHANNEL (*destPixmapPtr);
 265 }
 266
 267
 268 // public static
 269 QBitmap kpPixmapFX::getNonNullMask (const QPixmap &pm)
 270 {
 271     KP_PFX_CHECK_NO_ALPHA_CHANNEL (pm);
 272
 273     // (a bit slow so we cache it)
 274     const QBitmap mask = pm.mask ();
 275
 276     if (!mask.isNull ())
 277         return mask;
 278     else
 279     {
 280         QBitmap maskBitmap (pm.width (), pm.height ());
 281         maskBitmap.fill (Qt::color1/*opaque*/);
 282
 283         return maskBitmap;
 284     }
 285 }
 286
 287
 288 // public static
 289 void kpPixmapFX::ensureTransparentAt (QPixmap *destPixmapPtr, const QRect &destRect)
 290 {
 291     if (!destPixmapPtr)
 292         return;
 293
 294     KP_PFX_CHECK_NO_ALPHA_CHANNEL (*destPixmapPtr);
 295
 296     QBitmap maskBitmap = getNonNullMask (*destPixmapPtr);
 297
 298     QPainter p (&maskBitmap);
 299     p.fillRect (destRect, Qt::color0/*transparent*/);
 300     p.end ();
 301
 302     destPixmapPtr->setMask (maskBitmap);
 303
 304     KP_PFX_CHECK_NO_ALPHA_CHANNEL (*destPixmapPtr);
 305 }
 306
 307
 308 // public static
 309 void kpPixmapFX::paintMaskTransparentWithBrush (QPixmap *destPixmapPtr, const QPoint &destAt,
 310                                                 const QPixmap &brushBitmap)
 311 {
 312 #if DEBUG_KP_PIXMAP_FX
 313     kDebug () << "kpPixmapFX::paintMaskTransparentWithBrush(destAt="
 314               << destAt << ") brushRect=" << brushBitmap.rect ()
 315               << endl;
 316 #endif
 317
 318     Q_ASSERT (destPixmapPtr);
 319
 320     KP_PFX_CHECK_NO_ALPHA_CHANNEL (*destPixmapPtr);
 321
 322     Q_ASSERT (brushBitmap.depth () == 1);
 323
 324     const QRegion brushRegion = QRegion (brushBitmap).translated (destAt);
 325
 326     // OPT: Hopelessly inefficent due to function call overhead and
 327     //      fillRect() changing the mask every single iteration.
 328     //
 329     //      kpPixmapFX should have a function that does this with only a
 330     //      single mask write.
 331     foreach (const QRect &r, brushRegion.rects ())
 332     {
 333     #if DEBUG_KP_PIXMAP_FX && 0
 334         kDebug () << "\tcopy rect=" << r;
 335     #endif
 336         kpPixmapFX::fillRect (destPixmapPtr,
 337             r.x (), r.y (), r.width (), r.height (),
 338             kpColor::Transparent);
 339     }
 340
 341     KP_PFX_CHECK_NO_ALPHA_CHANNEL (*destPixmapPtr);
 342 }
 343
 344 // public static
 345 void kpPixmapFX::paintMaskTransparentWithBrush (QPixmap *destPixmapPtr, int destX, int destY,
 346                                                 const QPixmap &brushBitmap)
 347 {
 348     kpPixmapFX::paintMaskTransparentWithBrush (destPixmapPtr,
 349                                                QPoint (destX, destY),
 350                                                brushBitmap);
 351 }
 352
 353
 354 // public static
 355 void kpPixmapFX::ensureOpaqueAt (QPixmap *destPixmapPtr, const QRect &destRect)
 356 {
 357     if (!destPixmapPtr)
 358         return;
 359
 360     KP_PFX_CHECK_NO_ALPHA_CHANNEL (*destPixmapPtr);
 361
 362     // (a bit slow so we cache it)
 363     QBitmap maskBitmap = destPixmapPtr->mask ();
 364
 365     // Already opaque?
 366     if (maskBitmap.isNull ())
 367         return;
 368
 369     QPainter p (&maskBitmap);
 370     p.fillRect (destRect, Qt::color1/*opaque*/);
 371     p.end ();
 372
 373     destPixmapPtr->setMask (maskBitmap);
 374
 375     KP_PFX_CHECK_NO_ALPHA_CHANNEL (*destPixmapPtr);
 376 }
 377
 378
 379