Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdegraphics@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 953 insertions, 0 deletions

diff --git a/kview/kviewcanvas/kimagecanvas.cpp b/kview/kviewcanvas/kimagecanvas.cpp
new file mode 100644
index 00000000..6c54850f
--- /dev/null
+++ b/kview/kviewcanvas/kimagecanvas.cpp
@@ -0,0 +1,953 @@
+/*  This file is part of the KDE project
+    Copyright (C) 2001-2002 Matthias Kretz <kretz@kde.org>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License version 2
+    as published by the Free Software Foundation.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+*/
+
+#include "kimagecanvas.h"
+#include "kimageholder.h"
+#include "version.h"
+#include "config/defaults.h"
+
+#include <qcolor.h>
+#include <qimage.h>
+#include <qapplication.h>
+#include <qwmatrix.h>
+#include <qtimer.h>
+
+#include <kpixmap.h>
+#include <kdebug.h>
+#include <kgenericfactory.h>
+#include <ksettings/dispatcher.h>
+#include <kconfig.h>
+
+#define KIMAGECANVAS_WIPESIZE 5
+
+const int MOUSECURSORHIDETIME = 3000;
+
+//extern bool qt_use_xrender;
+
+typedef KGenericFactory<KImageCanvas> KImageCanvasFactory;
+K_EXPORT_COMPONENT_FACTORY( libkviewcanvas,
+		KImageCanvasFactory( "kviewcanvas" ) )
+
+KImageCanvas::KImageCanvas( QWidget * parent, const char * name, const QStringList & )
+	: QScrollView( parent, name, WResizeNoErase | WStaticContents )
+	, m_client( 0 )
+	, m_oldClient( 0 )
+	, m_image( 0 )
+	, m_imageTransformed( 0 )
+	, m_pixmap( 0 )
+	, m_pTimer( new QTimer( this, "KImageCanvas/Timer" ) )
+	, m_maxsize( Defaults::maxSize )
+	, m_minsize( Defaults::minSize )
+	, m_currentsize( 0, 0 )
+	, m_zoom( 1.0 )
+	, m_fastscale( ! Defaults::smoothScaling )
+	, m_keepaspectratio( Defaults::keepAspectRatio )
+	, m_bImageChanged( false )
+	, m_bSizeChanged( false )
+	, m_bNeedNewPixmap( false )
+	, m_bCentered( Defaults::centerImage )
+	, m_bImageUpdateScheduled( false )
+	, m_bNewImage( false )
+	, m_iBlendTimerId( 0 )
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	setFrameStyle( QFrame::NoFrame );
+	setResizePolicy( QScrollView::Manual );
+	setMinimumSize( 0, 0 );
+	setBgColor( Defaults::bgColor );
+
+	connect( this, SIGNAL( imageChanged() ), this, SLOT( slotImageChanged() ) );
+	connect( m_pTimer, SIGNAL( timeout() ), this, SLOT( hideCursor() ) );
+
+	KSettings::Dispatcher::self()->registerInstance(
+			KImageCanvasFactory::instance(), this,
+			SLOT( loadSettings() ) );
+
+	viewport()->setFocusProxy( this );
+	clear();
+
+	QWidget::setMouseTracking( true );
+	viewport()->setMouseTracking( true );
+	m_cursor.setShape( Qt::CrossCursor );
+	viewport()->setCursor( m_cursor );
+	m_pTimer->start( MOUSECURSORHIDETIME, true );
+
+	loadSettings();
+}
+
+KImageCanvas::~KImageCanvas()
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	delete m_image; m_image = 0;
+	delete m_pixmap; m_pixmap = 0;
+}
+
+void KImageCanvas::setBgColor( const QColor & color )
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	viewport()->setPaletteBackgroundColor( color );
+	if( m_client )
+		m_client->setPaletteBackgroundColor( color );
+}
+
+const QColor & KImageCanvas::bgColor() const
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	return viewport()->paletteBackgroundColor();
+}
+
+int KImageCanvas::imageDepth() const
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	if( ! m_image )
+		return 0;
+
+	return m_image->depth();
+}
+
+QSize KImageCanvas::imageSize() const
+{
+	//kdDebug( 4620 ) << k_funcinfo << endl;
+	if( ! m_image )
+		return QSize( 0, 0 );
+
+	return m_matrix.isIdentity() ? m_image->size() : m_matrix.mapRect( QRect( QPoint(), m_image->size() ) ).size();
+}
+
+QSize KImageCanvas::currentSize() const
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	if( ! m_image )
+		return QSize( 0, 0 );
+
+	return m_currentsize;
+}
+
+const QImage * KImageCanvas::image() const
+{
+	if( m_imageTransformed )
+		return m_imageTransformed;
+	return m_image;
+}
+
+QRect KImageCanvas::selection() const
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	if( m_client )
+		return m_selection;
+	else
+		return QRect();
+}
+
+void KImageCanvas::setCentered( bool centered )
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	if( m_bCentered != centered )
+	{
+		m_bCentered = centered;
+		center();
+	}
+}
+
+void KImageCanvas::setImage( const QImage & newimage )
+{
+	bool emitHasImage = m_image ? false : true;
+	m_matrix.reset();
+	matrixChanged();
+	delete m_image;
+	m_image = new QImage( newimage );
+	m_bNewImage = true;
+	// don't emit the signal here - call the slot directly
+	slotImageChanged();
+
+	sizeFromZoom( m_zoom );
+	updateImage();
+	if( emitHasImage && m_image )
+		emit hasImage( true );
+}
+
+void KImageCanvas::setImage( const QImage & newimage, const QSize & size )
+{
+	kdDebug( 4620 ) << k_funcinfo << size << endl;
+	bool emitHasImage = m_image ? false : true;
+	m_matrix.reset();
+	matrixChanged();
+	delete m_image;
+	m_image = new QImage( newimage );
+	m_bNewImage = true;
+	// don't emit the signal here - call the slot directly
+	slotImageChanged();
+
+	resizeImage( size );
+	updateImage();
+	if( emitHasImage && m_image )
+		emit hasImage( true );
+}
+
+void KImageCanvas::setZoom( double zoom )
+{
+	kdDebug( 4620 ) << k_funcinfo << zoom << endl;
+	if( m_image == 0 )
+		return;
+
+	if( zoom > 0.0 && m_zoom != zoom )
+	{
+		m_zoom = zoom;
+		sizeFromZoom( m_zoom );
+		emit zoomChanged( m_zoom );
+		updateImage();
+	}
+}
+
+void KImageCanvas::boundImageTo( const QSize & size )
+{
+	bool keepAspectRatio = m_keepaspectratio;
+	m_keepaspectratio = true;
+	resizeImage( size );
+	m_keepaspectratio = keepAspectRatio;
+}
+
+void KImageCanvas::setMaximumImageSize( const QSize & maxsize )
+{
+	kdDebug( 4620 ) << k_funcinfo << maxsize << endl;
+	if( ( ! m_minsize.isEmpty() ) &&
+			( maxsize.width() < m_minsize.width() || maxsize.height() < m_minsize.height() ) )
+	{
+		kdWarning( 4620 ) << "the new maximum image size is smaller than the minimum size" << endl;
+		return;
+	}
+
+	m_maxsize = maxsize;
+
+	resizeImage( m_currentsize );
+}
+
+void KImageCanvas::setMinimumImageSize( const QSize & minsize )
+{
+	kdDebug( 4620 ) << k_funcinfo << minsize << endl;
+	if( ( ! m_maxsize.isEmpty() ) &&
+			( minsize.width() > m_maxsize.width() || minsize.height() > m_maxsize.height() ) )
+	{
+		kdWarning( 4620 ) << "the new minimum image size is greater than the maximum size" << endl;
+		return;
+	}
+
+	m_minsize = minsize;
+
+	resizeImage( m_currentsize );
+}
+
+void KImageCanvas::resizeImage( const QSize & newsize )
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	if( m_image == 0 )
+		return;
+
+	QSize size = newsize;
+
+	// check that it fits into min and max sizes
+	checkBounds( size );
+
+	// calculate the new zoom factor
+	zoomFromSize( size );
+
+	if( size != m_currentsize )
+	{
+		m_currentsize = size;
+		sizeChanged();
+
+		updateImage();
+	}
+}
+
+void KImageCanvas::hideScrollbars( bool hidden )
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	if( hidden )
+	{
+		setVScrollBarMode( AlwaysOff );
+		setHScrollBarMode( AlwaysOff );
+	}
+	else
+	{
+		setVScrollBarMode( Auto );
+		setHScrollBarMode( Auto );
+	}
+}
+
+void KImageCanvas::setKeepAspectRatio( bool aspect )
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	m_keepaspectratio = aspect;
+}
+
+unsigned int KImageCanvas::numOfBlendEffects() const
+{
+	return Defaults::numOfBlendEffects;
+}
+
+QString KImageCanvas::blendEffectDescription( unsigned int idx ) const
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	switch( idx )
+	{
+		case NoBlending:
+			kdWarning( 4620 ) << k_funcinfo << " shouldn't be called with an index of 0 - That's always not really defined\n";
+			return i18n( Defaults::blendEffectDescription[ 0 ] );
+		case AlphaBlend:
+			return i18n( Defaults::blendEffectDescription[ 5 ] );
+		case WipeFromLeft:
+			return i18n( Defaults::blendEffectDescription[ 1 ] );
+		case WipeFromRight:
+			return i18n( Defaults::blendEffectDescription[ 2 ] );
+		case WipeFromTop:
+			return i18n( Defaults::blendEffectDescription[ 3 ] );
+		case WipeFromBottom:
+			return i18n( Defaults::blendEffectDescription[ 4 ] );
+	}
+	kdError( 4620 ) << "Effect description for effect with index " << idx << " doesn't exist\n";
+	return QString::null;
+}
+
+bool KImageCanvas::eventFilter( QObject * obj, QEvent * ev )
+{
+	if( ( obj == m_client || obj == m_oldClient ) && ev->type() == QEvent::MouseMove )
+		mouseMoveEvent( static_cast<QMouseEvent*>( ev ) );
+	return QScrollView::eventFilter( obj, ev );
+}
+
+void KImageCanvas::setFastScale( bool fastscale )
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	m_fastscale = fastscale;
+	if( m_fastscale )
+	{
+		// wo do scaling with a matrix now, so the m_imageTransformed isn't needed anymore
+		delete m_imageTransformed;
+		m_imageTransformed = 0;
+	}
+	else
+	{
+		matrixChanged(); // set the flag to dirty so that a new m_imageTransformed will be created
+						 // else we very relyably get a crash
+	}
+	updateImage();
+}
+
+void KImageCanvas::clear()
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	bool emitHasImage = m_image ? true : false;
+	delete m_image;
+	m_image = 0;
+	m_currentsize -= m_currentsize; //zero size
+	if( m_client )
+		m_client->clear();
+	if( emitHasImage && ! m_image )
+		emit hasImage( false );
+}
+
+void KImageCanvas::flipHorizontal( bool change )
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	if( m_image == 0 )
+		return;
+
+	if( change )
+	{
+		QWMatrix matrix( 1.0F, 0.0F, 0.0F, -1.0F, 0.0F, 0.0F );
+		*m_image = m_image->xForm( matrix );
+		emit imageChanged();
+	}
+	else
+	{
+		m_matrix.scale( 1.0, -1.0 );
+		matrixChanged();
+	}
+	// size didn't change
+	updateImage();
+}
+
+void KImageCanvas::flipVertical( bool change )
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	if( m_image == 0 )
+		return;
+
+	if( change )
+	{
+		QWMatrix matrix( -1.0F, 0.0F, 0.0F, 1.0F, 0.0F, 0.0F );
+		*m_image = m_image->xForm( matrix );
+		emit imageChanged();
+	}
+	else
+	{
+		m_matrix.scale( -1.0, 1.0 );
+		matrixChanged();
+	}
+	// size didn't change
+	updateImage();
+}
+
+void KImageCanvas::rotate( double a, bool change )
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	if( m_image == 0 )
+		return;
+
+	if( change )
+	{
+		QWMatrix matrix;
+		matrix.rotate( a );
+		*m_image = m_image->xForm( matrix );
+		emit imageChanged();
+	}
+	else
+	{
+		m_matrix.rotate( a );
+		matrixChanged();
+	}
+	//adjust m_currentsize
+	sizeFromZoom( m_zoom );
+	updateImage();
+}
+
+void KImageCanvas::checkBounds( QSize & newsize )
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	if( m_keepaspectratio )
+	{
+		// check that the new size has the same aspect ratio the original image had
+		QSize origsize = imageSize();
+		double x1 = double( origsize.height() ) / double( newsize.height() );
+		double x2 = double( origsize.width() ) / double( newsize.width() );
+		if( ( newsize * x1 != origsize ) || ( newsize * x2 != origsize ) )
+		{
+			// not OK
+			kdDebug( 4620 ) << "checkBounds: the aspect ratio wasn't kept changing from " << newsize << endl;
+			// the user want's that the aspect ratio doesn't change. The
+			// question is: make it larger or smaller?
+			// we make it smaller (we depend on that in boundImageTo)
+			newsize = origsize / KMAX( x1, x2 );
+			kdDebug( 4620 ) << "checkBounds: to " << newsize << endl;
+		}
+	}
+	if( ( ! m_maxsize.isEmpty() ) &&
+			( newsize.width() > m_maxsize.width() || newsize.height() > m_maxsize.height() ) )
+	{
+		kdDebug( 4620 ) << "checkBounds: the new size is bigger than the max size" << endl;
+		if( m_keepaspectratio )
+		{
+			double x1 = double( m_maxsize.height() ) / double( newsize.height() );
+			double x2 = double( m_maxsize.width() ) / double( newsize.width() );
+			double x = KMIN( x1, x2 );//( x1 > x2 ) ? x2 : x1;
+			newsize *= x;
+		}
+		else
+			newsize = newsize.boundedTo( m_maxsize );
+	}
+	if( ( ! m_minsize.isEmpty() ) &&
+			( newsize.width() < m_minsize.width() || newsize.height() < m_minsize.height() ) )
+	{
+		kdDebug( 4620 ) << "checkBounds: the new size is smaller than the min size" << endl;
+		if( m_keepaspectratio )
+		{
+			double x1 = double( m_minsize.height() ) / double( newsize.height() );
+			double x2 = double( m_minsize.width() ) / double( newsize.width() );
+			double x = KMAX( x1, x2 );//( x1 > x2 ) ? x1 : x2;
+			newsize *= x;
+		}
+		else
+			newsize = newsize.expandedTo( m_minsize );
+	}
+	// if it still won't fit we have a problem: we can't keep the aspect ratio or we have
+	// to violate the min/max settings
+	if( ( ! m_maxsize.isEmpty() ) &&
+			( newsize.width() > m_maxsize.width() || newsize.height() > m_maxsize.height() ) )
+	{
+		kdDebug( 4620 ) << "checkBounds: Sorry, I can't keep the aspect ratio." << endl;
+		newsize = newsize.boundedTo( m_maxsize );
+	}
+}
+
+void KImageCanvas::zoomFromSize( const QSize & newsize )
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	if( ! m_image )
+		return;
+
+	QSize originalsize = imageSize();
+	double widthzoom = double( newsize.width() ) / double( originalsize.width() );
+	double heightzoom = double( newsize.height() ) / double( originalsize.height() );
+	double zoom = ( widthzoom + heightzoom ) / 2;
+	if( zoom != m_zoom )
+	{
+		m_zoom = zoom;
+		emit zoomChanged( m_zoom );
+	}
+}
+
+void KImageCanvas::sizeFromZoom( double zoom )
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	if( ! m_image )
+		return;
+
+	QSize newsize = zoom * imageSize();
+	kdDebug( 4620 ) << "change size from " << imageSize() << " to " << newsize << endl;
+	resizeImage( newsize );
+}
+
+void KImageCanvas::updateImage()
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	if( ! m_bImageUpdateScheduled )
+		QTimer::singleShot( 0, this, SLOT( slotUpdateImage() ) );
+	m_bImageUpdateScheduled = true;
+}
+
+void KImageCanvas::slotUpdateImage()
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	m_bImageUpdateScheduled = false;
+	if( m_image == 0 )
+		return;
+
+	//only update if something was changed
+	if( m_bImageChanged || m_bSizeChanged || m_bMatrixChanged )
+	{
+		kdDebug( 4620 ) << "actually updating the image now" << endl;
+		QApplication::setOverrideCursor( WaitCursor );
+		if( m_bNewImage || ! m_client )
+		{
+			finishNewClient();
+			m_oldClient = m_client;
+			m_client = createNewClient();
+		}
+		m_client->setImage( pixmap() );
+
+		if( m_bSizeChanged || m_bNewImage )
+		{
+			QSize sh = m_client->sizeHint();
+			if( ! sh.isValid() )
+				sh = QSize( 0, 0 );
+			m_client->resize( sh );
+			resizeContents( sh.width(), sh.height() );
+			center();
+		}
+		QRect drawRect = m_client->drawRect();
+		switch( m_iBlendEffect )
+		{
+			case NoBlending:
+				break;
+			case AlphaBlend:
+				break;
+			case WipeFromLeft:
+				drawRect.setRight( KIMAGECANVAS_WIPESIZE + contentsX() );
+				m_client->setDrawRect( drawRect );
+				break;
+			case WipeFromRight:
+				drawRect.rLeft() += KMIN( drawRect.width() - KIMAGECANVAS_WIPESIZE, contentsX() + visibleWidth() );
+				m_client->setDrawRect( drawRect );
+				break;
+			case WipeFromTop:
+				drawRect.setBottom( KIMAGECANVAS_WIPESIZE + contentsY() );
+				m_client->setDrawRect( drawRect );
+				break;
+			case WipeFromBottom:
+				drawRect.setTop( KMIN( drawRect.height() - KIMAGECANVAS_WIPESIZE, contentsY() + visibleHeight() ) );
+				m_client->setDrawRect( drawRect );
+				break;
+		}
+		m_client->update();
+		m_iBlendTimerId = startTimer( 5 );
+		QApplication::restoreOverrideCursor();
+	}
+
+	m_bNewImage = false;
+	m_bImageChanged = false;
+	m_bSizeChanged = false;
+	m_bMatrixChanged = false;
+}
+
+void KImageCanvas::mouseMoveEvent( QMouseEvent * )
+{
+	if( m_cursor.shape() == Qt::BlankCursor )
+	{
+		m_cursor.setShape( Qt::CrossCursor );
+		viewport()->setCursor( m_cursor );
+		if( m_client )
+			m_client->setCursor( m_cursor );
+	}
+	m_pTimer->start( MOUSECURSORHIDETIME, true );
+}
+
+
+void KImageCanvas::resizeEvent( QResizeEvent * ev )
+{
+	kdDebug( 4620 ) << "KImageCanvas resized to " << ev->size() << endl;
+	QScrollView::resizeEvent( ev );
+	center();
+}
+
+void KImageCanvas::contentsMousePressEvent( QMouseEvent * ev )
+{
+	if ( ev->button() == RightButton )
+		emit contextPress( ev->globalPos() );
+	QScrollView::contentsMousePressEvent( ev );
+}
+
+void KImageCanvas::contentsWheelEvent( QWheelEvent * ev )
+{
+	//kdDebug( 4620 ) << k_funcinfo << endl;
+    // Ctrl+Wheelmouse changes the zoom.
+    // Wheelmouse scrolls around
+    if ( ev->state() & ControlButton )
+    {
+		int delta = ev->delta() / 120;
+		double zoom = m_zoom;
+		// make zoom a value of 1/16, 1/15, 1/14, .. , 1/2, 1, 2, 3, .. , 15, 16
+		bool done = false;
+		for( int i = 15; i > 0; --i )
+		{
+			if( zoom <= ( 1.0 / i ) )
+			{
+				if( zoom < ( 1.0 / ( i + 0.5 ) ) )
+					zoom = ( 1.0 / ( i + 1 ) );
+				else
+					zoom = ( 1.0 / i );
+				done = true;
+				// zoom = 1/16, 1/15, .. , 1/2, 1
+				double x = 1.0 / zoom - delta;
+				if( x == 0 )
+					zoom = 2.0;
+				else
+					zoom = 1.0 / x;
+				break;
+			}
+		}
+		if( ! done )
+			for( int i = 2; i < 17; ++i )
+			{
+				if( zoom < (double)i )
+				{
+					if( zoom < ( i - 0.5 ) )
+						zoom = i - 1.0;
+					else
+						zoom = (double)i;
+					done = true;
+					// zoom = 1, 2, .., 15, 16
+					zoom = zoom + delta;
+					if( zoom < 0.9 )
+						zoom = 0.5;
+					break;
+				}
+			}
+		if( ! done )
+		{
+			zoom = 16.0;
+			zoom = zoom + delta;
+			if( zoom > 16.0 )
+				zoom = 16.0;
+		}
+		kdDebug( 4620 ) << "Mousewheel: oldzoom = " << m_zoom << " newzoom = " << zoom << endl;
+		ev->accept();
+		bool oldscale = fastScale();
+		setFastScale( true );
+		setZoom( zoom );
+		setFastScale( oldscale );
+    }
+    else
+        QScrollView::contentsWheelEvent( ev );
+}
+
+void KImageCanvas::keyPressEvent( QKeyEvent * ev )
+{
+	//kdDebug( 4620 ) << k_funcinfo << endl;
+	switch( ev->key() )
+	{
+		case Key_Down:
+			ev->accept();
+			verticalScrollBar()->addLine();
+			break;
+		case Key_Up:
+			ev->accept();
+			verticalScrollBar()->subtractLine();
+			break;
+		case Key_Left:
+			ev->accept();
+			horizontalScrollBar()->subtractLine();
+			break;
+		case Key_Right:
+			ev->accept();
+			horizontalScrollBar()->addLine();
+			break;
+		case Key_PageUp:
+			ev->accept();
+			verticalScrollBar()->subtractPage();
+			break;
+		case Key_PageDown:
+			ev->accept();
+			verticalScrollBar()->addPage();
+			break;
+		default:
+			ev->ignore();
+			break;
+	}
+}
+
+void KImageCanvas::timerEvent( QTimerEvent * ev )
+{
+	if( ev->timerId() == m_iBlendTimerId )
+	{
+		QRect drawRect = m_client->drawRect();
+		switch( m_iBlendEffect )
+		{
+			case NoBlending:
+				finishNewClient();
+				break;
+			case AlphaBlend:
+				finishNewClient();
+				//if( qt_use_xrender )
+				//{
+				//}
+				//else
+				//{
+					//kdWarning( 4620 ) << "no XRender" << endl;
+					//finishNewClient();
+				//}
+				break;
+			case WipeFromLeft:
+				drawRect.rRight() += KIMAGECANVAS_WIPESIZE;
+				m_client->setDrawRect( drawRect );
+				m_client->update( drawRect.right() - KIMAGECANVAS_WIPESIZE, 0, KIMAGECANVAS_WIPESIZE, m_client->height() );
+				if( drawRect.right() >= contentsX() + visibleWidth() )
+					finishNewClient();
+				break;
+			case WipeFromRight:
+				drawRect.rLeft() -= KIMAGECANVAS_WIPESIZE;
+				m_client->setDrawRect( drawRect );
+				m_client->update( drawRect.left(), 0, KIMAGECANVAS_WIPESIZE, m_client->height() );
+				if( drawRect.left() <= contentsX() )
+					finishNewClient();
+				break;
+			case WipeFromTop:
+				drawRect.rBottom() += KIMAGECANVAS_WIPESIZE;
+				m_client->setDrawRect( drawRect );
+				m_client->update( 0, drawRect.bottom() - KIMAGECANVAS_WIPESIZE, m_client->width(), KIMAGECANVAS_WIPESIZE );
+				if( drawRect.bottom() >= contentsY() + visibleHeight() )
+					finishNewClient();
+				break;
+			case WipeFromBottom:
+				drawRect.rTop() -= KIMAGECANVAS_WIPESIZE;
+				m_client->setDrawRect( drawRect );
+				m_client->update( 0, drawRect.top(), m_client->width(), KIMAGECANVAS_WIPESIZE );
+				if( drawRect.top() <= contentsY() )
+					finishNewClient();
+				break;
+			default:
+				kdFatal( 4620 ) << "unknown Blend Effect" << endl;
+				break;
+		}
+	}
+	else
+		killTimer( ev->timerId() );
+}
+
+void KImageCanvas::hideCursor()
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	m_cursor.setShape( Qt::BlankCursor );
+	viewport()->setCursor( m_cursor );
+	if( m_client )
+		m_client->setCursor( m_cursor );
+}
+
+const KPixmap KImageCanvas::pixmap()
+{
+	kdDebug( 4620 ) << k_funcinfo << ( m_bNeedNewPixmap ? "convert from Image" : "use old copy" ) << endl;
+	// create a new Pixmap in m_pixmap if needed
+	if( m_bNeedNewPixmap )
+	{
+		// only do it again if requested
+		m_bNeedNewPixmap = false;
+		// ok, the old one may go now
+		delete m_pixmap;
+
+		// if smoothscaling is wanted and the transformation matrix or the image
+		// itself changed...
+		if( ! m_fastscale && ( m_bMatrixChanged || m_bImageChanged ) )
+		{
+			delete m_imageTransformed;
+			// we create a new image transformed by the matrix
+			m_imageTransformed = new QImage( m_matrix.isIdentity() ? *m_image : m_image->xForm( m_matrix ) );
+			kdDebug( 4620 ) << "Size of m_image: " << m_image->size() << endl;
+			kdDebug( 4620 ) << "Size of m_imageTransformed: " << m_imageTransformed->size() << endl;
+		}
+		// smoothScale or fast scaling via m_matrix
+		m_pixmap = new KPixmap();
+		m_pixmap->convertFromImage( m_fastscale ? *m_image : m_imageTransformed->smoothScale( m_currentsize ), KPixmap::ColorOnly );
+	}
+	if( m_fastscale )
+	{
+		// fast scaling is needed so we need to scale now
+		QWMatrix matrix( m_matrix );
+		matrix.scale( m_zoom, m_zoom );
+		if( ! matrix.isIdentity() )
+			return m_pixmap->xForm( matrix );
+	}
+	return *m_pixmap;
+}
+
+void KImageCanvas::slotImageChanged()
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	m_bImageChanged = true;
+	m_bNeedNewPixmap = true;
+}
+
+void KImageCanvas::loadSettings()
+{
+	KConfigGroup cfgGroup( KImageCanvasFactory::instance()->config(),
+			"Settings" );
+	setFastScale( ! cfgGroup.readBoolEntry( "Smooth Scaling", ! fastScale() ) );
+	setKeepAspectRatio( cfgGroup.readBoolEntry( "Keep Aspect Ratio",
+				keepAspectRatio() ) );
+	setCentered( cfgGroup.readBoolEntry( "Center Image", centered() ) );
+
+	setBgColor( cfgGroup.readColorEntry( "Background Color", &bgColor() ) );
+
+	setMinimumImageSize( QSize( cfgGroup.readNumEntry( "Minimum Width",
+					minimumImageSize().width() ), cfgGroup.readNumEntry(
+					"Minimum Height", minimumImageSize().height() ) ) );
+	setMaximumImageSize( QSize( cfgGroup.readNumEntry( "Maximum Width",
+					maximumImageSize().width() ), cfgGroup.readNumEntry(
+					"Maximum Height", maximumImageSize().height() ) ) );
+
+	KConfigGroup blendConfig( KImageCanvasFactory::instance()->config(),
+			"Blend Effects" );
+	/* TODO
+	m_vEffects.clear();
+	for( unsigned int i = 1; i <= numOfBlendEffects(); ++i )
+	{
+		if( blendConfig.readBoolEntry( QString::number( i ), false ) )
+			m_vEffects.push_back( i );
+	}
+	// and now tell the canvas what blend effect to use
+	switchBlendEffect();
+	*/
+}
+
+void KImageCanvas::selected( const QRect & rect )
+{
+	//kdDebug( 4620 ) << k_funcinfo << rect << endl;
+	m_selection = rect;
+	if( ! m_selection.isNull() )
+	{
+		m_selection.setTop( int( ( m_selection.top() + 0.5 ) / m_zoom ) );
+		m_selection.setLeft( int( ( m_selection.left() + 0.5 ) / m_zoom ) );
+		m_selection.setRight( int( ( m_selection.right() + 0.5 ) / m_zoom ) );
+		m_selection.setBottom( int( ( m_selection.bottom() + 0.5 ) / m_zoom ) );
+	}
+	//kdDebug( 4620 ) << "m_selection = " << m_selection << endl;
+	emit selectionChanged( m_selection );
+}
+
+void KImageCanvas::mapCursorPos( const QPoint & pos )
+{
+	QPoint mapped( static_cast<int>( ( pos.x() + 0.5 ) / m_zoom ), static_cast<int>( ( pos.y() + 0.5 ) / m_zoom ) );
+	//kdDebug( 4620 ) << k_funcinfo << pos << " -> " << mapped << endl;
+	emit cursorPos( mapped );
+}
+
+void KImageCanvas::sizeChanged()
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	m_bSizeChanged = true;
+	if( ! m_fastscale )
+		m_bNeedNewPixmap = true;
+	emit imageSizeChanged( m_currentsize );
+}
+
+void KImageCanvas::matrixChanged()
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	m_bMatrixChanged = true;
+	m_bNeedNewPixmap = true;
+}
+
+void KImageCanvas::center()
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	if( m_bCentered && m_client )
+	{
+		int x = 0;
+		int y = 0;
+
+		int scrollbarwidth = ( height() >= m_currentsize.height() ) ? 0 : verticalScrollBar()->width();
+		int scrollbarheight = ( width() - scrollbarwidth >= m_currentsize.width() ) ? 0 : horizontalScrollBar()->height();
+		scrollbarwidth = ( height() - scrollbarheight >= m_currentsize.height() ) ? 0 : verticalScrollBar()->width();
+
+		int availheight = height() - scrollbarheight;
+		int availwidth = width() - scrollbarwidth;
+
+		if( availwidth > m_currentsize.width() )
+			x = ( availwidth - m_currentsize.width() ) / 2;
+		if( availheight > m_currentsize.height() )
+			y = ( availheight - m_currentsize.height() ) / 2;
+
+		kdDebug( 4620 ) << "center with left top at " << x << ", " << y << endl;
+		moveChild( m_client, x, y );
+	}
+}
+
+void KImageCanvas::finishNewClient()
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	killTimer( m_iBlendTimerId );
+	if( m_client )
+		m_client->setDrawRect( m_client->rect() );
+	delete m_oldClient;
+	m_oldClient = 0;
+	emit showingImageDone();
+}
+
+KImageHolder * KImageCanvas::createNewClient()
+{
+	kdDebug( 4620 ) << k_funcinfo << endl;
+	KImageHolder * client = new KImageHolder( viewport() );
+	client->setMinimumSize( 0, 0 );
+	client->setMouseTracking( true );
+	client->installEventFilter( this );
+	setFocusProxy( client );
+	client->setFocusPolicy( QWidget::StrongFocus );
+	client->setFocus();
+
+	addChild( client, 0, 0 );
+
+	connect( client, SIGNAL( contextPress( const QPoint& ) ), SIGNAL( contextPress( const QPoint& ) ) );
+	connect( client, SIGNAL( cursorPos( const QPoint & ) ), SLOT( mapCursorPos( const QPoint & ) ) );
+	connect( client, SIGNAL( selected( const QRect & ) ), SLOT( selected( const QRect & ) ) );
+	connect( client, SIGNAL( wannaScroll( int, int ) ), SLOT( scrollBy( int, int ) ) );
+
+	return client;
+}
+
+#include "kimagecanvas.moc"
+
+// vim:sw=4:ts=4