| -rw-r--r-- | libopie2/opiemm/oimagescrollview.cpp | 585 | ||||
| -rw-r--r-- | libopie2/opiemm/oimagescrollview.h | 95 | ||||
| -rw-r--r-- | libopie2/opiemm/oimagezoomer.cpp | 233 | ||||
| -rw-r--r-- | libopie2/opiemm/oimagezoomer.h | 141 | ||||
| -rw-r--r-- | libopie2/opiemm/opiemm.pro | 4 |
5 files changed, 1056 insertions, 2 deletions
diff --git a/libopie2/opiemm/oimagescrollview.cpp b/libopie2/opiemm/oimagescrollview.cpp new file mode 100644 index 0000000..0e86bd0 --- a/dev/null +++ b/libopie2/opiemm/oimagescrollview.cpp @@ -0,0 +1,585 @@ +#include "oimagescrollview.h" + +#include <opie2/oimagezoomer.h> +#include <opie2/odebug.h> +#include <opie2/oapplication.h> +#include <opie2/owait.h> + +#include <qimage.h> +#include <qlayout.h> +#include <qpe/qcopenvelope_qws.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; + 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); + 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; + 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); + if (FirstResizeDone()) { + generateImage(); + } +} + +void OImageScrollView::loadJpeg(bool interncall) +{ + if (m_lastName.isEmpty()) return; + QImageIO iio( m_lastName, 0l ); + QString param; + bool real_load = false; + 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()); + setImageScaledLoaded(true); + real_load = true; + } + } else { + if (ImageScaledLoaded()||!interncall) { + odebug << "Load jpeg unscaled" << oendl; + real_load = true; + } + 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 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") { + setImageIsJpeg(true); + loadJpeg(); + } else { + { + QCopEnvelope( "QPE/System", "busy()" ); + } + 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 (FirstResizeDone()) { + generateImage(); + } +} + +/* 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&)) ); + + viewport()->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()); + } +} + +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::setAutoScale(bool how) +{ + m_states.setBit(AUTO_SCALE,how); + if (!how) { + setAutoRotate(false); + } + _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; + } + + } + _image_data = dest; +} + +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 (AutoRotate()) r = Rotate90; + } + + odebug << " r = " << r << oendl; + 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 (!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; + 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 + */ + 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 OImageScrollView::resizeEvent(QResizeEvent * e) +{ + odebug << "OImageScrollView resizeEvent" << oendl; + QScrollView::resizeEvent(e); + 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) +{ + 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 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 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 OImageScrollView::setDestructiveClose() { + WFlags fl = getWFlags(); + /* clear it just in case */ + fl &= ~WDestructiveClose; + fl |= WDestructiveClose; + setWFlags( fl ); +} + +bool OImageScrollView::image_fit_into(const QSize&s ) +{ + if (s.width()>width()||s.height()>height()) { + return false; + } + return true; +} + +void OImageScrollView::setShowZoomer(bool how) +{ + m_states.setBit(SHOW_ZOOMER,how); + check_zoomer(); +} + +bool OImageScrollView::ShowZoomer()const +{ + return m_states.testBit(SHOW_ZOOMER); +} + +void OImageScrollView::check_zoomer() +{ + if (!_zoomer) return; + if ( (!ShowZoomer()||image_fit_into(_pdata.size()) ) && _zoomer->isVisible()) { + _zoomer->hide(); + } 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/libopie2/opiemm/oimagescrollview.h b/libopie2/opiemm/oimagescrollview.h new file mode 100644 index 0000000..3d2ea38 --- a/dev/null +++ b/libopie2/opiemm/oimagescrollview.h @@ -0,0 +1,95 @@ +#ifndef _IMAGE_SCROLL_VIEW_H +#define _IMAGE_SCROLL_VIEW_H + +#include <qscrollview.h> +#include <qimage.h> +#include <qpixmap.h> +#include <qstring.h> +#include <qdialog.h> +#include <qbitarray.h> + + +class QPainter; + +namespace Opie { namespace MM { + + class OImageZoomer; + +class OImageScrollView:public QScrollView +{ + Q_OBJECT +public: + 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 setDestructiveClose(); + + virtual void setAutoRotate(bool); + virtual void setAutoScale(bool); + virtual void setShowZoomer(bool); + + 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 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; + + 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/libopie2/opiemm/oimagezoomer.cpp b/libopie2/opiemm/oimagezoomer.cpp new file mode 100644 index 0000000..d1eec67 --- a/dev/null +++ b/libopie2/opiemm/oimagezoomer.cpp @@ -0,0 +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*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 ); + } + m_mouseX = mx; + m_mouseY = my; +} + + +} +} diff --git a/libopie2/opiemm/oimagezoomer.h b/libopie2/opiemm/oimagezoomer.h new file mode 100644 index 0000000..0b356c9 --- a/dev/null +++ b/libopie2/opiemm/oimagezoomer.h @@ -0,0 +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 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 + */ + virtual void mousePressEvent( QMouseEvent* ev ); + /** + * make sure to call these if you reimplement + * @internal + */ + 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 diff --git a/libopie2/opiemm/opiemm.pro b/libopie2/opiemm/opiemm.pro index f386618..09b5ed4 100644 --- a/libopie2/opiemm/opiemm.pro +++ b/libopie2/opiemm/opiemm.pro @@ -1,8 +1,8 @@ TEMPLATE = lib CONFIG += qt warn_on DESTDIR = $(OPIEDIR)/lib -HEADERS = osoundsystem.h -SOURCES = osoundsystem.cpp +HEADERS = osoundsystem.h oimagezoomer.h oimagescrollview.h +SOURCES = osoundsystem.cpp oimagezoomer.cpp oimagescrollview.cpp INTERFACES = TARGET = opiemm2 VERSION = 1.9.0 |