zoomer widget better integrated, size of it depends on the size of the displayed image,

may switched off by user and so on.

4 files changed, 56 insertions, 9 deletions

diff --git a/noncore/graphics/opie-eye/gui/imagescrollview.cpp b/noncore/graphics/opie-eye/gui/imagescrollview.cpp
index 5b12258..2f16d82 100644
--- a/noncore/graphics/opie-eye/gui/imagescrollview.cpp
+++ b/noncore/graphics/opie-eye/gui/imagescrollview.cpp
@@ -1,52 +1,52 @@
 #include "imagescrollview.h"
 
 #include <opie2/odebug.h>
 
 using namespace Opie::Core;
 
 #include <qimage.h>
 #include <qlayout.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),first_resize_done(false),m_lastName("")
+     rotate_to_fit(true),show_zoomer(true),first_resize_done(false),m_lastName("")
 {
     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),first_resize_done(false),m_lastName("")
+    rotate_to_fit(rfit),show_zoomer(true),first_resize_done(false),m_lastName("")
 {
     _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),first_resize_done(false),m_lastName("")
+    rotate_to_fit(rfit),show_zoomer(true),first_resize_done(false),m_lastName("")
 {
     init();
     setImage(img);
 }
 
 void ImageScrollView::setImage(const QImage&img)
 {
     _image_data = QImage();
     _original_data=img;
     _original_data.convertDepth(QPixmap::defaultDepth());
     _original_data.setAlphaBuffer(false);
     m_lastName = "";
     if (first_resize_done) {
         generateImage();
     }
 }
 
 void ImageScrollView::setImage( const QString& path ) {
     odebug << "load new image " << oendl;
     if (m_lastName == path) return;
     m_lastName = path;
     _original_data.load(path);
     _original_data.convertDepth(QPixmap::defaultDepth());
     _original_data.setAlphaBuffer(false);
@@ -59,50 +59,50 @@ void ImageScrollView::setImage( const QString& path ) {
 /* should be called every time the QImage changed it content */
 void ImageScrollView::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(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);
     if (first_resize_done) {
         last_rot = Rotate0;
         generateImage();
-        odebug << "reinit display " << oendl;
     } else if (_original_data.size().isValid()) {
+        if (image_fit_into(_original_data.size()) || !show_zoomer) _zoomer->hide();
         resizeContents(_original_data.width(),_original_data.height());
     }
 }
 
 void ImageScrollView::setAutoRotate(bool how)
 {
     /* to avoid double repaints */
     if (rotate_to_fit != how) {
         rotate_to_fit = how;
         _image_data = QImage();
         generateImage();
     }
 }
 
 void ImageScrollView::setAutoScale(bool how)
 {
     scale_to_fit = how;
     if (!how) {
         rotate_to_fit = false;
     }
     _image_data = QImage();
     generateImage();
 }
 
@@ -245,74 +245,77 @@ void ImageScrollView::generateImage()
         if (rotate_to_fit) r = Rotate90;
     }
     odebug << " r = " << r << oendl;
     if (scale_to_fit) {
         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) {
         if (r==Rotate0) {
             _image_data = _original_data;
         } else {
             rotate_into_data(r);
         }
         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 );
-
     /*
      * invalidate
      */
     _image_data=QImage();
 }
 
 void ImageScrollView::resizeEvent(QResizeEvent * e)
 {
     odebug << "ImageScrollView resizeEvent" << oendl;
     QScrollView::resizeEvent(e);
     generateImage();
     first_resize_done = true;
     emit viewportSizeChanged( viewport()->size() );
 
-   /*
-    * move scrollbar
-    */
-    _zoomer->setGeometry( viewport()->width()-100, viewport()->height()-50, 100, 50 );
 }
 
 void ImageScrollView::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);
 }
@@ -377,24 +380,47 @@ void ImageScrollView::viewportMouseMoveEvent(QMouseEvent* e)
     }
     _mouseStartPosX=mx;
     _mouseStartPosY=my;
 }
 
 void ImageScrollView::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() {
     WFlags fl = getWFlags();
     /* clear it just in case */
     fl &= ~WDestructiveClose;
     fl |= WDestructiveClose;
     setWFlags( fl );
 }
+
+bool ImageScrollView::image_fit_into(const QSize&s )
+{
+    if (s.width()>width()||s.height()>height()) {
+        return false;
+    }
+    return true;
+}
+
+void ImageScrollView::setShowZoomer(bool how)
+{
+    show_zoomer = how;
+    check_zoomer();
+}
+
+void ImageScrollView::check_zoomer()
+{
+    if ( (!show_zoomer||image_fit_into(_pdata.size()) ) && _zoomer->isVisible()) {
+        _zoomer->hide();
+    } else if ( show_zoomer && !image_fit_into(_pdata.size()) && _zoomer->isHidden()){
+        _zoomer->show();
+    }
+}
diff --git a/noncore/graphics/opie-eye/gui/imagescrollview.h b/noncore/graphics/opie-eye/gui/imagescrollview.h
index 1b25103..e209dfb 100644
--- a/noncore/graphics/opie-eye/gui/imagescrollview.h
+++ b/noncore/graphics/opie-eye/gui/imagescrollview.h
@@ -7,65 +7,69 @@
 #include <qimage.h>
 #include <qpixmap.h>
 #include <qstring.h>
 #include <qdialog.h>
 
 
 
 class QPainter;
 
 class ImageScrollView: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();
 
     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
     };
 
 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;
     Rotation last_rot;
     QString m_lastName;
     virtual void rescaleImage(int w, int h);
 
     virtual void rotate_into_data(Rotation r);
     virtual void generateImage();
+    bool image_fit_into(const QSize&s);
+    void check_zoomer();
 
 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/mainwindow.cpp b/noncore/graphics/opie-eye/gui/mainwindow.cpp
index 3650493..ef23f79 100644
--- a/noncore/graphics/opie-eye/gui/mainwindow.cpp
+++ b/noncore/graphics/opie-eye/gui/mainwindow.cpp
@@ -85,54 +85,68 @@ PMainWindow::PMainWindow(QWidget* wid, const char* name, WFlags style)
     btn = new QToolButton( bar );
     btn->setIconSet( Resource::loadIconSet( "trash" ) );
     connect( btn, SIGNAL(clicked() ),
              m_view, SLOT(slotTrash() ) );
 
     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);
     rotateButton->setOn(true);
     connect(rotateButton,SIGNAL(toggled(bool)),this,SLOT(slotRotateToggled(bool)));
     autoRotate = true;
 
     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
@@ -210,48 +224,49 @@ void PMainWindow::slotConfig() {
  */
 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) {
         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();
     }
diff --git a/noncore/graphics/opie-eye/gui/mainwindow.h b/noncore/graphics/opie-eye/gui/mainwindow.h
index 59dba30..e9b16d0 100644
--- a/noncore/graphics/opie-eye/gui/mainwindow.h
+++ b/noncore/graphics/opie-eye/gui/mainwindow.h
@@ -20,51 +20,53 @@ namespace Core{
     class OKeyConfigManager;
 }
 }
 
 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