added missing interface methods for a generic imagedisplay (display

brightness)
apps using that OImageScrollview must rebuild! this will be the last
change of interface for a long time

2 files changed, 123 insertions, 0 deletions

diff --git a/libopie2/opiemm/oimagescrollview.cpp b/libopie2/opiemm/oimagescrollview.cpp
index 37a1ad5..58a9748 100644
--- a/libopie2/opiemm/oimagescrollview.cpp
+++ b/libopie2/opiemm/oimagescrollview.cpp
@@ -1,475 +1,582 @@
 #include "oimagescrollview.h"
 
 #include <opie2/oimagezoomer.h>
 #include <opie2/odebug.h>
 #include <opie2/oapplication.h>
 #include <opie2/owait.h>
 #include <opie2/opieexif.h>
 
 #include <qimage.h>
 #include <qlayout.h>
 
 /* for usage with the bitset */
 #define AUTO_SCALE 0
 #define AUTO_ROTATE 1
 #define SHOW_ZOOMER 2
 #define FIRST_RESIZE_DONE 3
 #define IMAGE_IS_JPEG 4
 #define IMAGE_SCALED_LOADED 5
 
 #define SCROLLVIEW_BITSET_SIZE 6
 
 namespace Opie {
 namespace MM {
 OImageScrollView::OImageScrollView( QWidget* parent, const char* name,  WFlags f )
     :QScrollView(parent,name,f|Qt::WRepaintNoErase ),_image_data(),_original_data(),
     m_states(SCROLLVIEW_BITSET_SIZE),m_lastName("")
 {
     _zoomer = 0;
     m_states[AUTO_SCALE]=true;
     m_states[AUTO_ROTATE]=true;
     m_states[FIRST_RESIZE_DONE]=false;
     m_states[IMAGE_IS_JPEG]=false;
     m_states[IMAGE_SCALED_LOADED]=false;
     m_states[SHOW_ZOOMER]=true;
+    _newImage = true;
     init();
 }
 
 OImageScrollView::OImageScrollView (const QImage&img, QWidget * parent, const char * name, WFlags f,bool always_scale,bool rfit)
     :QScrollView(parent,name,f|Qt::WRepaintNoErase),_image_data(),_original_data(img),
      m_states(SCROLLVIEW_BITSET_SIZE),m_lastName("")
 {
     _zoomer = 0;
     m_states[AUTO_SCALE]=always_scale;
     m_states[AUTO_ROTATE]=rfit;
     m_states[FIRST_RESIZE_DONE]=false;
     m_states[IMAGE_IS_JPEG]=false;
     m_states[IMAGE_SCALED_LOADED]=false;
     m_states[SHOW_ZOOMER]=true;
     _original_data.convertDepth(QPixmap::defaultDepth());
     _original_data.setAlphaBuffer(false);
+    _newImage = true;
     init();
 }
 
 OImageScrollView::OImageScrollView (const QString&img, QWidget * parent, const char * name, WFlags f,bool always_scale,bool rfit)
     :QScrollView(parent,name,f|Qt::WRepaintNoErase),_image_data(),_original_data(),m_states(SCROLLVIEW_BITSET_SIZE),m_lastName("")
 {
     _zoomer = 0;
     m_states.resize(SCROLLVIEW_BITSET_SIZE);
     m_states[AUTO_SCALE]=always_scale;
     m_states[AUTO_ROTATE]=rfit;
     m_states[FIRST_RESIZE_DONE]=false;
     m_states[IMAGE_IS_JPEG]=false;
     m_states[IMAGE_SCALED_LOADED]=false;
     m_states[SHOW_ZOOMER]=true;
+    _newImage = true;
     init();
     setImage(img);
 }
 
 void OImageScrollView::setImage(const QImage&img)
 {
     _image_data = QImage();
     _original_data=img;
     _original_data.convertDepth(QPixmap::defaultDepth());
     _original_data.setAlphaBuffer(false);
     m_lastName = "";
     setImageIsJpeg(false);
     setImageScaledLoaded(false);
+    _newImage = true;
     if (FirstResizeDone()) {
         generateImage();
     }
 }
 
 void OImageScrollView::loadJpeg(bool interncall)
 {
     if (m_lastName.isEmpty()) return;
     QImageIO iio( m_lastName, 0l );
     QString param;
     bool real_load = false;
+    _newImage = true;
     if (AutoScale()) {
         if (!interncall) {
             ExifData xf;
             bool scanned = xf.scan(m_lastName);
             int wid, hei;
             wid = QApplication::desktop()->width();
             hei = QApplication::desktop()->height();
             if (hei>wid) {
                 wid = hei;
             } else {
                 hei = wid;
             }
             if ( (scanned && (wid<xf.getWidth()||hei<xf.getHeight()))||!scanned ) {
                 param = QString( "Fast Shrink( 3 ) Scale( %1, %2, ScaleMin)" ).arg( wid ).arg( hei );
                 odebug << "Load jpeg scaled \"" << param << "\"" << oendl;
                 iio.setParameters(param.latin1());
                 setImageScaledLoaded(true);
             }
 
             real_load = true;
         }
     } else {
         if (ImageScaledLoaded()||!interncall) {
             odebug << "Load jpeg unscaled" << oendl;
             real_load = true;
         }
         setImageScaledLoaded(false);
     }
     if (real_load) {
         _original_data = iio.read() ? iio.image() : QImage();
     }
 }
 
 void OImageScrollView::setImage( const QString& path ) {
     odebug << "load new image " << oendl;
     if (m_lastName == path) return;
     m_lastName = path;
+    _newImage = true;
     _original_data = QImage();
     QString itype = QImage::imageFormat(m_lastName);
     odebug << "Image type = " << itype << oendl;
     if (itype == "JPEG") {
         setImageIsJpeg(true);
         loadJpeg();
     } else {
         setImageIsJpeg(false);
         _original_data.load(path);
         _original_data.convertDepth(QPixmap::defaultDepth());
         _original_data.setAlphaBuffer(false);
     }
     _image_data = QImage();
     if (FirstResizeDone()) {
         generateImage();
         if (isVisible()) viewport()->repaint(true);
     }
 }
 
 /* should be called every time the QImage changed it content */
 void OImageScrollView::init()
 {
     odebug << "init " << oendl;
 
     /*
      * create the zoomer
      * and connect ther various signals
      */
     _zoomer = new Opie::MM::OImageZoomer( this, "The Zoomer" );
     connect(_zoomer, SIGNAL( zoomAreaRel(int,int)),
             this, SLOT(scrollBy(int,int)) );
     connect(_zoomer, SIGNAL( zoomArea(int,int)),
             this, SLOT(center(int,int)) );
     connect(this,SIGNAL(contentsMoving(int,int)),
             _zoomer, (SLOT(setVisiblePoint(int,int))) );
     connect(this,SIGNAL(imageSizeChanged(const QSize&)),
             _zoomer, SLOT(setImageSize(const QSize&)) );
     connect(this,SIGNAL(viewportSizeChanged(const QSize&)),
             _zoomer, SLOT(setViewPortSize(const QSize&)) );
 
     setBackgroundColor(white);
     setFocusPolicy(QWidget::StrongFocus);
     setImageScaledLoaded(false);
     setImageIsJpeg(false);
     if (FirstResizeDone()) {
         m_last_rot = Rotate0;
         generateImage();
     } else if (_original_data.size().isValid()) {
         if (image_fit_into(_original_data.size()) || !ShowZoomer()) _zoomer->hide();
         resizeContents(_original_data.width(),_original_data.height());
     }
+    _intensity = 0;
 }
 
 void OImageScrollView::setAutoRotate(bool how)
 {
     /* to avoid double repaints */
     if (AutoRotate() != how) {
         m_states.setBit(AUTO_ROTATE,how);
         _image_data = QImage();
         generateImage();
     }
 }
 
 bool OImageScrollView::AutoRotate()const
 {
     return m_states.testBit(AUTO_ROTATE);
 }
 
 void OImageScrollView::setAutoScaleRotate(bool scale, bool rotate)
 {
     m_states.setBit(AUTO_ROTATE,rotate);
     setAutoScale(scale);
 }
 
 void OImageScrollView::setAutoScale(bool how)
 {
     m_states.setBit(AUTO_SCALE,how);
     _image_data = QImage();
     if (ImageIsJpeg() && how == false && ImageScaledLoaded()==true) {
         loadJpeg(true);
     }
     generateImage();
 }
 
 bool OImageScrollView::AutoScale()const
 {
     return m_states.testBit(AUTO_SCALE);
 }
 
 OImageScrollView::~OImageScrollView()
 {
 }
 
 void OImageScrollView::rescaleImage(int w, int h)
 {
     if (_image_data.width()==w && _image_data.height()==h) {
         return;
     }
     double hs = (double)h / (double)_image_data.height() ;
     double ws = (double)w / (double)_image_data.width() ;
     double scaleFactor = (hs > ws) ? ws : hs;
     int smoothW = (int)(scaleFactor * _image_data.width());
     int smoothH = (int)(scaleFactor * _image_data.height());
     _image_data = _image_data.smoothScale(smoothW,smoothH);
 }
 
 void OImageScrollView::rotate_into_data(Rotation r)
 {
     /* realy - we must do this that way, 'cause when acting direct on _image_data the app will
        segfault :( */
     QImage dest;
     int x, y;
     if ( _original_data.depth() > 8 )
     {
         unsigned int *srcData, *destData;
         switch ( r )
         {
             case Rotate90:
                 dest.create(_original_data.height(), _original_data.width(), _original_data.depth());
                 for ( y=0; y < _original_data.height(); ++y )
                 {
                     srcData = (unsigned int *)_original_data.scanLine(y);
                     for ( x=0; x < _original_data.width(); ++x )
                     {
                         destData = (unsigned int *)dest.scanLine(x);
                         destData[_original_data.height()-y-1] = srcData[x];
                     }
                 }
                 break;
             case Rotate180:
                 dest.create(_original_data.width(), _original_data.height(), _original_data.depth());
                 for ( y=0; y < _original_data.height(); ++y )
                 {
                     srcData = (unsigned int *)_original_data.scanLine(y);
                     destData = (unsigned int *)dest.scanLine(_original_data.height()-y-1);
                     for ( x=0; x < _original_data.width(); ++x )
                         destData[_original_data.width()-x-1] = srcData[x];
                 }
                 break;
             case Rotate270:
                 dest.create(_original_data.height(), _original_data.width(), _original_data.depth());
                 for ( y=0; y < _original_data.height(); ++y )
                 {
                     srcData = (unsigned int *)_original_data.scanLine(y);
                     for ( x=0; x < _original_data.width(); ++x )
                     {
                         destData = (unsigned int *)dest.scanLine(_original_data.width()-x-1);
                         destData[y] = srcData[x];
                     }
                 }
                 break;
             default:
                 dest = _original_data;
                 break;
         }
     }
     else
     {
         unsigned char *srcData, *destData;
         unsigned int *srcTable, *destTable;
         switch ( r )
         {
             case Rotate90:
                 dest.create(_original_data.height(), _original_data.width(), _original_data.depth());
                 dest.setNumColors(_original_data.numColors());
                 srcTable = (unsigned int *)_original_data.colorTable();
                 destTable = (unsigned int *)dest.colorTable();
                 for ( x=0; x < _original_data.numColors(); ++x )
                     destTable[x] = srcTable[x];
                 for ( y=0; y < _original_data.height(); ++y )
                 {
                     srcData = (unsigned char *)_original_data.scanLine(y);
                     for ( x=0; x < _original_data.width(); ++x )
                     {
                         destData = (unsigned char *)dest.scanLine(x);
                         destData[_original_data.height()-y-1] = srcData[x];
                     }
                 }
                 break;
             case Rotate180:
                 dest.create(_original_data.width(), _original_data.height(), _original_data.depth());
                 dest.setNumColors(_original_data.numColors());
                 srcTable = (unsigned int *)_original_data.colorTable();
                 destTable = (unsigned int *)dest.colorTable();
                 for ( x=0; x < _original_data.numColors(); ++x )
                     destTable[x] = srcTable[x];
                 for ( y=0; y < _original_data.height(); ++y )
                 {
                     srcData = (unsigned char *)_original_data.scanLine(y);
                     destData = (unsigned char *)dest.scanLine(_original_data.height()-y-1);
                     for ( x=0; x < _original_data.width(); ++x )
                         destData[_original_data.width()-x-1] = srcData[x];
                 }
                 break;
             case Rotate270:
                 dest.create(_original_data.height(), _original_data.width(), _original_data.depth());
                 dest.setNumColors(_original_data.numColors());
                 srcTable = (unsigned int *)_original_data.colorTable();
                 destTable = (unsigned int *)dest.colorTable();
                 for ( x=0; x < _original_data.numColors(); ++x )
                     destTable[x] = srcTable[x];
                 for ( y=0; y < _original_data.height(); ++y )
                 {
                     srcData = (unsigned char *)_original_data.scanLine(y);
                     for ( x=0; x < _original_data.width(); ++x )
                     {
                         destData = (unsigned char *)dest.scanLine(_original_data.width()-x-1);
                         destData[y] = srcData[x];
                     }
                 }
                 break;
             default:
                 dest = _original_data;
                 break;
         }
 
     }
+    _newImage = true;
     _image_data = dest;
 }
 
+void OImageScrollView::apply_gamma(int aValue)
+{
+    if (!_image_data.size().isValid()) return;
+    float percent = ((float)aValue/100);
+    odebug << "Apply gamma " << percent << oendl;
+    int pixels = _image_data.depth()>8?_image_data.width()*_image_data.height() : _image_data.numColors();
+    int segColors = _image_data.depth() > 8 ? 256 : _image_data.numColors();
+    unsigned char *segTbl = new unsigned char[segColors];
+    bool brighten = (percent >= 0);
+    if ( percent < 0 )
+        percent = -percent;
+
+    unsigned int *data = _image_data.depth() > 8 ? (unsigned int *)_image_data.bits() :
+                         (unsigned int *)_image_data.colorTable();
+
+
+    if (brighten) {
+        for ( int i=0; i < segColors; ++i )
+        {
+            int tmp = (int)(i*percent);
+            if ( tmp > 255 )
+                tmp = 255;
+            segTbl[i] = tmp;
+        }
+    } else {
+        for ( int i=0; i < segColors; ++i )
+        {
+            int tmp = (int)(i*percent);
+            if ( tmp < 0 )
+                tmp = 0;
+            segTbl[i] = tmp;
+        }
+    }
+    if (brighten) {
+        for ( int i=0; i < pixels; ++i )
+        {
+            int r = qRed(data[i]);
+            int g = qGreen(data[i]);
+            int b = qBlue(data[i]);
+            int a = qAlpha(data[i]);
+            r = r + segTbl[r] > 255 ? 255 : r + segTbl[r];
+            g = g + segTbl[g] > 255 ? 255 : g + segTbl[g];
+            b = b + segTbl[b] > 255 ? 255 : b + segTbl[b];
+            data[i] = qRgba(r, g, b,a);
+        }
+    } else {
+        for ( int i=0; i < pixels; ++i )
+        {
+            int r = qRed(data[i]);
+            int g = qGreen(data[i]);
+            int b = qBlue(data[i]);
+            int a = qAlpha(data[i]);
+            r = r - segTbl[r] < 0 ? 0 : r - segTbl[r];
+            g = g - segTbl[g] < 0 ? 0 : g - segTbl[g];
+            b = b - segTbl[b] < 0 ? 0 : b - segTbl[b];
+            data[i] = qRgba(r, g, b, a);
+        }
+    }
+    delete [] segTbl;
+}
+
+const int OImageScrollView::Intensity()const
+{
+    return _intensity;
+}
+
+int OImageScrollView::setIntensity(int value,bool reload)
+{
+    int oldi = _intensity;
+    _intensity = value;
+    if (!_pdata.size().isValid()) {
+        return _intensity;
+    }
+
+    if (!reload) {
+        _image_data = _pdata.convertToImage();
+        apply_gamma(_intensity-oldi);
+        _pdata.convertFromImage(_image_data);
+        /*
+        * invalidate
+        */
+        _image_data=QImage();
+        if (isVisible()) {
+            updateContents(contentsX(),contentsY(),width(),height());
+        }
+    } else {
+        _newImage = true;
+        generateImage();
+    }
+    return _intensity;
+}
+
 void OImageScrollView::generateImage()
 {
     Rotation r = Rotate0;
     _pdata = QPixmap();
     if (_original_data.isNull()) {
         emit imageSizeChanged( _image_data.size() );
         if (_zoomer) _zoomer->setImage( _image_data );
         return;
     }
     if (width()>height()&&_original_data.width()<_original_data.height() ||
         width()<height()&&_original_data.width()>_original_data.height()) {
         if (AutoRotate()) r = Rotate90;
     }
 
     int twidth,theight;
     odebug << " r = " << r << oendl;
     if (AutoScale() && (_original_data.width()>width() || _original_data.height() > height()) ) {
         if (!_image_data.size().isValid()||width()>_image_data.width()||height()>_image_data.height()) {
             odebug << "Rescaling data" << oendl;
             if (r==Rotate0) {
                 _image_data = _original_data;
             } else {
                 rotate_into_data(r);
             }
+            _newImage = true;
         }
         rescaleImage(width(),height());
     }  else if (!FirstResizeDone()||r!=m_last_rot||_image_data.width()==0) {
         if (r==Rotate0) {
             _image_data = _original_data;
         } else {
             rotate_into_data(r);
         }
         m_last_rot = r;
     }
+
+    if (_newImage) {
+        apply_gamma(_intensity);
+        _newImage = false;
+    }
+
     _pdata.convertFromImage(_image_data);
     twidth = _image_data.width();
     theight = _image_data.height();
 
     /*
      * update the zoomer
      */
     check_zoomer();
     emit imageSizeChanged( _image_data.size() );
     rescaleImage( 128, 128 );
     resizeContents(twidth,theight);
     /*
      * move scrollbar
      */
      if (_zoomer) {
         _zoomer->setGeometry( viewport()->width()-_image_data.width()/2, viewport()->height()-_image_data.height()/2,
              _image_data.width()/2, _image_data.height()/2 );
         _zoomer->setImage( _image_data );
      }
     /*
      * invalidate
      */
     _image_data=QImage();
     if (isVisible()) {
         updateContents(contentsX(),contentsY(),width(),height());
     }
 }
 
 void OImageScrollView::resizeEvent(QResizeEvent * e)
 {
     odebug << "OImageScrollView resizeEvent (" << e->size() << " - " << e->oldSize() << oendl;
     QScrollView::resizeEvent(e);
     if (e->oldSize()==e->size()||!isUpdatesEnabled ()) return;
     generateImage();
     setFirstResizeDone(true);
     emit viewportSizeChanged( viewport()->size() );
 
 }
 
 void OImageScrollView::keyPressEvent(QKeyEvent * e)
 {
     if (!e) return;
     int dx = horizontalScrollBar()->lineStep();
     int dy = verticalScrollBar()->lineStep();
     if (e->key()==Qt::Key_Right) {
         scrollBy(dx,0);
         e->accept();
     } else if (e->key()==Qt::Key_Left) {
         scrollBy(0-dx,0);
         e->accept();
     } else if (e->key()==Qt::Key_Up) {
         scrollBy(0,0-dy);
         e->accept();
     } else if (e->key()==Qt::Key_Down) {
         scrollBy(0,dy);
         e->accept();
     } else {
         e->ignore();
     }
     QScrollView::keyPressEvent(e);
 }
 
 void OImageScrollView::drawContents(QPainter * p, int clipx, int clipy, int clipw, int cliph)
 {
     if (!_pdata.size().isValid()) {
         p->fillRect(clipx,clipy,clipw,cliph, backgroundColor());
         return;
     }
 
     int w = clipw;
     int h = cliph;
     int x = clipx;
     int y = clipy;
     bool erase = false;
 
     if (w>_pdata.width()) {
         w = _pdata.width()-x;
         erase=true;
     }
     if (h>_pdata.height()) {
         h = _pdata.height()-y;
         erase=true;
     }
     if (!erase && (clipy+cliph>_pdata.height()||clipx+clipw>_pdata.width())) {
         erase = true;
     }
     if (erase||_original_data.hasAlphaBuffer()) {
         p->fillRect(clipx,clipy,clipw,cliph, backgroundColor());
     }
     if (w>0 && h>0&&x<_pdata.width()&&y<_pdata.height()) {
         p->drawPixmap(clipx,clipy,_pdata,x,y,w,h);
     }
 }
 
 /* using the real geometry points and not the translated points is wanted! */
 void OImageScrollView::viewportMouseMoveEvent(QMouseEvent* e)
diff --git a/libopie2/opiemm/oimagescrollview.h b/libopie2/opiemm/oimagescrollview.h
index 01a2d56..11964fd 100644
--- a/libopie2/opiemm/oimagescrollview.h
+++ b/libopie2/opiemm/oimagescrollview.h
@@ -28,166 +28,182 @@ class OImageScrollView:public QScrollView
 {
     Q_OBJECT
 public:
     enum  Rotation {
         Rotate0,
         Rotate90,
         Rotate180,
         Rotate270
     };
 
     /**
      * Standard constructor
      * @param parent the parent widget
      * @param name the name of the widget
      * @param fl widget flags. The flag Qt::WRepaintNoErase will be always set.
      */
     OImageScrollView( QWidget* parent, const char* name = 0, WFlags fl = 0 );
     /**
      * constructor
      * @param aImage QImage object to display
      * @param parent the parent widget
      * @param name the name of the widget
      * @param fl widget flags. The flag Qt::WRepaintNoErase will be always set.
      * @param always_scale if the image should be scaled into the display
      * @param rfit the image will be rotated to fit
      */
     OImageScrollView (const QImage&aImage, QWidget * parent=0, const char * name=0, WFlags f=0,bool always_scale=false,bool rfit=false );
     /**
      * constructor
      * @param aFile image file to display
      * @param parent the parent widget
      * @param name the name of the widget
      * @param fl widget flags. The flag Qt::WRepaintNoErase will be always set.
      * @param always_scale if the image should be scaled into the display
      * @param rfit the image will be rotated to fit
      */
     OImageScrollView (const QString&aFile, QWidget * parent=0, const char * name=0, WFlags f=0,bool always_scale=false,bool rfit=false );
     virtual ~OImageScrollView();
 
     /**
      * sets the WDestructiveClose flag to the view
      */
     virtual void setDestructiveClose();
 
     /**
      * set if the image should be rotate to best fit
      * and repaint it if set to a new value.
      *
      * Be carefull - autorating real large images cost time!
      * @param how if true then autorotate otherwise not
      */
     virtual void setAutoRotate(bool how);
     /**
      * set if the image should be scaled to the size of the viewport if larger(!)
      *
      * if autoscaling is set when loading a jpeg image, it will use a feature of
      * jpeg lib to load the image scaled to display size. If switch of later the
      * image will reloaded.
      *
      * @param how true - display image scaled down otherwise not
      */
     virtual void setAutoScale(bool how);
     /**
      * set if the image should be scaled to the size of the viewport if larger(!)
      * and/or rotate to best fit. You avoid double repainting when you want to switch
      * booth values.
      *
      * if autoscaling is set when loading a jpeg image, it will use a feature of
      * jpeg lib to load the image scaled to display size. If switch of later the
      * image will reloaded.
      *
      * @param scale true - display image scaled down otherwise not
      * @param rotate true - the image will rotate for best fit
      */
     virtual void setAutoScaleRotate(bool scale, bool rotate);
     /**
      * set if there should be displayed a small zoomer widget at the right bottom of
      * the view when the image is larger than the viewport.
      *
      * @param how true - display zoomer
      */
     virtual void setShowZoomer(bool how);
 
     /**
      * return the current value of the autorotate flag.
      */
     virtual bool AutoRotate()const;
     /**
      * return the current value of the autoscale flag.
      */
     virtual bool AutoScale()const;
     /**
      * return the current value of the show zoomer flag.
      */
     virtual bool ShowZoomer()const;
 
+    /**
+     * set a display intensity
+     * @param value the intensity value, will calcuated to a percent value (value/100)
+     * @param reload should the real image recalculated complete or just work on current display.
+     * @return the new intensity
+     */
+    virtual int setIntensity(int value,bool reload=false);
+    /**
+     * return the current display intensity
+     */
+    virtual const int Intensity()const;
+
+
 public slots:
     /**
      * Displays a new image, calculations will made immediately.
      *
      * @param aImage the image to display
      */
     virtual void setImage(const QImage&aImage);
     /**
      * Displays a new image, calculations will made immediately.
      *
      * @param path the image to display
      */
     virtual void setImage( const QString& path );
 
 
 signals:
     /**
      * emitted when the display image size has changed.
      */
     void imageSizeChanged( const QSize& );
     /**
      * emitted when the size of the viewport has changed, eg. in resizeEvent of
      * the view.
      *
      * @see QWidget::resizeEvent
      */
     void viewportSizeChanged( const QSize& );
 
 protected:
     virtual void drawContents ( QPainter * p, int clipx, int clipy, int clipw, int cliph );
     void init();
 
     Opie::MM::OImageZoomer *_zoomer;
     QImage _image_data;
     QImage _original_data;
     QPixmap _pdata;
+    int _intensity;
+    bool _newImage;
 
     int _mouseStartPosX,_mouseStartPosY;
 
     QBitArray m_states;
 
     Rotation m_last_rot;
     QString m_lastName;
     virtual void rescaleImage(int w, int h);
 
     virtual void rotate_into_data(Rotation r);
     virtual void generateImage();
     virtual void loadJpeg(bool interncall = false);
     bool image_fit_into(const QSize&s);
     void check_zoomer();
 
     /* internal bitset manipulation */
     virtual bool ImageIsJpeg()const;
     virtual void setImageIsJpeg(bool how);
     virtual bool ImageScaledLoaded()const;
     virtual void setImageScaledLoaded(bool how);
     virtual bool FirstResizeDone()const;
     virtual void setFirstResizeDone(bool how);
+    virtual void apply_gamma(int aValue);
 
 protected slots:
     virtual void viewportMouseMoveEvent(QMouseEvent* e);
     virtual void contentsMousePressEvent ( QMouseEvent * e);
     virtual void resizeEvent(QResizeEvent * e);
     virtual void keyPressEvent(QKeyEvent * e);
 };
 
 }
 }
 
 #endif