summaryrefslogtreecommitdiffstats
path: root/plugin/tdeqt4painter.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'plugin/tdeqt4painter.cpp')
-rw-r--r--plugin/tdeqt4painter.cpp772
1 files changed, 772 insertions, 0 deletions
diff --git a/plugin/tdeqt4painter.cpp b/plugin/tdeqt4painter.cpp
new file mode 100644
index 0000000..6c8d4c0
--- /dev/null
+++ b/plugin/tdeqt4painter.cpp
@@ -0,0 +1,772 @@
+/****************************************************************************
+**
+** 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;
+}
+
generated by cgit v1.2.1 (git 2.18.0) at 2024-11-10 10:09:16 +0000