8 files changed, 221 insertions, 98 deletions

diff --git a/noncore/graphics/opie-eye/gui/imagescrollview.cpp b/noncore/graphics/opie-eye/gui/imagescrollview.cpp
index d034ee0..3bb07a7 100644
--- a/noncore/graphics/opie-eye/gui/imagescrollview.cpp
+++ b/noncore/graphics/opie-eye/gui/imagescrollview.cpp
@@ -1,500 +1,586 @@
 #include "imagescrollview.h"
 
+#include "lib/oimagezoomer.h"
+
 #include <opie2/odebug.h>
 #include <opie2/oapplication.h>
 #include <opie2/owait.h>
 
-using namespace Opie::Core;
-
 #include <qimage.h>
 #include <qlayout.h>
 #include <qpe/qcopenvelope_qws.h>
 
-ImageScrollView::ImageScrollView( QWidget* parent, const char* name,  WFlags f )
-    :QScrollView(parent,name,f|Qt::WRepaintNoErase ),_image_data(),_original_data(),scale_to_fit(true),
-     rotate_to_fit(true),show_zoomer(true),first_resize_done(false),m_lastName("")
+/* 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;
     init();
 }
 
-ImageScrollView::ImageScrollView (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),scale_to_fit(always_scale),
-    rotate_to_fit(rfit),show_zoomer(true),first_resize_done(false),m_lastName("")
+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);
     init();
 }
 
-ImageScrollView::ImageScrollView (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(),scale_to_fit(always_scale),
-    rotate_to_fit(rfit),show_zoomer(true),first_resize_done(false),m_lastName("")
+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;
     init();
     setImage(img);
 }
 
-void ImageScrollView::setImage(const QImage&img)
+void OImageScrollView::setImage(const QImage&img)
 {
     _image_data = QImage();
     _original_data=img;
     _original_data.convertDepth(QPixmap::defaultDepth());
     _original_data.setAlphaBuffer(false);
     m_lastName = "";
-    image_is_jpeg = false;
-    image_scaled_loaded = false;
-    if (first_resize_done) {
+    setImageIsJpeg(false);
+    setImageScaledLoaded(false);
+    if (FirstResizeDone()) {
         generateImage();
     }
 }
 
-void ImageScrollView::loadJpeg(bool interncall)
+void OImageScrollView::loadJpeg(bool interncall)
 {
     if (m_lastName.isEmpty()) return;
     QImageIO iio( m_lastName, 0l );
     QString param;
     bool real_load = false;
-    if (scale_to_fit) {
+    if (AutoScale()) {
         if (!interncall) {
             int wid, hei;
             wid = QApplication::desktop()->width();
             hei = QApplication::desktop()->height();
             if (hei>wid) {
                 wid = hei;
             } else {
                 hei = wid;
             }
             param = QString( "Fast Shrink( 7 ) Scale( %1, %2, ScaleFree)" ).arg( wid ).arg( hei );
             odebug << "Load jpeg scaled \"" << param << "\"" << oendl;
             iio.setParameters(param.latin1());
-            image_scaled_loaded = true;
+            setImageScaledLoaded(true);
             real_load = true;
         }
     } else {
-        if (image_scaled_loaded||!interncall) {
+        if (ImageScaledLoaded()||!interncall) {
             odebug << "Load jpeg unscaled" << oendl;
             real_load = true;
         }
-        image_scaled_loaded = false;
+        setImageScaledLoaded(false);
     }
     if (real_load) {
         {
             QCopEnvelope( "QPE/System", "busy()" );
         }
         _original_data = iio.read() ? iio.image() : QImage();
         {
             QCopEnvelope env( "QPE/System", "notBusy(QString)" );
             env << "Image loaded";
         }
     }
 }
 
-void ImageScrollView::setImage( const QString& path ) {
+void OImageScrollView::setImage( const QString& path ) {
     odebug << "load new image " << oendl;
     if (m_lastName == path) return;
     m_lastName = path;
     QString itype = QImage::imageFormat(m_lastName);
     odebug << "Image type = " << itype << oendl;
     if (itype == "JPEG") {
-        image_is_jpeg = true;
+        setImageIsJpeg(true);
         loadJpeg();
     } else {
         {
             QCopEnvelope( "QPE/System", "busy()" );
         }
-        image_is_jpeg = false;
+        setImageIsJpeg(false);
         _original_data.load(path);
         _original_data.convertDepth(QPixmap::defaultDepth());
         _original_data.setAlphaBuffer(false);
         {
             QCopEnvelope env( "QPE/System", "notBusy(QString)" );
             env << "Image loaded";
         }
     }
     _image_data = QImage();
-    if (first_resize_done) {
+    if (FirstResizeDone()) {
         generateImage();
     }
 }
 
 /* should be called every time the QImage changed it content */
-void ImageScrollView::init()
+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&)) );
 
     viewport()->setBackgroundColor(white);
     setFocusPolicy(QWidget::StrongFocus);
-    image_scaled_loaded = false;
-    image_is_jpeg = false;
-    if (first_resize_done) {
-        last_rot = Rotate0;
+    setImageScaledLoaded(false);
+    setImageIsJpeg(false);
+    if (FirstResizeDone()) {
+        m_last_rot = Rotate0;
         generateImage();
     } else if (_original_data.size().isValid()) {
-        if (image_fit_into(_original_data.size()) || !show_zoomer) _zoomer->hide();
+        if (image_fit_into(_original_data.size()) || !ShowZoomer()) _zoomer->hide();
         resizeContents(_original_data.width(),_original_data.height());
     }
 }
 
-void ImageScrollView::setAutoRotate(bool how)
+void OImageScrollView::setAutoRotate(bool how)
 {
     /* to avoid double repaints */
-    if (rotate_to_fit != how) {
-        rotate_to_fit = how;
+    if (AutoRotate() != how) {
+        m_states.setBit(AUTO_ROTATE,how);
         _image_data = QImage();
         generateImage();
     }
 }
 
-void ImageScrollView::setAutoScale(bool how)
+bool OImageScrollView::AutoRotate()const
+{
+    return m_states.testBit(AUTO_ROTATE);
+}
+
+void OImageScrollView::setAutoScale(bool how)
 {
-    scale_to_fit = how;
+    m_states.setBit(AUTO_SCALE,how);
     if (!how) {
-        rotate_to_fit = false;
+        setAutoRotate(false);
     }
     _image_data = QImage();
-    if (image_is_jpeg && how == false && image_scaled_loaded==true) {
+    if (ImageIsJpeg() && how == false && ImageScaledLoaded()==true) {
         loadJpeg(true);
     }
     generateImage();
 }
 
-ImageScrollView::~ImageScrollView()
+bool OImageScrollView::AutoScale()const
+{
+    return m_states.testBit(AUTO_SCALE);
+}
+
+OImageScrollView::~OImageScrollView()
 {
 }
 
-void ImageScrollView::rescaleImage(int w, int h)
+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 ImageScrollView::rotate_into_data(Rotation r)
+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;
         }
 
     }
     _image_data = dest;
 }
 
-void ImageScrollView::generateImage()
+void OImageScrollView::generateImage()
 {
     Rotation r = Rotate0;
+    if (_original_data.isNull()) return;
     {
         QCopEnvelope( "QPE/System", "busy()" );
     }
     if (width()>height()&&_original_data.width()<_original_data.height() ||
         width()<height()&&_original_data.width()>_original_data.height()) {
-        if (rotate_to_fit) r = Rotate90;
+        if (AutoRotate()) r = Rotate90;
     }
 
     odebug << " r = " << r << oendl;
-    if (scale_to_fit) {
+    if (AutoScale()) {
         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);
             }
         }
         rescaleImage(width(),height());
         resizeContents(_image_data.width(),_image_data.height());
-    }  else if (!first_resize_done||r!=last_rot||_image_data.width()==0) {
+    }  else if (!FirstResizeDone()||r!=m_last_rot||_image_data.width()==0) {
         if (r==Rotate0) {
             _image_data = _original_data;
         } else {
             rotate_into_data(r);
         }
-        last_rot = r;
+        m_last_rot = r;
         resizeContents(_image_data.width(),_image_data.height());
     }
     _pdata.convertFromImage(_image_data);
 
 
     /*
      * update the zoomer
      */
     check_zoomer();
     emit imageSizeChanged( _image_data.size() );
     rescaleImage( 128, 128 );
     /*
      * move scrollbar
      */
-    _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 );
+     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();
     {
         QCopEnvelope env( "QPE/System", "notBusy(QString)" );
         env << "Image generated";
     }
 }
 
-void ImageScrollView::resizeEvent(QResizeEvent * e)
+void OImageScrollView::resizeEvent(QResizeEvent * e)
 {
-    odebug << "ImageScrollView resizeEvent" << oendl;
+    odebug << "OImageScrollView resizeEvent" << oendl;
     QScrollView::resizeEvent(e);
     generateImage();
-    first_resize_done = true;
+    setFirstResizeDone(true);
     emit viewportSizeChanged( viewport()->size() );
 
 }
 
-void ImageScrollView::keyPressEvent(QKeyEvent * e)
+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 ImageScrollView::drawContents(QPainter * p, int clipx, int clipy, int clipw, int cliph)
+void OImageScrollView::drawContents(QPainter * p, int clipx, int clipy, int clipw, int cliph)
 {
     int w = clipw;
     int h = cliph;
     int x = clipx;
     int y = clipy;
     bool erase = false;
 
     if (!_pdata.size().isValid()) {
         p->fillRect(clipx,clipy,clipw,cliph,white);
         return;
     }
     if (w>_pdata.width()) {
         w=_pdata.width();
         x = 0;
         erase = true;
     } else if (x+w>_pdata.width()){
         x = _pdata.width()-w;
     }
     if (h>_pdata.height()) {
         h=_pdata.height();
         y = 0;
         erase = true;
     } else if (y+h>_pdata.height()){
         y = _pdata.height()-h;
     }
     if (erase||_original_data.hasAlphaBuffer()) {
         p->fillRect(clipx,clipy,clipw,cliph,white);
     }
     p->drawPixmap(clipx,clipy,_pdata,x,y,w,h);
 }
 
 /* using the real geometry points and not the translated points is wanted! */
-void ImageScrollView::viewportMouseMoveEvent(QMouseEvent* e)
+void OImageScrollView::viewportMouseMoveEvent(QMouseEvent* e)
 {
     odebug << "Move X and Y " << e->x() << " " << e->y() << oendl;
     int mx, my;
     mx = e->x();
     my = e->y();
     if (_mouseStartPosX!=-1 && _mouseStartPosY!=-1) {
         int diffx = _mouseStartPosX-mx;
         int diffy = _mouseStartPosY-my;
 #if 0
         QScrollBar*xbar = horizontalScrollBar();
         QScrollBar*ybar = verticalScrollBar();
         if (xbar->value()+diffx>xbar->maxValue()) {
             diffx = xbar->maxValue()-xbar->value();
         } else if (xbar->value()+diffx<0) {
             diffx=0-xbar->value();
         }
         if (ybar->value()+diffy>ybar->maxValue()) {
             diffy = ybar->maxValue()-ybar->value();
         } else if (ybar->value()+diffy<0) {
             diffy=0-ybar->value();
         }
 #endif
         scrollBy(diffx,diffy);
     }
     _mouseStartPosX=mx;
     _mouseStartPosY=my;
 }
 
-void ImageScrollView::contentsMousePressEvent ( QMouseEvent * e)
+void OImageScrollView::contentsMousePressEvent ( QMouseEvent * e)
 {
     odebug << " X and Y " << e->x() << " " << e->y() << oendl;
     /* this marks the beginning of a possible mouse move. Due internal reasons of QT
        the geometry values here may real differ from that set in MoveEvent (I don't know
        why). For getting them in real context, we use the first move-event to set the start
        position ;)
     */
     _mouseStartPosX = -1;
     _mouseStartPosY = -1;
 }
 
-void ImageScrollView::setDestructiveClose() {
+void OImageScrollView::setDestructiveClose() {
     WFlags fl = getWFlags();
     /* clear it just in case */
     fl &= ~WDestructiveClose;
     fl |= WDestructiveClose;
     setWFlags( fl );
 }
 
-bool ImageScrollView::image_fit_into(const QSize&s )
+bool OImageScrollView::image_fit_into(const QSize&s )
 {
     if (s.width()>width()||s.height()>height()) {
         return false;
     }
     return true;
 }
 
-void ImageScrollView::setShowZoomer(bool how)
+void OImageScrollView::setShowZoomer(bool how)
 {
-    show_zoomer = how;
+    m_states.setBit(SHOW_ZOOMER,how);
     check_zoomer();
 }
 
-void ImageScrollView::check_zoomer()
+bool OImageScrollView::ShowZoomer()const
+{
+    return m_states.testBit(SHOW_ZOOMER);
+}
+
+void OImageScrollView::check_zoomer()
 {
-    if ( (!show_zoomer||image_fit_into(_pdata.size()) ) && _zoomer->isVisible()) {
+    if (!_zoomer) return;
+    if ( (!ShowZoomer()||image_fit_into(_pdata.size()) ) && _zoomer->isVisible()) {
         _zoomer->hide();
-    } else if ( show_zoomer && !image_fit_into(_pdata.size()) && _zoomer->isHidden()){
+    } else if ( ShowZoomer() && !image_fit_into(_pdata.size()) && _zoomer->isHidden()){
         _zoomer->show();
     }
 }
+
+bool OImageScrollView::FirstResizeDone()const
+{
+    return m_states.testBit(FIRST_RESIZE_DONE);
+}
+
+void OImageScrollView::setFirstResizeDone(bool how)
+{
+    m_states.setBit(FIRST_RESIZE_DONE,how);
+}
+
+bool OImageScrollView::ImageIsJpeg()const
+{
+    return m_states.testBit(IMAGE_IS_JPEG);
+}
+
+void OImageScrollView::setImageIsJpeg(bool how)
+{
+    m_states.setBit(IMAGE_IS_JPEG,how);
+}
+
+bool OImageScrollView::ImageScaledLoaded()const
+{
+    return m_states.testBit(IMAGE_SCALED_LOADED);
+}
+
+void OImageScrollView::setImageScaledLoaded(bool how)
+{
+    m_states.setBit(IMAGE_SCALED_LOADED,how);
+}
+
+} // namespace MM
+} // namespace Opie
diff --git a/noncore/graphics/opie-eye/gui/imagescrollview.h b/noncore/graphics/opie-eye/gui/imagescrollview.h
index f6e187d..3d2ea38 100644
--- a/noncore/graphics/opie-eye/gui/imagescrollview.h
+++ b/noncore/graphics/opie-eye/gui/imagescrollview.h
@@ -1,78 +1,95 @@
 #ifndef _IMAGE_SCROLL_VIEW_H
 #define _IMAGE_SCROLL_VIEW_H
 
-#include <lib/oimagezoomer.h>
-
 #include <qscrollview.h>
 #include <qimage.h>
 #include <qpixmap.h>
 #include <qstring.h>
 #include <qdialog.h>
-
+#include <qbitarray.h>
 
 
 class QPainter;
 
-class ImageScrollView:public QScrollView
+namespace Opie { namespace MM { 
+
+    class OImageZoomer; 
+
+class OImageScrollView:public QScrollView
 {
     Q_OBJECT
 public:
-    ImageScrollView( QWidget* parent, const char* name = 0, WFlags fl = 0 );
-    ImageScrollView (const QImage&, QWidget * parent=0, const char * name=0, WFlags f=0,bool always_scale=false,bool rfit=false );
-    ImageScrollView (const QString&, QWidget * parent=0, const char * name=0, WFlags f=0,bool always_scale=false,bool rfit=false );
-    virtual ~ImageScrollView();
+    enum  Rotation {
+        Rotate0,
+        Rotate90,
+        Rotate180,
+        Rotate270
+    };
+
+    OImageScrollView( QWidget* parent, const char* name = 0, WFlags fl = 0 );
+    OImageScrollView (const QImage&, QWidget * parent=0, const char * name=0, WFlags f=0,bool always_scale=false,bool rfit=false );
+    OImageScrollView (const QString&, QWidget * parent=0, const char * name=0, WFlags f=0,bool always_scale=false,bool rfit=false );
+    virtual ~OImageScrollView();
+
 
-    virtual void setImage(const QImage&);
-    virtual void setImage( const QString& path );
     virtual void setDestructiveClose();
 
     virtual void setAutoRotate(bool);
     virtual void setAutoScale(bool);
     virtual void setShowZoomer(bool);
 
-    enum  Rotation {
-        Rotate0,
-        Rotate90,
-        Rotate180,
-        Rotate270
-    };
+    virtual bool AutoRotate()const;
+    virtual bool AutoScale()const;
+    virtual bool ShowZoomer()const;
+
+public slots:
+    virtual void setImage(const QImage&);
+    virtual void setImage( const QString& path );
+
 
 signals:
-    void sig_return();
     void imageSizeChanged( const QSize& );
     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 _mouseStartPosX,_mouseStartPosY;
 
-    bool scale_to_fit;
-    bool rotate_to_fit;
-    bool show_zoomer;
-    bool first_resize_done;
-    bool image_is_jpeg;
-    bool image_scaled_loaded;
-    Rotation last_rot;
+    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);
+
 protected slots:
     virtual void viewportMouseMoveEvent(QMouseEvent* e);
     virtual void contentsMousePressEvent ( QMouseEvent * e);
     virtual void resizeEvent(QResizeEvent * e);
     virtual void keyPressEvent(QKeyEvent * e);
 };
+
+}
+}
+
 #endif
diff --git a/noncore/graphics/opie-eye/gui/imageview.cpp b/noncore/graphics/opie-eye/gui/imageview.cpp
index 2078b19..db3ae74 100644
--- a/noncore/graphics/opie-eye/gui/imageview.cpp
+++ b/noncore/graphics/opie-eye/gui/imageview.cpp
@@ -1,61 +1,60 @@
 #include "imageview.h"
 
 #include <opie2/odebug.h>
 #include <opie2/oconfig.h>
 #include <opie2/okeyconfigwidget.h>
 
 #include <qpe/resource.h>
 
 using namespace Opie::Core;
 
 ImageView::ImageView(Opie::Core::OConfig *cfg, QWidget* parent, const char* name, WFlags fl )
-    : ImageScrollView(parent,name,fl)
+    : Opie::MM::OImageScrollView(parent,name,fl)
 {
     m_viewManager = 0;
     m_cfg = cfg;
     initKeys();
 }
 
 ImageView::~ImageView()
 {
     if (m_viewManager) {
         delete m_viewManager;
     }
 }
 
 Opie::Core::OKeyConfigManager* ImageView::manager()
 {
     if (!m_viewManager) {
         initKeys();
     }
     return m_viewManager;
 }
 
 void ImageView::initKeys()
 {
     odebug << "init imageview keys" << oendl;
     if (!m_cfg) {
         m_cfg = new Opie::Core::OConfig("phunkview");
         m_cfg->setGroup("image_view_keys" );
     }
     Opie::Core::OKeyPair::List lst;
     lst.append( Opie::Core::OKeyPair::upArrowKey() );
     lst.append( Opie::Core::OKeyPair::downArrowKey() );
     lst.append( Opie::Core::OKeyPair::leftArrowKey() );
     lst.append( Opie::Core::OKeyPair::rightArrowKey() );
-    lst.append( Opie::Core::OKeyPair::returnKey() );
 
     m_viewManager = new Opie::Core::OKeyConfigManager(m_cfg, "image_view_keys",
                                                     lst, false,this, "image_view_keys" );
     m_viewManager->addKeyConfig( Opie::Core::OKeyConfigItem(tr("View Image Info"), "imageviewinfo",
                                                 Resource::loadPixmap("1to1"), ViewInfo,
                                                 Opie::Core::OKeyPair(Qt::Key_I,Qt::ShiftButton),
                                                 this, SLOT(slotShowImageInfo())));
     m_viewManager->handleWidget( this );
     m_viewManager->load();
 }
 
 void ImageView::slotShowImageInfo()
 {
     emit dispImageInfo(m_lastName);
 }
diff --git a/noncore/graphics/opie-eye/gui/imageview.h b/noncore/graphics/opie-eye/gui/imageview.h
index 87e2b32..e4f899a 100644
--- a/noncore/graphics/opie-eye/gui/imageview.h
+++ b/noncore/graphics/opie-eye/gui/imageview.h
@@ -1,38 +1,37 @@
 #ifndef _IMAGE_VIEW_H
 #define _IMAGE_VIEW_H
 
 /* must be changed when it will moved to Opie::MM */
 #include "imagescrollview.h"
 
 namespace Opie {
     namespace Core {
         class OConfig;
         class OKeyConfigManager;
     }
 }
 
-class ImageView:public ImageScrollView
+class ImageView:public Opie::MM::OImageScrollView
 {
     Q_OBJECT
 
     enum ActionIds {
         ViewInfo
     };
 
 public:
     ImageView(Opie::Core::OConfig *cfg, QWidget* parent, const char* name = 0, WFlags fl = 0 );
     virtual ~ImageView();
     Opie::Core::OKeyConfigManager* manager();
 
 signals:
     void dispImageInfo(const QString&);
-    void sig_return();
 
 protected:
     Opie::Core::OConfig * m_cfg;
     Opie::Core::OKeyConfigManager*m_viewManager;
     void initKeys();
 protected slots:
     virtual void slotShowImageInfo();
 };
 #endif
diff --git a/noncore/graphics/opie-eye/gui/mainwindow.cpp b/noncore/graphics/opie-eye/gui/mainwindow.cpp
index e5921d8..09f562a 100644
--- a/noncore/graphics/opie-eye/gui/mainwindow.cpp
+++ b/noncore/graphics/opie-eye/gui/mainwindow.cpp
@@ -1,327 +1,327 @@
 /*
  * GPLv2 zecke@handhelds.org
  * No WArranty...
  */
 #include "mainwindow.h"
+#include "imageview.h"
 
 #include "iconview.h"
 #include "filesystem.h"
 #include "imageinfoui.h"
-#include "imageview.h"
 #include "viewmodebutton.h"
 
 #include <iface/ifaceinfo.h>
 #include <iface/dirview.h>
 
 #include <opie2/odebug.h>
 #include <opie2/owidgetstack.h>
 #include <opie2/oapplicationfactory.h>
 #include <opie2/otabwidget.h>
 #include <opie2/okeyconfigwidget.h>
 
 #include <qpe/resource.h>
 #include <qpe/config.h>
 #include <qpe/ir.h>
 #include <qpe/applnk.h>
 
 #include <qtoolbar.h>
 #include <qtoolbutton.h>
 #include <qlayout.h>
 #include <qdialog.h>
 #include <qmap.h>
 #include <qtimer.h>
 
 
 
 
 OPIE_EXPORT_APP_V2( Opie::Core::OApplicationFactory<PMainWindow>,"Opie Eye" )
 
 PMainWindow::PMainWindow(QWidget* wid, const char* name, WFlags style)
     : QMainWindow( wid, name, style ), m_info( 0 ), m_disp( 0 )
 {
     setCaption( QObject::tr("Opie Eye Caramba" ) );
     m_cfg = new Opie::Core::OConfig("phunkview");
     m_cfg->setGroup("Zecke_view" );
 //    qDebug( "Process-wide OApplication object @ %0x", oApp );
     /*
      * Initialize ToolBar and IconView
      * And Connect Them
      */
     QToolBar *bar = new QToolBar( this );
     bar->setHorizontalStretchable( true );
     setToolBarsMovable( false );
 
     m_stack = new Opie::Ui::OWidgetStack( this );
     setCentralWidget( m_stack );
 
     m_view = new PIconView( m_stack, m_cfg );
     m_stack->addWidget( m_view, IconView );
     m_stack->raiseWidget( IconView );
     connect(m_view, SIGNAL(sig_display(const QString&)),
             this, SLOT(slotDisplay(const QString&)));
     connect(m_view, SIGNAL(sig_showInfo(const QString&)),
             this, SLOT(slotShowInfo(const QString&)) );
 
     m_stack->forceMode(Opie::Ui::OWidgetStack::NoForce);
 
     QToolButton *btn = new QToolButton( bar );
     btn->setIconSet(  Resource::loadIconSet( "up" ) );
     connect( btn, SIGNAL(clicked()),
              m_view, SLOT(slotDirUp()) );
 
     btn = new PFileSystem( bar );
     connect( btn, SIGNAL( changeDir( const QString& ) ),
              m_view, SLOT(slotChangeDir( const QString& ) ) );
 
     btn = new QToolButton( bar );
     btn->setIconSet( Resource::loadIconSet( "edit" ) );
     connect( btn, SIGNAL(clicked()),
              m_view, SLOT(slotRename()) );
 
     if ( Ir::supported() ) {
         btn = new QToolButton( bar );
         btn->setIconSet( Resource::loadIconSet( "beam" ) );
         connect( btn, SIGNAL(clicked()),
                  m_view, SLOT(slotBeam()) );
     }
 
     btn = new QToolButton( bar );
     btn->setIconSet( Resource::loadIconSet( "trash" ) );
     connect( btn, SIGNAL(clicked() ),
              m_view, SLOT(slotTrash() ) );
 
 
     btn = new ViewModeButton( bar );
     connect( btn, SIGNAL(changeMode(int)),
              m_view, SLOT(slotChangeMode(int)));
 
     btn = new QToolButton( bar );
     btn->setIconSet( Resource::loadIconSet( "SettingsIcon" ) );
     connect( btn, SIGNAL(clicked() ),
              this, SLOT(slotConfig() ) );
 
     rotateButton = new QToolButton(bar);
     rotateButton->setIconSet( Resource::loadIconSet( "rotate" ) );
     rotateButton->setToggleButton(true);
 
     odebug << "Mode = " << m_stack->mode() << oendl;
     if (m_stack->mode() == Opie::Ui::OWidgetStack::SmallScreen) {
         rotateButton->setOn(true);
         autoRotate = true;
     } else {
         rotateButton->setOn(false);
         autoRotate = false;
     }
 
     connect(rotateButton,SIGNAL(toggled(bool)),this,SLOT(slotRotateToggled(bool)));
 
     btn = new QToolButton(bar);
     btn->setIconSet( Resource::loadIconSet( "1to1" ) );
     btn->setToggleButton(true);
     btn->setOn(false);
     connect(btn,SIGNAL(toggled(bool)),this,SLOT(slotScaleToggled(bool)));
     autoScale = true;
 
     btn = new QToolButton(bar);
     btn->setIconSet( Resource::loadIconSet( "mag" ) );
     btn->setToggleButton(true);
     btn->setOn(true);
     connect(btn,SIGNAL(toggled(bool)),this,SLOT(slotZoomerToggled(bool)));
     zoomerOn = true;
 }
 
 PMainWindow::~PMainWindow() {
     odebug << "Shutting down" << oendl;
 }
 
 void PMainWindow::slotZoomerToggled(bool how)
 {
     zoomerOn = how;
     if (m_disp) {
         m_disp->setShowZoomer(zoomerOn);
     }
 }
 
 void PMainWindow::slotRotateToggled(bool how)
 {
     autoRotate = how;
     if (m_disp) {
         m_disp->setAutoRotate(how);
     }
 }
 
 void PMainWindow::slotScaleToggled(bool how)
 {
     autoScale = !how;
     if (m_disp) {
         m_disp->setAutoScale(autoScale);
     }
     if (!autoScale && autoRotate) {
         rotateButton->setOn(false);
     }
     rotateButton->setEnabled(!how);
 }
 
 void PMainWindow::slotConfig() {
    /*
     * have a tab with the possible views
     * a tab for globals image cache size.. scaled loading
     * and one tab for the  KeyConfigs
     */
     QDialog dlg(this, 0, true);
     dlg.setCaption( tr("Phunk View - Config" ) );
 
     QHBoxLayout *lay = new QHBoxLayout(&dlg);
     Opie::Ui::OTabWidget *wid = new Opie::Ui::OTabWidget(&dlg );
     lay->addWidget( wid );
     ViewMap *vM = viewMap();
     ViewMap::Iterator _it = vM->begin();
     QMap<PDirView*, QWidget*> lst;
 
     for( ; _it != vM->end(); ++_it ) {
         PDirView *view = (_it.data())(*m_cfg);
         PInterfaceInfo *inf =  view->interfaceInfo();
         QWidget *_wid = inf->configWidget( *m_cfg );
         _wid->reparent(wid, QPoint() );
         lst.insert( view, _wid );
         wid->addTab( _wid, "fileopen", inf->name() );
     }
 
 /*
  * Add the KeyConfigWidget
  */
     Opie::Ui::OKeyConfigWidget* keyWid = new Opie::Ui::OKeyConfigWidget( wid, "key config" );
     keyWid->setChangeMode( Opie::Ui::OKeyConfigWidget::Queue );
     keyWid->insert( tr("Browser Keyboard Actions"), m_view->manager() );
 
     if ( !m_info ) {
         initInfo();
     }
     keyWid->insert( tr("Imageinfo Keyboard Actions"), m_info->manager() );
 
     if ( !m_disp ) {
         initDisp();
     }
     keyWid->insert( tr("Imageview Keyboard Actions"), m_disp->manager() );
 
     keyWid->load();
     wid->addTab( keyWid, QString::fromLatin1("AppsIcon" ), tr("Keyboard Configuration") );
 
 
     bool act = ( QPEApplication::execDialog( &dlg ) == QDialog::Accepted );
 
 /*
  * clean up
  *apply changes
  */
 
     QMap<PDirView*, QWidget*>::Iterator it;
     for ( it = lst.begin(); it != lst.end(); ++it ) {
         if ( act )
             it.key()->interfaceInfo()->writeConfig(it.data(),  *m_cfg);
         delete it.key();
     }
 
 
     if ( act ) {
         m_view->resetView();
         keyWid->save();
         m_disp->manager()->save();
         m_info->manager()->save();
         m_view->manager()->save();
     }
     delete keyWid;
 }
 
 /*
  * create a new image info component
  * and detach the current one
  * we will make the other delete on exit
  */
 template<class T>
 void PMainWindow::initT( const char* name, T** ptr, int id) {
     if ( *ptr ) {
         (*ptr)->disconnect(this, SLOT(slotReturn()));
         (*ptr)->setDestructiveClose();
         m_stack->removeWidget( *ptr );
     }
     *ptr = new T(m_cfg, m_stack, name );
     m_stack->addWidget( *ptr, id );
 
     connect(*ptr, SIGNAL(sig_return()),
             this,SLOT(slotReturn()));
 
 }
 void PMainWindow::initInfo() {
     initT<imageinfo>( "Image Info", &m_info, ImageInfo );
     connect(m_info,SIGNAL(dispImage(const QString&)),this,SLOT(slotDisplay(const QString&)));
 }
 void PMainWindow::initDisp() {
     initT<ImageView>( "Image ScrollView", &m_disp, ImageDisplay );
     if (m_disp) {
         if (m_stack->mode() != Opie::Ui::OWidgetStack::SmallScreen) {
             m_disp->setMinimumSize(QApplication::desktop()->size()/2);
         }
         m_disp->setAutoScale(autoScale);
         m_disp->setAutoRotate(autoRotate);
         m_disp->setShowZoomer(zoomerOn);
         connect(m_disp,SIGNAL(dispImageInfo(const QString&)),this,SLOT(slotShowInfo(const QString&)));
     }
 }
 
 /**
  * With big Screen the plan could be to 'detach' the image
  * window if visible and to create a ne wone
  * init* already supports it but I make no use of it for
  * now. We set filename and raise
  *
  * ### FIXME and talk to alwin
  */
 void PMainWindow::slotShowInfo( const QString& inf ) {
     if ( !m_info ) {
         initInfo();
     }
     m_info->setPath( inf );
     m_stack->raiseWidget( ImageInfo );
 }
 
 void PMainWindow::slotDisplay( const QString& inf ) {
     if ( !m_disp ) {
         initDisp();
     }
     m_disp->setImage( inf );
     m_stack->raiseWidget( ImageDisplay );
 }
 
 void PMainWindow::slotReturn() {
     raiseIconView();
 }
 
 
 void PMainWindow::closeEvent( QCloseEvent* ev ) {
     /*
      * return from view
      * or properly quit
      */
     if ( m_stack->visibleWidget() == m_info ||
          m_stack->visibleWidget() == m_disp ) {
         raiseIconView();
         ev->ignore();
         return;
     }
     ev->accept();
     QTimer::singleShot(0, qApp, SLOT(closeAllWindows()));
 }
 
 void PMainWindow::raiseIconView() {
     m_stack->raiseWidget( IconView );
 }
 
 void PMainWindow::setDocument( const QString& showImg ) {
     QString file = showImg;
     DocLnk lnk(showImg);
     if (lnk.isValid() )
         file = lnk.file();
 
     slotDisplay( file );
 }
diff --git a/noncore/graphics/opie-eye/gui/mainwindow.h b/noncore/graphics/opie-eye/gui/mainwindow.h
index e9b16d0..adb5dc2 100644
--- a/noncore/graphics/opie-eye/gui/mainwindow.h
+++ b/noncore/graphics/opie-eye/gui/mainwindow.h
@@ -1,72 +1,73 @@
 /*
  * GPLv2 zecke@handhelds.org
  * No WArranty...
  */
 
 #ifndef PHUNK_MAIN_WINDOW_H
 #define PHUNK_MAIN_WINDOW_H
 
 #include <opie2/oconfig.h>
 
 #include <qmainwindow.h>
 
 
 
 namespace Opie {
 namespace Ui{
     class OWidgetStack;
 }
 namespace Core{
     class OKeyConfigManager;
 }
 }
 
+class ImageView;
 class PIconView;
 class imageinfo;
-class ImageView;
+
 class PMainWindow : public QMainWindow {
     Q_OBJECT
     enum Views { IconView,  ImageInfo, ImageDisplay };
 public:
     static QString appName() { return QString::fromLatin1("opie-eye" ); }
     PMainWindow(QWidget*, const char*, WFlags );
     ~PMainWindow();
 
 signals:
     void configChanged();
 
 public slots:
     void slotShowInfo( const QString& inf );
     void slotDisplay( const QString& inf );
     void slotReturn();
     void slotRotateToggled(bool);
     void slotScaleToggled(bool);
     void slotZoomerToggled(bool);
     void setDocument( const QString& );
 
 protected:
     void raiseIconView();
     void closeEvent( QCloseEvent* );
 
 private:
     template<class T>  void initT( const char* name, T**, int );
     void initInfo();
     void initDisp();
 
 private:
     Opie::Core::OConfig *m_cfg;
     Opie::Ui::OWidgetStack *m_stack;
     PIconView* m_view;
     imageinfo *m_info;
     ImageView *m_disp;
     bool autoRotate;
     bool autoScale;
     bool zoomerOn;
     QToolButton*rotateButton;
 
 
 private slots:
     void slotConfig();
 };
 
 #endif
diff --git a/noncore/graphics/opie-eye/lib/oimagezoomer.cpp b/noncore/graphics/opie-eye/lib/oimagezoomer.cpp
index 00b93e2..d1eec67 100644
--- a/noncore/graphics/opie-eye/lib/oimagezoomer.cpp
+++ b/noncore/graphics/opie-eye/lib/oimagezoomer.cpp
@@ -1,219 +1,233 @@
 #include "oimagezoomer.h"
 
+#include <opie2/odebug.h>
+
 #include <qimage.h>
 #include <qpixmap.h>
 #include <qpainter.h>
 #include <qrect.h>
 #include <qpoint.h>
 #include <qsize.h>
 
 namespace Opie {
 namespace MM {
 
 /**
  * \brief The most simple c'tor
  * The main c'tor. You still need to set a QPixmap/QIMage,
  *  setImageSize,setViewPortSize,setVisiblePoint
  *
  * @param parent The parent widget
  * @param name A name for this widget
  * @param fl The widget flags
  *
  */
 OImageZoomer::OImageZoomer( QWidget* parent,  const char* name,  WFlags fl )
     :  QFrame( parent, name, fl ) {
     init();
 }
 
 
 /**
  * \brief This c'tor takes a QPixmap additional
  *
  * You initially set the QPixmap but you still need to provide
  * the additional data to make this widget useful
  *
  * @param pix A Pixmap it'll be converted to a QImage later!
  * @param par The parent widget
  * @param name The name of this widget
  * @param fl The widget flags
  */
 OImageZoomer::OImageZoomer( const QPixmap& pix, QWidget* par, const char* name, WFlags fl )
     : QFrame( par, name, fl ) {
     init();
     setImage( pix );
 }
 
 
 /**
  * \brief This c'tor takes a QImage instead
  * You just provide a QImage which is saved. It behaves the same as the others.
  *
  * @param img A Image which will be used for the zoomer content
  * @param par The  parent of the widget
  * @param name The name of the widget
  * @param fl The widgets flags
  */
 OImageZoomer::OImageZoomer( const QImage& img, QWidget* par, const char* name,  WFlags fl)
     : QFrame( par, name, fl ) {
     init();
     setImage( img );
 }
 
 
 /**
  * \brief overloaded c'tor
  *
  * This differs only in the arguments it takes
  *
  *
  * @param pSize The size of the Page you show
  * @param vSize The size of the viewport. The size of the visible part of the widget
  * @param par The parent of the widget
  * @param name The name
  * @param fl The window flags
  */
 OImageZoomer::OImageZoomer( const QSize& pSize, const QSize& vSize, QWidget* par,
                             const char* name, WFlags fl )
     : QFrame( par, name, fl ), m_imgSize( pSize ),m_visSize( vSize ) {
     init();
 }
 
 /**
  * d'tor
  */
 OImageZoomer::~OImageZoomer() {
 
 }
 
 void OImageZoomer::init() {
+    m_mevent = false;
     setFrameStyle( Panel | Sunken );
 }
 
 
 /**
  * \brief set the page/image size
  * Tell us the QSize of the Data you show to the user. We need this
  * to do the calculations
  *
  * @param size The size of the stuff you want to zoom on
  */
 void OImageZoomer::setImageSize( const QSize& size ) {
     m_imgSize = size;
     repaint();
 }
 
 /**
  * \brief Set the size of the viewport
  * Tell us the QSize of the viewport. The viewport is the part
  * of the widget which is exposed on the screen
  *
  * @param size Te size of the viewport
  *
  * @see QScrollView::viewport()
  */
 void OImageZoomer::setViewPortSize( const QSize& size ) {
     m_visSize = size;
     repaint();
 }
 
 /**
  * \brief the point in the topleft corner which is currently visible
  * Set the visible point. This most of the times relate to QScrollView::contentsX()
  * and QScrollView::contentsY()
  *
  * @see setVisiblePoint(int,int)
  */
 void OImageZoomer::setVisiblePoint( const QPoint& pt ) {
     m_visPt = pt;
     repaint();
 }
 
 
 /**
  * Set the Image. The image will be resized on resizeEvent
  * and it'll set the QPixmap background
  *
  * @param img The image will be stored internally and used as the background
  */
 void OImageZoomer::setImage( const QImage& img) {
     m_img = img;
     resizeEvent( 0 );
     repaint();
 }
 
 /**
  * overloaded function it calls the QImage version
  */
 void OImageZoomer::setImage( const QPixmap& pix) {
     setImage( pix.convertToImage() );
 }
 
 void OImageZoomer::resizeEvent( QResizeEvent* ev ) {
     QFrame::resizeEvent( ev );
     setBackgroundOrigin(  QWidget::WidgetOrigin );
     // TODO Qt3 use PalettePixmap and use size
     QPixmap pix; pix.convertFromImage( m_img.smoothScale( size().width(), size().height() ) );
     setBackgroundPixmap( pix);
 }
 
 void OImageZoomer::drawContents( QPainter* p ) {
     /*
      * if the page size
      */
     if ( m_imgSize.isEmpty() )
         return;
 
    /*
     * paint a red rect which represents the visible size
     *
     * We need to recalculate x,y and width and height of the
     * rect. So image size relates to contentRect
     *
     */
     QRect c( contentsRect() );
     p->setPen( Qt::red );
 
     /*
      * the contentRect is set equal to the size of the image
      * Rect/Original = NewRectORWidth/OriginalVisibleStuff and then simply we
      * need to add the c.y/x due usage of QFrame
      * For x and y we use the visiblePoint
      * For height and width we use the size of the viewport
      * if width/height would be bigger than our widget we use this width/height
      *
      */
     int len = m_imgSize.width();
     int x = (c.width()*m_visPt.x())/len        + c.x();
     int w = (c.width()*m_visSize.width() )/len + c.x();
     if ( w > c.width() ) w = c.width();
 
     len = m_imgSize.height();
     int y = (c.height()*m_visPt.y() )/len          + c.y();
     int h = (c.height()*m_visSize.height() )/len + c.y();
     if ( h > c.height() ) h = c.height();
 
     p->drawRect( x, y, w, h );
 }
 
-void OImageZoomer::mousePressEvent( QMouseEvent*  ) {
+void OImageZoomer::mousePressEvent( QMouseEvent*ev) {
     m_mouseX = m_mouseY = -1;
+    m_mevent = true;
+}
+
+void OImageZoomer::mouseReleaseEvent( QMouseEvent*ev) {
+    if (!m_mevent) return;
+    int mx, my;
+    mx = ev->x();
+    my = ev->y();
+    int diffx = (mx) * m_imgSize.width() / width();
+    int diffy = (my) * m_imgSize.height() / height();
+    emit zoomArea(diffx,diffy);
 }
 
 void OImageZoomer::mouseMoveEvent( QMouseEvent* ev ) {
     int mx, my;
     mx = ev->x();
     my = ev->y();
 
     if ( m_mouseX != -1 && m_mouseY != -1 ) {
+        m_mevent = false;
         int diffx = ( mx - m_mouseX ) * m_imgSize.width() / width();
         int diffy = ( my - m_mouseY ) * m_imgSize.height() / height();
         emit zoomAreaRel( diffx, diffy );
-        emit zoomArea(m_visPt.x()+diffx, m_visPt.y()+diffy );
     }
     m_mouseX = mx;
     m_mouseY = my;
 }
 
 
 }
 }
diff --git a/noncore/graphics/opie-eye/lib/oimagezoomer.h b/noncore/graphics/opie-eye/lib/oimagezoomer.h
index 2516c61..0b356c9 100644
--- a/noncore/graphics/opie-eye/lib/oimagezoomer.h
+++ b/noncore/graphics/opie-eye/lib/oimagezoomer.h
@@ -1,134 +1,141 @@
 #ifndef OPIE_ODP_IMAGE_ZOOMER_H
 #define OPIE_ODP_IMAGE_ZOOMER_H
 
 #include <qframe.h>
 #include <qimage.h>
 
 class QPixmap;
 class QRect;
 class QPoint;
 
 
 namespace Opie {
 namespace MM   {
 
 /**
  * \brief small class to zoom over a Page
  *
  *  This class represents your page but smaller.
  *  It can draw a Rect on top of an Image/Pixmap you supply
  *  and you can allow the user easily zooming/moving
  *  over your widget.
  *  All you need to do is to supply a image/pixmap, the visible size
  *  and the original image/pixmap size and the current visible top/left
  *  position.
  *
  *  This Image works perfectly with QScrollView as you can connect
  *  QScrollView::contentsMoving to setVisiblePoint slot and the zoomAreRel
  *  to the QScrollView::scrollBy slot. Now you would only need to watch
  *  the resize event anf give us the new information about QScrollView::viewport
  *
  *  You need to position and set the size of this widget! using setFixedSize() is quite
  *  a good idea for this widget
  *
  * @see QScrollView
  * @see QScrollView::viewport()
  *
  * @since 1.2
  *
  */
 class OImageZoomer : public QFrame {
     Q_OBJECT
 public:
     OImageZoomer( QWidget* parent = 0, const char* name = 0, WFlags fl = 0 );
     OImageZoomer( const QPixmap&,QWidget* parent = 0, const char* name = 0,  WFlags fl = 0 );
     OImageZoomer( const QImage&, QWidget* parent = 0, const char* name= 0, WFlags fl = 0 );
     OImageZoomer( const QSize&, const QSize&, QWidget* par, const char*, WFlags fl );
     ~OImageZoomer();
 
 public slots:
     void setImageSize( const QSize& );
     void setViewPortSize( const QSize& );
     void setVisiblePoint( const QPoint& );
     void setVisiblePoint( int x, int y );
     void setImage( const QImage& );
     void setImage( const QPixmap& );
 
 signals:
     /**
      * Relative movement in the coordinates of the viewport
      * This signal can easily be connected to QScrollView::scrollBy.
      * This signal is emitted from within the mouseMoveEvent of this widget
      *
      *
      * @param x The way to move relative on the X-Axis
      * @param y The way to move relative on the Y-Axis
      *
      * @see setVisiblePoint
      * @see QScrollView::scrollBy
      */
     void zoomAreaRel( int x,int y);
 
     /**
      * Here you get absolute coordinates.
-     * This slot will be emitted from within the mouseMoveEvent of this widget.
+     * This slot will be emitted from within the mouseReleaseEvent of this widget.
+     * if no mouse move where done.
      * So you may not delete this widget
      *
      * @param x The absolute X Coordinate to scroll to.
      * @param y The absolute Y Coordinate to scroll to.
      *
      */
     void zoomArea( int x,int y);
 
 public:
     /**
      * make sure to call these if you reimplement
      * @internal
      */
     void resizeEvent( QResizeEvent* );
 
 protected:
     /**
      * make sure to call these if you reimplement
      * @internal
      */
     void drawContents( QPainter* p );
 
     /**
      * make sure to call these if you reimplememt
      * @internal
      */
-    void mousePressEvent( QMouseEvent* ev );
+    virtual void mousePressEvent( QMouseEvent* ev );
     /**
      * make sure to call these if you reimplement
      * @internal
      */
-    void mouseMoveEvent( QMouseEvent* ev );
+    virtual void mouseMoveEvent( QMouseEvent* ev );
+    /**
+     * make sure to call these if you reimplement
+     * @internal
+     */
+    virtual void mouseReleaseEvent( QMouseEvent* ev );
 
 private:
     /**
      * @internal
      */
     void init();
     QImage m_img;
     QSize m_imgSize, m_visSize;
     QPoint m_visPt;
     int m_mouseX, m_mouseY;
+    bool m_mevent;
 };
 
 /**
  * This slot is present for convience. You can connect the
  * QScrollView::contentsMoved to this slot and it calls the QPoint
  * version for you
  * This realtes to QScrollView::contentsX() and QScrollView::contentsY()
  *
  * @param x The top left x coordinate
  * @param y The top left y coorisnate
  */
 inline void OImageZoomer::setVisiblePoint( int x, int y ) {
     setVisiblePoint( QPoint( x, y ) );
 }
 
 }
 }
 #endif