include fixlet

1 files changed, 2 insertions, 0 deletions

diff --git a/noncore/styles/theme/ogfxeffect.cpp b/noncore/styles/theme/ogfxeffect.cpp
index cc5bbcd..2071a67 100644
--- a/noncore/styles/theme/ogfxeffect.cpp
+++ b/noncore/styles/theme/ogfxeffect.cpp
@@ -1,144 +1,146 @@
 /* This file is part of the KDE libraries
     Copyright (C) 1998, 1999 Christian Tibirna <ctibirna@total.net>
               (C) 1998, 1999 Daniel M. Duley <mosfet@kde.org>
               (C) 1998, 1999 Dirk A. Mueller <mueller@kde.org>
 
 */
 
 // $Id$
 
 #include <qimage.h>
 #include <qpainter.h>
 
 #include <qpe/qmath.h>
 
 #include "ogfxeffect.h"
 
+#include <cstdlib>
+#include <cmath>
 
 //======================================================================
 //
 // Gradient effects
 //
 //======================================================================
 
 
 QPixmap& OGfxEffect::gradient(QPixmap &pixmap, const QColor &ca,
         const QColor &cb, GradientType eff, int ncols)
 {
         QImage image = gradient(pixmap.size(), ca, cb, eff, ncols);
         pixmap.convertFromImage(image);
 
         return pixmap;
 }
 
 QImage OGfxEffect::gradient(const QSize &size, const QColor &ca,
                             const QColor &cb, GradientType eff, int /*ncols*/)
 {    
         int rDiff, gDiff, bDiff;
         int rca, gca, bca, rcb, gcb, bcb;
         
         QImage image(size, 32);
 
         if (size.width() == 0 || size.height() == 0) {
                 qDebug ( "WARNING: OGfxEffect::gradient: invalid image" );
                 return image;
         }
 
     register int x, y;
 
     rDiff = (rcb = cb.red())   - (rca = ca.red());
     gDiff = (gcb = cb.green()) - (gca = ca.green());
     bDiff = (bcb = cb.blue())  - (bca = ca.blue());
 
     if( eff == VerticalGradient || eff == HorizontalGradient ){
 
         uint *p;
         uint rgb;
 
         register int rl = rca << 16;
         register int gl = gca << 16;
         register int bl = bca << 16;
 
         if( eff == VerticalGradient ) {
 
             int rcdelta = ((1<<16) / size.height()) * rDiff;
             int gcdelta = ((1<<16) / size.height()) * gDiff;
             int bcdelta = ((1<<16) / size.height()) * bDiff;
 
             for ( y = 0; y < size.height(); y++ ) {
                 p = (uint *) image.scanLine(y);
 
                 rl += rcdelta;
                 gl += gcdelta;
                 bl += bcdelta;
 
                 rgb = qRgb( (rl>>16), (gl>>16), (bl>>16) );
 
                 for( x = 0; x < size.width(); x++ ) {
                     *p = rgb;
                     p++;
                 }
             }
 
         }
         else {                  // must be HorizontalGradient
 
             unsigned int *o_src = (unsigned int *)image.scanLine(0);
             unsigned int *src = o_src;
 
             int rcdelta = ((1<<16) / size.width()) * rDiff;
             int gcdelta = ((1<<16) / size.width()) * gDiff;
             int bcdelta = ((1<<16) / size.width()) * bDiff;
 
             for( x = 0; x < size.width(); x++) {
 
                 rl += rcdelta;
                 gl += gcdelta;
                 bl += bcdelta;
 
                 *src++ = qRgb( (rl>>16), (gl>>16), (bl>>16));
             }
 
             src = o_src;
 
             // Believe it or not, manually copying in a for loop is faster
             // than calling memcpy for each scanline (on the order of ms...).
             // I think this is due to the function call overhead (mosfet).
 
             for (y = 1; y < size.height(); ++y) {
 
                 p = (unsigned int *)image.scanLine(y);
                 src = o_src;
                 for(x=0; x < size.width(); ++x)
                     *p++ = *src++;
             }
         }
     }
 
     else {
 
         float rfd, gfd, bfd;
         float rd = rca, gd = gca, bd = bca;
 
         unsigned char *xtable[3];
         unsigned char *ytable[3];
 
         unsigned int w = size.width(), h = size.height();
         xtable[0] = new unsigned char[w];
         xtable[1] = new unsigned char[w];
         xtable[2] = new unsigned char[w];
         ytable[0] = new unsigned char[h];
         ytable[1] = new unsigned char[h];
         ytable[2] = new unsigned char[h];
         w*=2, h*=2;
 
         if ( eff == DiagonalGradient || eff == CrossDiagonalGradient) {
             // Diagonal dgradient code inspired by BlackBox (mosfet)
             // BlackBox dgradient is (C) Brad Hughes, <bhughes@tcac.net> and
             // Mike Cole <mike@mydot.com>.
 
             rfd = (float)rDiff/w;
             gfd = (float)gDiff/w;
             bfd = (float)bDiff/w;
 
             int dir;