path: root/plugin/tdeqt4painter.cpp

/****************************************************************************
**
** Implementation of TDEQt4PaintDevice class
**
** Copyright (C) 2012 Timothy Pearson.  All rights reserved.
**
** This file is part of the TDE Qt4 style interface
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
** Software Foundation and appearing in the files LICENSE.GPL2
** and LICENSE.GPL3 included in the packaging of this file.
**
** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
** herein.
**
**********************************************************************/

#include "tdeqt4painter.h"

#define TQT_NO_COMPAT_NAMES
#include "tqpainter.h"
#include "tqpixmap.h"
#include "tqbitmap.h"
#include "tqimage.h"
#include "tqfile.h"
#include "tqpaintdevicemetrics.h"
#undef Qt

/*!
    \class TDEQt4PaintDevice ntqpicture.h
    \brief The TDEQt4PaintDevice class is a paint device that records and
    replays TQPainter commands.

    \ingroup graphics
    \ingroup images
    \ingroup shared

    A picture serializes painter commands to an IO device in a
    platform-independent format. For example, a picture created under
    Windows can be read on a Sun SPARC.

    Pictures are called meta-files on some platforms.

    TQt pictures use a proprietary binary format. Unlike native picture
    (meta-file) formats on many window systems, TQt pictures have no
    limitations regarding their contents. Everything that can be
    painted can also be stored in a picture, e.g. fonts, pixmaps,
    regions, transformed graphics, etc.

    TDEQt4PaintDevice is an \link shclass.html implicitly shared\endlink class.

    Example of how to record a picture:
    \code
    TDEQt4PaintDevice  pic;
    TQPainter  p;
    p.begin( &pic );               // paint in picture
    p.drawEllipse( 10,20, 80,70 ); // draw an ellipse
    p.end();                       // painting done
    pic.save( "drawing.pic" );     // save picture
    \endcode

    Example of how to replay a picture:
    \code
    TDEQt4PaintDevice  pic;
    pic.load( "drawing.pic" );     // load picture
    TQPainter  p;
    p.begin( &myWidget );          // paint in myWidget
    p.drawPicture( pic );          // draw the picture
    p.end();                       // painting done
    \endcode

    Pictures can also be drawn using play(). Some basic data about a
    picture is available, for example, size(), isNull() and
    boundingRect().

*/


/*!
    Constructs an empty picture.

    The \a formatVersion parameter may be used to \e create a TDEQt4PaintDevice
    that can be read by applications that are compiled with earlier
    versions of TQt.
    \list
    \i \a formatVersion == 1 is binary compatible with TQt 1.x and later.
    \i \a formatVersion == 2 is binary compatible with TQt 2.0.x and later.
    \i \a formatVersion == 3 is binary compatible with TQt 2.1.x and later.
    \i \a formatVersion == 4 is binary compatible with TQt 3.0.x and later.
    \i \a formatVersion == 5 is binary compatible with TQt 3.1.
    \endlist

    Note that the default formatVersion is -1 which signifies the
    current release, i.e. for TQt 3.1 a formatVersion of 5 is the same
    as the default formatVersion of -1.

    Reading pictures generated by earlier versions of TQt is supported
    and needs no special coding; the format is automatically detected.
*/

TDEQt4PaintDevice::TDEQt4PaintDevice( QPainter *qt4painter )
    : TQPaintDevice( TQInternal::Picture | TQInternal::ExternalDevice )
{
	m_qt4painter = qt4painter;
}

/*!
    Destroys the picture.
*/
TDEQt4PaintDevice::~TDEQt4PaintDevice()
{
}

/*!
  \internal
  Implementation of the function forwarded above to the internal data struct.
*/

bool TDEQt4PaintDevice::cmd( int c, TQPainter *pt, TQPDevCmdParam *p )
{
	Q_UNUSED(pt);

	unsigned int i;
	int x;
	int y;
	QPen qt4pen;
	QRect qt4rect;
	QBrush qt4brush;
	QPoint qt4point1;
	QPoint qt4point2;
	QPolygon qt4polygon;
	QFont qt4font;
	QPixmap qt4pixmap;
	QString qt4string;
	QMatrix qt4matrix;
	QRegion qt4region;
	Qt::BGMode qt4bkmode = Qt::TransparentMode;
	QPainter::CompositionMode qt4compositionmode = QPainter::CompositionMode_SourceOver;
	int qt4formattedtextflags = 0;

	if (p) {
		if (c == PdcSetClipRegion) {
			// FIXME
			// Ellipses are not being handle correctly AT ALL
			// Look at the Lipstik progress bar for an example of this...
#if 0
			// IMPRECISE
			const TQMemArray<TQRect> rects = p[0].rgn->rects();
			for ( uint i = 0; i < rects.count(); i++ ) {
				TQRect r = rects[(int)i];
				qt4region = qt4region.united(QRegion(QRect(r.x(), r.y(), r.width(), r.height())));
			}
#else
			// SLOW
			TQRect tqt3br = p[0].rgn->boundingRect();
			TQBitmap regionMask(tqt3br.x()+tqt3br.width(), tqt3br.y()+tqt3br.height());
			regionMask.fill(TQt::color0);
			TQPainter tqt3brpainter(&regionMask);
			tqt3brpainter.setClipRegion(*p[0].rgn);
			tqt3brpainter.fillRect(0,0,regionMask.width(),regionMask.height(),TQt::color1);
			tqt3brpainter.end();
			QBitmap qt4RegionMask = QPixmap::fromX11Pixmap(regionMask.handle(), QPixmap::ImplicitlyShared);
			qt4region = QRegion(qt4RegionMask);
#endif
			TQPainter::CoordinateMode tqt3coordmode = (TQPainter::CoordinateMode)p[1].ival;
			if ( tqt3coordmode == TQPainter::CoordDevice ) {
				qt4region = qt4region;
			}
			else {
				qt4region = m_qt4painter->transform().map(qt4region);
			}
		}
		if (c == PdcSetWMatrix) {
			const TQWMatrix* tqt3matrix = p[0].matrix;
			qt4matrix = QMatrix(tqt3matrix->m11(), tqt3matrix->m12(), tqt3matrix->m21(), tqt3matrix->m22(), tqt3matrix->dx(), tqt3matrix->dy());
		}
		if (c == PdcSetROP) {
			TQt::RasterOp rop = (TQt::RasterOp)p[0].ival;
			switch (rop) {
				case TQPainter::CopyROP:
					qt4compositionmode=QPainter::CompositionMode_SourceOver;
					break;
				case TQPainter::OrROP:
					qt4compositionmode=QPainter::RasterOp_SourceOrDestination;
					break;
				case TQPainter::XorROP:
					qt4compositionmode=QPainter::RasterOp_SourceXorDestination;
					break;
				case TQPainter::NotAndROP:
					qt4compositionmode=QPainter::RasterOp_NotSourceAndDestination;
					break;
// 				case TQPainter::EraseROP:
// 					qt4compositionmode=QPainter::RasterOp_NotSourceAndDestination;
// 					break;
				case TQPainter::NotCopyROP:
					qt4compositionmode=QPainter::RasterOp_NotSource;
					break;
				case TQPainter::NotOrROP:
					tqWarning("TDEQt4PaintDevice::cmd: Unhandled raster operation [Was attempting to use raster operation %d\n\r", rop);
					break;
				case TQPainter::NotXorROP:
					qt4compositionmode=QPainter::RasterOp_NotSourceXorDestination;
					break;
				case TQPainter::AndROP:
					qt4compositionmode=QPainter::RasterOp_SourceAndDestination;
					break;
// 				case TQPainter::NotEraseROP:
// 					qt4compositionmode=QPainter::RasterOp_SourceAndDestination;
// 					break;
				case TQPainter::NotROP:
					qt4compositionmode=QPainter::RasterOp_SourceAndNotDestination;          // [WARNING] This may not be a correct substitute for NotROP!
					break;
				case TQPainter::ClearROP:
					qt4compositionmode=QPainter::CompositionMode_Clear;
					break;
				case TQPainter::SetROP:
					tqWarning("TDEQt4PaintDevice::cmd: Unhandled raster operation [Was attempting to use raster operation %d\n\r", rop);
					break;
				case TQPainter::NopROP:
					qt4compositionmode=QPainter::CompositionMode_Destination;
					break;
				case TQPainter::AndNotROP:
					qt4compositionmode=QPainter::RasterOp_SourceAndNotDestination;
					break;
				case TQPainter::OrNotROP:
					tqWarning("TDEQt4PaintDevice::cmd: Unhandled raster operation [Was attempting to use raster operation %d\n\r", rop);
					break;
				case TQPainter::NandROP:
					qt4compositionmode=QPainter::RasterOp_NotSourceOrNotDestination;
					break;
				case TQPainter::NorROP:
					qt4compositionmode=QPainter::RasterOp_NotSourceAndNotDestination;
					break;
				default:
					qt4compositionmode=QPainter::CompositionMode_SourceOver;
#if defined(QT_CHECK_RANGE)
					tqWarning( "TDEQt4PaintDevice::cmd: Unhandled raster operation %d", rop );
#endif
			}
		}
		if (( c== PdcDrawTextFormatted) || (c == PdcDrawText2Formatted)) {
			qt4rect = QRect(p[0].rect->x(), p[0].rect->y(), p[0].rect->width(), p[0].rect->height());
			qt4formattedtextflags = 0;
// 			if (p[1].ival & TQt::AlignAuto) {
// 				qt4formattedtextflags = qt4formattedtextflags | Qt::AlignAuto;
// 			}
			if ((p[1].ival & TQt::AlignLeft) == TQt::AlignLeft) {
				qt4formattedtextflags = qt4formattedtextflags | Qt::AlignLeft;
			}
			if ((p[1].ival & TQt::AlignRight) == TQt::AlignRight) {
				qt4formattedtextflags = qt4formattedtextflags | Qt::AlignRight;
			}
			if ((p[1].ival & TQt::AlignHCenter) == TQt::AlignHCenter) {
				qt4formattedtextflags = qt4formattedtextflags | Qt::AlignHCenter;
			}
			if ((p[1].ival & TQt::AlignJustify) == TQt::AlignJustify) {
				qt4formattedtextflags = qt4formattedtextflags | Qt::AlignJustify;
			}
			if ((p[1].ival & TQt::AlignTop) == TQt::AlignTop) {
				qt4formattedtextflags = qt4formattedtextflags | Qt::AlignTop;
			}
			if ((p[1].ival & TQt::AlignBottom) == TQt::AlignBottom) {
				qt4formattedtextflags = qt4formattedtextflags | Qt::AlignBottom;
			}
			if ((p[1].ival & TQt::AlignVCenter) == TQt::AlignVCenter) {
				qt4formattedtextflags = qt4formattedtextflags | Qt::AlignVCenter;
			}
			if ((p[1].ival & TQt::AlignCenter) == TQt::AlignCenter) {
				qt4formattedtextflags = qt4formattedtextflags | Qt::AlignCenter;
			}
			if ((p[1].ival & TQt::SingleLine) == TQt::SingleLine) {
				qt4formattedtextflags = qt4formattedtextflags | Qt::TextSingleLine;
			}
			if ((p[1].ival & TQt::DontClip) == TQt::DontClip) {
				qt4formattedtextflags = qt4formattedtextflags | Qt::TextDontClip;
			}
			if ((p[1].ival & TQt::ExpandTabs) == TQt::ExpandTabs) {
				qt4formattedtextflags = qt4formattedtextflags | Qt::TextExpandTabs;
			}
			if ((p[1].ival & TQt::ShowPrefix) == TQt::ShowPrefix) {
				qt4formattedtextflags = qt4formattedtextflags | Qt::TextShowMnemonic;
			}
			if ((p[1].ival & TQt::WordBreak) == TQt::WordBreak) {
				qt4formattedtextflags = qt4formattedtextflags | Qt::TextWordWrap;
			}
			if ((p[1].ival & TQt::BreakAnywhere) == TQt::BreakAnywhere) {
				qt4formattedtextflags = qt4formattedtextflags | Qt::TextWrapAnywhere;
			}
			if ((p[1].ival & TQt::NoAccel) == TQt::NoAccel) {
				qt4formattedtextflags = qt4formattedtextflags | Qt::TextHideMnemonic;
			}
			qt4string = QString::fromUtf8(p[2].str->utf8().data());
		}
		if ((c == PdcDrawPoint) || (c == PdcMoveTo) || (c == PdcLineTo) || (c == PdcSetBrushOrigin)) {
			qt4point1 = QPoint(p[0].point->x(), p[0].point->y());
		}
		if (c == PdcDrawLine) {
			qt4point1 = QPoint(p[0].point->x(), p[0].point->y());
			qt4point2 = QPoint(p[1].point->x(), p[1].point->y());
		}
		if ((c == PdcDrawPolyline) || (c == PdcDrawPolygon) || (c == PdcDrawLineSegments) || (c == PdcDrawCubicBezier)) {
			TQPointArray qt3parray = *p[0].ptarr;
			qt4polygon.resize(qt3parray.count());
			for (i=0;i<qt3parray.count();i++) {
				qt3parray.point(i, &x, &y );
				qt4polygon.setPoint(i, x, y);
			}
		}
		if ((c == PdcDrawRect) || (c == PdcDrawRoundRect) || (c == PdcDrawEllipse) || (c == PdcDrawArc) || (c == PdcDrawPie) || (c == PdcDrawChord)) {
			qt4rect = QRect(p[0].rect->x(), p[0].rect->y(), p[0].rect->width(), p[0].rect->height());
		}
		if (c == PdcSetBrush) {
			TQt::BrushStyle tqt3brushstyle = p[0].brush->style();
			Qt::BrushStyle qt4brushstyle;
			switch ( tqt3brushstyle ) {
				case TQt::NoBrush:
					qt4brushstyle = Qt::NoBrush;
					break;
				case TQt::SolidPattern:
					qt4brushstyle = Qt::SolidPattern;
					break;
				case TQt::Dense1Pattern:
					qt4brushstyle = Qt::Dense1Pattern;
					break;
				case TQt::Dense2Pattern:
					qt4brushstyle = Qt::Dense2Pattern;
					break;
				case TQt::Dense3Pattern:
					qt4brushstyle = Qt::Dense3Pattern;
					break;
				case TQt::Dense4Pattern:
					qt4brushstyle = Qt::Dense4Pattern;
					break;
				case TQt::Dense5Pattern:
					qt4brushstyle = Qt::Dense5Pattern;
					break;
				case TQt::Dense6Pattern:
					qt4brushstyle = Qt::Dense6Pattern;
					break;
				case TQt::Dense7Pattern:
					qt4brushstyle = Qt::Dense7Pattern;
					break;
				case TQt::HorPattern:
					qt4brushstyle = Qt::HorPattern;
					break;
				case TQt::VerPattern:
					qt4brushstyle = Qt::VerPattern;
					break;
				case TQt::CrossPattern:
					qt4brushstyle = Qt::CrossPattern;
					break;
				case TQt::BDiagPattern:
					qt4brushstyle = Qt::BDiagPattern;
					break;
				case TQt::FDiagPattern:
					qt4brushstyle = Qt::FDiagPattern;
					break;
				case TQt::DiagCrossPattern:
					qt4brushstyle = Qt::DiagCrossPattern;
					break;
				case TQt::CustomPattern:
					qt4brushstyle = Qt::TexturePattern;
					break;
				default:
					qt4brushstyle = Qt::NoBrush;
#if defined(QT_CHECK_RANGE)
					tqWarning( "TDEQt4PaintDevice::cmd: Invalid brush style %d", tqt3brushstyle );
#endif
			}
			qt4brush.setStyle(qt4brushstyle);
			TQColor qt3color = p[0].brush->color();
			qt4brush.setColor(QColor(qt3color.red(), qt3color.green(), qt3color.blue(), 255));
			if (qt4brushstyle == Qt::TexturePattern) {
				TQPixmap tqtPM = *p[0].brush->pixmap();
				QPixmap qtPM = QPixmap::fromX11Pixmap(tqtPM.handle(), QPixmap::ImplicitlyShared);
				qt4brush.setTexture(qtPM);
			}
		}
		if (c == PdcSetPen) {
			bool customPenStyle = false;
			TQt::PenStyle tqt3penstyle = p[0].pen->style();
			Qt::PenStyle qt4penstyle;
			QVector<qreal> dashes;
			qreal mark;
			qreal space;
			switch ( tqt3penstyle ) {
				case TQt::NoPen:
					qt4penstyle = Qt::NoPen;
					break;
				case TQt::SolidLine:
					qt4penstyle = Qt::SolidLine;
					break;
				case TQt::DashLine:
					qt4penstyle = Qt::DashLine;
					break;
				case TQt::DotLine:
					qt4penstyle = Qt::DotLine;
					break;
				case TQt::DashDotLine:
					qt4penstyle = Qt::DashDotLine;
					break;
				case TQt::DashDotDotLine:
					qt4penstyle = Qt::DashDotDotLine;
					break;
				case TQt::FineDotLine:
					customPenStyle = true;
					mark = 1;
					space = 1;
					dashes << mark << space;
					qt4pen.setDashPattern(dashes);
					break;
				case TQt::MPenStyle:
					qt4penstyle = Qt::MPenStyle;
					break;
				default:
					qt4penstyle = Qt::NoPen;
#if defined(QT_CHECK_RANGE)
					tqWarning( "TDEQt4PaintDevice::cmd: Invalid pen style %d", tqt3penstyle );
#endif
			}
			if (customPenStyle == false) {
				qt4pen.setStyle(qt4penstyle);
			}
			TQt::PenCapStyle tqt3pencapstyle = p[0].pen->capStyle();
			Qt::PenCapStyle qt4pencapstyle;
			switch ( tqt3pencapstyle ) {
				case TQt::FlatCap:
					qt4pencapstyle = Qt::FlatCap;
					break;
				case TQt::SquareCap:
					qt4pencapstyle = Qt::SquareCap;
					break;
				case TQt::RoundCap:
					qt4pencapstyle = Qt::RoundCap;
					break;
				case TQt::MPenCapStyle:
					qt4pencapstyle = Qt::MPenCapStyle;
				default:
					qt4pencapstyle = Qt::FlatCap;
#if defined(QT_CHECK_RANGE)
					tqWarning( "TDEQt4PaintDevice::cmd: Invalid pen cap style %d", tqt3pencapstyle );
#endif
			}
			qt4pen.setCapStyle(qt4pencapstyle);
			TQt::PenJoinStyle tqt3penjoinstyle = p[0].pen->joinStyle();
			Qt::PenJoinStyle qt4penjoinstyle;
			switch ( tqt3penjoinstyle ) {
				case TQt::MiterJoin:
					qt4penjoinstyle = Qt::MiterJoin;
					break;
				case TQt::BevelJoin:
					qt4penjoinstyle = Qt::BevelJoin;
					break;
				case TQt::RoundJoin:
					qt4penjoinstyle = Qt::RoundJoin;
					break;
				case TQt::MPenJoinStyle:
					qt4penjoinstyle = Qt::MPenJoinStyle;
				default:
					qt4penjoinstyle = Qt::MiterJoin;
#if defined(QT_CHECK_RANGE)
					tqWarning( "TDEQt4PaintDevice::cmd: Invalid pen join style %d", tqt3penjoinstyle );
#endif
			}
			qt4pen.setJoinStyle(qt4penjoinstyle);
			TQColor qt3color = p[0].pen->color();
			qt4pen.setColor(QColor(qt3color.red(), qt3color.green(), qt3color.blue(), 255));
			qt4pen.setWidth(p[0].pen->width());
		}
		if (c == PdcSetBkMode) {
			TQt::BGMode qt3bkmode = (TQt::BGMode)p[0].ival;
			switch ( qt3bkmode ) {
				case TQt::TransparentMode:
					qt4bkmode = Qt::TransparentMode;
					break;
				case TQt::OpaqueMode:
					qt4bkmode = Qt::OpaqueMode;
					break;
				default:
					qt4bkmode = Qt::TransparentMode;
#if defined(QT_CHECK_RANGE)
					tqWarning( "TDEQt4PaintDevice::cmd: Invalid background mode %d", qt3bkmode );
#endif
			}
		}
		if (c == PdcSetFont) {
			// FIXME
			printf("[WARNING] QFont conversion is NOT COMPLETE\n\r"); fflush(stdout);

			TQFont qt3font = *p[0].font;
			qt4font = QFont(QString::fromUtf8(qt3font.family().utf8().data()), qt3font.pointSize(), qt3font.weight(), qt3font.italic());
		}
		if (c == PdcDrawPixmap) {
			qt4rect = QRect(p[0].rect->x(), p[0].rect->y(), p[0].rect->width(), p[0].rect->height());
			TQPixmap qt3pixmap = *p[1].pixmap;
			qt4pixmap = QPixmap::fromX11Pixmap(qt3pixmap.handle(), QPixmap::ImplicitlyShared);
		}
		if (c == PdcDrawText2) {
			qt4point1 = QPoint(p[0].point->x(), p[0].point->y());
			qt4string = QString::fromUtf8(p[1].str->utf8().data());
		}
	}

	int index;
	int count;
	int lineCount;
	QPainterPath path;

	switch ( c ) {				// exec cmd
	    case PdcNOP:
		break;
	    case PdcDrawPoint:
		m_qt4painter->drawPoint( qt4point1 );
		break;
	    case PdcMoveTo:
		curPt = qt4point1;
		break;
	    case PdcLineTo:
		prevPt = curPt;
		curPt = qt4point1;
		m_qt4painter->drawLine( prevPt, curPt );
		break;
	    case PdcDrawLine:
		m_qt4painter->drawLine( qt4point1, qt4point2 );
		break;
	    case PdcDrawRect:
		m_qt4painter->drawRect( qt4rect );
		break;
	    case PdcDrawRoundRect:
		m_qt4painter->drawRoundedRect( qt4rect, p[1].ival, p[2].ival );
		break;
	    case PdcDrawEllipse:
		m_qt4painter->drawEllipse( qt4rect );
		break;
	    case PdcDrawArc:
		m_qt4painter->drawArc( qt4rect, p[1].ival, p[2].ival );
		break;
	    case PdcDrawPie:
		m_qt4painter->drawPie( qt4rect, p[1].ival, p[2].ival );
		break;
	    case PdcDrawChord:
		m_qt4painter->drawChord( qt4rect, p[1].ival, p[2].ival );
		break;
	    case PdcDrawLineSegments:
		index = 0;
		count = -1;
		lineCount = (count == -1) ? (qt4polygon.size() - index) / 2  : count;
		m_qt4painter->drawLines(qt4polygon.constData() + index * 2, lineCount);
		break;
	    case PdcDrawPolyline:
		m_qt4painter->drawPolyline( qt4polygon );
		break;
	    case PdcDrawPolygon:
		m_qt4painter->drawPolygon( qt4polygon, (p[1].ival == 0)?Qt::OddEvenFill:Qt::WindingFill );
		break;
	    case PdcDrawCubicBezier:
		index = 0;
		path.moveTo(qt4polygon.at(index));
		path.cubicTo(qt4polygon.at(index+1), qt4polygon.at(index+2), qt4polygon.at(index+3));
		m_qt4painter->strokePath(path, m_qt4painter->pen());
		break;
	    case PdcDrawText:
		m_qt4painter->drawText( qt4point1, qt4string );
		break;
	    case PdcDrawTextFormatted:
		m_qt4painter->drawText( qt4rect, qt4formattedtextflags, qt4string );
		break;
	    case PdcDrawText2:
		m_qt4painter->drawText( qt4point1, qt4string );
		break;
	    case PdcDrawText2Formatted:
		m_qt4painter->drawText( qt4rect, qt4formattedtextflags, qt4string );
		break;
	    case PdcDrawPixmap:
		m_qt4painter->drawPixmap( qt4rect, qt4pixmap );
		break;
#if 0
	    case PdcDrawImage: {
		TQImage image;
		if ( d->formatMajor < 4 ) {
		    s >> p >> image;
		    painter->drawImage( p, image );
		} else {
		    s >> r >> image;
		    painter->drawImage( r, image );
		}
		}
		break;
#endif
	    case PdcBegin:
		if (m_qt4painter->isActive()) {
			// KEEP THIS DEACTIVATED
// 			QPaintDevice* pd = m_qt4painter->device();
// 			m_qt4painter->end();
// 			m_qt4painter->begin(pd);
		}
#if defined(QT_CHECK_RANGE)
		else {
			tqWarning( "TDEQt4PaintDevice::cmd: Painter has no paint device available" );
		}
#endif
		break;
	    case PdcEnd:
		// KEEP THIS DEACTIVATED
// 		m_qt4painter->end();
		break;
	    case PdcSave:
		m_qt4painter->save();
		break;
	    case PdcRestore:
		m_qt4painter->restore();
		break;
	    case PdcSetBkColor:
		m_qt4painter->setBackground( QBrush(QColor(p[0].color->red(), p[0].color->green(), p[0].color->blue())) );
		break;
	    case PdcSetBkMode:
		m_qt4painter->setBackgroundMode( qt4bkmode );
		break;
	    case PdcSetROP:
		m_qt4painter->setCompositionMode(qt4compositionmode);
		break;
	    case PdcSetBrushOrigin:
		m_qt4painter->setBrushOrigin( qt4point1 );
		break;
	    case PdcSetFont:
		m_qt4painter->setFont( qt4font );
		break;
	    case PdcSetPen:
		m_qt4painter->setPen( qt4pen );
		break;
	    case PdcSetBrush:
		m_qt4painter->setBrush( qt4brush );
		break;
#if 0
	    case PdcSetTabStops:
		s >> i_16;
		painter->setTabStops( i_16 );
		break;
	    case PdcSetTabArray:
		s >> i_16;
		if ( i_16 == 0 ) {
		    painter->setTabArray( 0 );
		} else {
		    int *ta = new int[i_16];
		    TQ_CHECK_PTR( ta );
		    for ( int i=0; i<i_16; i++ ) {
			s >> i1_16;
			ta[i] = i1_16;
		    }
		    painter->setTabArray( ta );
		    delete [] ta;
		}
		break;
	    case PdcSetVXform:
		s >> i_8;
#ifndef QT_NO_TRANSFORMATIONS
		painter->setViewXForm( i_8 );
#endif
		break;
	    case PdcSetWindow:
		s >> r;
#ifndef QT_NO_TRANSFORMATIONS
		painter->setWindow( r );
#endif
		break;
	    case PdcSetViewport:
		s >> r;
#ifndef QT_NO_TRANSFORMATIONS
		painter->setViewport( r );
#endif
		break;
#endif
	    case PdcSetWXform:
		m_qt4painter->setWorldMatrixEnabled( p[0].ival );
		break;
	    case PdcSetWMatrix:
		m_qt4painter->setWorldMatrix( qt4matrix, p[1].ival );
		break;
#if 0
#ifndef QT_NO_TRANSFORMATIONS
	    case PdcSaveWMatrix:
		painter->saveWorldMatrix();
		break;
	    case PdcRestoreWMatrix:
		painter->restoreWorldMatrix();
		break;
#endif
#endif
	    case PdcSetClip:
		m_qt4painter->setClipping( p[0].ival );
		break;
	    case PdcSetClipRegion:
		m_qt4painter->setClipRegion( qt4region, Qt::ReplaceClip );
		break;
	    default:
#if defined(QT_CHECK_RANGE)
		tqWarning( "TDEQt4PaintDevice::cmd: Invalid command %d", c );
#endif
	}

	return TRUE;
}


/*!
    Internal implementation of the virtual TQPaintDevice::metric()
    function.

    Use the TQPaintDeviceMetrics class instead.

    A picture has the following hard-coded values: dpi=72,
    numcolors=16777216 and depth=24.

    \a m is the metric to get.
*/

int TDEQt4PaintDevice::metric( int m ) const
{
	int val;
	QPaintDevice* qt4pd = m_qt4painter->device();
	if (qt4pd) {
		switch ( m ) {
			// ### hard coded dpi and color depth values !
			case TQPaintDeviceMetrics::PdmWidth:
				val = qt4pd->width();
				break;
			case TQPaintDeviceMetrics::PdmHeight:
				val = qt4pd->height();
				break;
			case TQPaintDeviceMetrics::PdmWidthMM:
				val = qt4pd->widthMM();
				break;
			case TQPaintDeviceMetrics::PdmHeightMM:
				val = qt4pd->heightMM();
				break;
			case TQPaintDeviceMetrics::PdmDpiX:
				val = qt4pd->logicalDpiX();
				break;
			case TQPaintDeviceMetrics::PdmPhysicalDpiX:
				val = qt4pd->physicalDpiX();
				break;
			case TQPaintDeviceMetrics::PdmDpiY:
				val = qt4pd->logicalDpiY();
				break;
			case TQPaintDeviceMetrics::PdmPhysicalDpiY:
				val = qt4pd->physicalDpiY();
				break;
			case TQPaintDeviceMetrics::PdmNumColors:
				val = qt4pd->colorCount();
				break;
			case TQPaintDeviceMetrics::PdmDepth:
				val = qt4pd->depth();
				break;
			default:
				val = 0;
#if defined(QT_CHECK_RANGE)
				tqWarning( "TDEQt4PaintDevice::metric: Invalid metric command" );
#endif
		}
	}
	else {
		val = 0;
#if defined(QT_CHECK_RANGE)
		tqWarning( "TDEQt4PaintDevice::metric: No Qt4 paint device available" );
#endif
	}
	return val;
}