summaryrefslogtreecommitdiffstats
path: root/tqtinterface/qt4/src/kernel/tqpainter.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'tqtinterface/qt4/src/kernel/tqpainter.cpp')
-rw-r--r--tqtinterface/qt4/src/kernel/tqpainter.cpp5382
1 files changed, 5382 insertions, 0 deletions
diff --git a/tqtinterface/qt4/src/kernel/tqpainter.cpp b/tqtinterface/qt4/src/kernel/tqpainter.cpp
new file mode 100644
index 0000000..66596f5
--- /dev/null
+++ b/tqtinterface/qt4/src/kernel/tqpainter.cpp
@@ -0,0 +1,5382 @@
+#include "tqpainter.h"
+
+#include "tqpicture.h"
+
+#ifdef USE_QT4
+
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt3Support module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "tqpainter.h"
+#include "tqimage.h"
+#include "Qt/qpaintengine.h"
+
+// #include <private/qpainter_p.h>
+
+QT_BEGIN_NAMESPACE
+
+// TAKEN FROM QT4 qbrush.cpp
+// THIS BLOCK MAY NEED TO BE UPDATED FROM TIME TO TIME
+// BEGIN BLOCK
+struct QTexturedBrushData : public QBrushData
+{
+ QTexturedBrushData() {
+ m_has_pixmap_texture = false;
+ m_pixmap = 0;
+ }
+ ~QTexturedBrushData() {
+ delete m_pixmap;
+ }
+
+ void setPixmap(const QPixmap &pm) {
+ delete m_pixmap;
+
+ if (pm.isNull()) {
+ m_pixmap = 0;
+ m_has_pixmap_texture = false;
+ } else {
+ m_pixmap = new QPixmap(pm);
+ m_has_pixmap_texture = true;
+ }
+
+ m_image = QImage();
+ }
+
+ void setImage(const QImage &image) {
+ m_image = image;
+ delete m_pixmap;
+ m_pixmap = 0;
+ m_has_pixmap_texture = false;
+ }
+
+ QPixmap &pixmap() {
+ if (!m_pixmap) {
+ m_pixmap = new QPixmap(QPixmap::fromImage(m_image));
+ }
+ return *m_pixmap;
+ }
+
+ QImage &image() {
+ if (m_image.isNull() && m_pixmap)
+ m_image = m_pixmap->toImage();
+ return m_image;
+ }
+
+ QPixmap *m_pixmap;
+ QImage m_image;
+ bool m_has_pixmap_texture;
+};
+// END BLOCK
+
+/*!
+ \class TQPainter
+ \brief The TQPainter class is a Qt 3 compatibility wrapper for QPainter.
+
+ \compat
+
+ Prior to Qt 4, QPainter specialized the pen drawing for rectangle
+ based functions (in particular: drawRect, drawEllipse,
+ drawRoundRect, drawArc, drawChord and drawPie). When stroking a
+ rectangle of width 10, the pen would draw a rectangle of width 10.
+ Drawing a polygon defined by the corner points of the same
+ rectangle the stroke would have a width of 11.
+
+ The reason for this is best explained using the picture below:
+
+ \img q3painter_rationale.png
+
+ As we can see, stroking the rectangle so it gets a width of 10,
+ means the pen is drawn on a rectangle on width 9. The polygon,
+ however follows a consistent model.
+
+ In Qt 4, all rectangle based functions have changed to follow the
+ polygon approach, which means that the rectangle defines the size of
+ the fill, and the pen follows the edges of the shape. For pen widths
+ of 0 and 1 this means that the stroke will be inside the shape on the
+ left and the top and outside on the bottom and right.
+
+ The reason for the change in Qt 4 is so that we provide consistency
+ for all drawing functions even with complex transformations.
+*/
+
+TQPainter::TQPainter() : QPainter(), has_qwidget(FALSE), current_penpos(0,0) {
+}
+
+TQPainter::TQPainter( const QWidget *pdev, bool unclipped) : QPainter((QWidget*)pdev), has_qwidget(TRUE), current_penpos(0,0) {
+ qwidget_ptr = (QWidget*)pdev;
+ if (unclipped) {
+ printf("[WARNING] Qt4 does not support drawing under child widgets in TQPainter via the unclipped==TRUE flag in any form! Blame Nokia and change your code...\n\r");
+ fflush(stdout);
+ }
+}
+
+TQPainter::TQPainter( QPaintDevice *pdev, bool unclipped) : QPainter(pdev), has_qwidget(FALSE), current_penpos(0,0) {
+ if (unclipped) {
+ printf("[WARNING] Qt4 does not support drawing under child widgets in TQPainter via the unclipped==TRUE flag in any form! Blame Nokia and change your code...\n\r");
+ fflush(stdout);
+ }
+}
+
+TQPainter::TQPainter( QWidget *pdev, const QWidget *w, bool unclipped) : QPainter(pdev), has_qwidget(TRUE), current_penpos(0,0) {
+ qwidget_ptr = pdev;
+ initFrom(w);
+ if (unclipped) {
+ printf("[WARNING] Qt4 does not support drawing under child widgets in TQPainter via the unclipped==TRUE flag in any form! Blame Nokia and change your code...\n\r");
+ fflush(stdout);
+ }
+}
+
+TQPainter::TQPainter( QPaintDevice *pdev, const QWidget *w, bool unclipped ) : QPainter(pdev), has_qwidget(FALSE), current_penpos(0,0) {
+ initFrom(w);
+ if (unclipped) {
+ printf("[WARNING] Qt4 does not support drawing under child widgets in TQPainter via the unclipped==TRUE flag in any form! Blame Nokia and change your code...\n\r");
+ fflush(stdout);
+ }
+}
+
+// [FIXME]
+void TQPainter::flush() {
+ printf("[WARNING] void TQPainter::flush() unimplemented\n\r");
+}
+
+// [FIXME]
+void TQPainter::flush( const TQRegion &region, TQPainter::CoordinateMode cm ) {
+ printf("[WARNING] void TQPainter::flush( const TQRegion &region, CoordinateMode cm = CoordDevice ) unimplemented\n\r");
+}
+
+void TQPainter::setBrush(const QBrush &brush) {
+ return QPainter::setBrush(brush);
+}
+
+void TQPainter::setBrush(Qt::BrushStyle style) {
+ return QPainter::setBrush(style);
+}
+
+void TQPainter::setBrush(TQt::BrushStyle style) {
+ this->QPainter::setBrush((Qt::BrushStyle)style);
+}
+
+TQPoint TQPainter::pos() const {
+ return current_penpos;
+}
+
+bool TQPainter::tqbegin( QPaintDevice *pdev, bool unclipped ) {
+ bool ret = begin(pdev);
+ if (unclipped) {
+ printf("[WARNING] Qt4 does not support drawing under child widgets in TQPainter via the unclipped==TRUE flag in any form! Blame Nokia and change your code...\n\r");
+ fflush(stdout);
+ }
+ return ret;
+}
+
+bool TQPainter::tqbegin( QPaintDevice *pdev, const QWidget *init, bool unclipped ) {
+ bool ret = begin(pdev);
+ initFrom(init);
+ if (unclipped) {
+ printf("[WARNING] Qt4 does not support drawing under child widgets in TQPainter via the unclipped==TRUE flag in any form! Blame Nokia and change your code...\n\r");
+ fflush(stdout);
+ }
+ return ret;
+}
+
+QRectF TQPainter::boundingRect(const QRectF &rect, int flags, const QString &text) {
+ TQT_INITIALIZE_QPAINTER_TEMPORARY_ENGINE_CONDITIONAL
+ QRectF tqbr = QPainter::boundingRect(rect, flags, text);
+ TQT_DESTROY_QPAINTER_TEMPORARY_ENGINE_CONDITIONAL
+ return tqbr;
+}
+
+QRect TQPainter::boundingRect(const QRect &rect, int flags, const QString &text) {
+ TQT_INITIALIZE_QPAINTER_TEMPORARY_ENGINE_CONDITIONAL
+ QRect tqbr = QPainter::boundingRect(rect, flags, text);
+ TQT_DESTROY_QPAINTER_TEMPORARY_ENGINE_CONDITIONAL
+ return tqbr;
+}
+
+QRect TQPainter::boundingRect(int x, int y, int w, int h, int flags, const QString &text) {
+ TQT_INITIALIZE_QPAINTER_TEMPORARY_ENGINE_CONDITIONAL
+ QRect tqbr = QPainter::boundingRect(x, y, w, h, flags, text);
+ TQT_DESTROY_QPAINTER_TEMPORARY_ENGINE_CONDITIONAL
+ return tqbr;
+}
+
+QRectF TQPainter::boundingRect(const QRectF &rect, const QString &text, const QTextOption &o) {
+ TQT_INITIALIZE_QPAINTER_TEMPORARY_ENGINE_CONDITIONAL
+ QRectF tqbr = QPainter::boundingRect(rect, text, o);
+ TQT_DESTROY_QPAINTER_TEMPORARY_ENGINE_CONDITIONAL
+ return tqbr;
+}
+
+TQRect TQPainter::boundingRect(const QRect &rect, int flags, const QString &text, int len) {
+ TQT_INITIALIZE_QPAINTER_TEMPORARY_ENGINE_CONDITIONAL
+ TQRect tqbr = QPainter::boundingRect(rect, flags, text.left(len));
+ TQT_DESTROY_QPAINTER_TEMPORARY_ENGINE_CONDITIONAL
+ return tqbr;
+}
+
+TQRect TQPainter::boundingRect(int x, int y, int w, int h, int flags, const QString &text, int len) {
+ TQT_INITIALIZE_QPAINTER_TEMPORARY_ENGINE_CONDITIONAL
+ TQRect tqbr = QPainter::boundingRect(QRect(x, y, w, h), flags, text.left(len));
+ TQT_DESTROY_QPAINTER_TEMPORARY_ENGINE_CONDITIONAL
+ return tqbr;
+}
+
+void TQPainter::drawText(const QPointF &p, const QString &s) {
+ QPainter::drawText(p, s);
+}
+
+void TQPainter::drawText(const QPoint &p, const QString &s) {
+ QPainter::drawText(p, s);
+}
+
+void TQPainter::drawText(int x, int y, const QString &s) {
+ QPainter::drawText(x, y, s);
+}
+
+void TQPainter::drawText(const QPointF &p, const QString &str, int tf, int justificationPadding) {
+ QPainter::drawText(p, str, tf, justificationPadding);
+}
+
+void TQPainter::drawText(const QRectF &r, int flags, const QString &text, QRectF *br) {
+ QPainter::drawText(r, flags, text, br);
+}
+
+void TQPainter::drawText(const QRect &r, int flags, const QString &text, QRect *br) {
+ QPainter::drawText(r, flags, text, br);
+}
+
+void TQPainter::drawText(int x, int y, int w, int h, int flags, const QString &text, QRect *br) {
+ QPainter::drawText(x, y, w, h, flags, text, br);
+}
+
+void TQPainter::drawText(const QRectF &r, const QString &text, const QTextOption &o) {
+ QPainter::drawText(r, text, o);
+}
+
+void TQPainter::drawText( int x, int y, const TQString &s, int len, TextDirection dir ) {
+ Qt::LayoutDirection old = layoutDirection();
+ if (dir == RTL)
+ setLayoutDirection(Qt::RightToLeft);
+ else if (dir == LTR)
+ setLayoutDirection(Qt::LeftToRight);
+ QPainter::drawText(x, y, s.left(len));
+ setLayoutDirection(old);
+}
+void TQPainter::drawText( const TQPoint &p, const TQString &s, int len, TextDirection dir ) {
+ Qt::LayoutDirection old = layoutDirection();
+ if (dir == RTL)
+ setLayoutDirection(Qt::RightToLeft);
+ else if (dir == LTR)
+ setLayoutDirection(Qt::LeftToRight);
+ QPainter::drawText(p, s.left(len));
+ setLayoutDirection(old);
+}
+void TQPainter::drawText( int x, int y, const TQString &s, int pos, int len, TextDirection dir ) {
+ Qt::LayoutDirection old = layoutDirection();
+ if (dir == RTL)
+ setLayoutDirection(Qt::RightToLeft);
+ else if (dir == LTR)
+ setLayoutDirection(Qt::LeftToRight);
+ QPainter::drawText(x, y, s.mid(pos, len));
+ setLayoutDirection(old);
+}
+void TQPainter::drawText( const TQPoint &p, const TQString &s, int pos, int len, TextDirection dir ) {
+ Qt::LayoutDirection old = layoutDirection();
+ if (dir == RTL)
+ setLayoutDirection(Qt::RightToLeft);
+ else if (dir == LTR)
+ setLayoutDirection(Qt::LeftToRight);
+ QPainter::drawText(p, s.mid(pos, len));
+ setLayoutDirection(old);
+}
+
+void TQPainter::drawText(int x, int y, const QString &s, int pos, int len) {
+ drawText(x, y, s.mid(pos, len));
+}
+
+void TQPainter::drawText(const QPoint &p, const QString &s, int pos, int len) {
+ drawText(p, s.mid(pos, len));
+}
+
+void TQPainter::drawText(int x, int y, const QString &s, int len) {
+ drawText(x, y, s.left(len));
+}
+
+void TQPainter::drawText(const QPoint &p, const QString &s, int len) {
+ drawText(p, s.left(len));
+}
+
+void TQPainter::drawText(const QRect &r, int flags, const QString &str, int len, QRect *br) {
+ drawText(r, flags, str.left(len), br);
+}
+
+void TQPainter::drawText(int x, int y, int w, int h, int flags, const QString &text, int len, QRect *br) {
+ drawText(QRect(x, y, w, h), flags, text.left(len), br);
+}
+
+int TQPainter::tabStops() const
+{
+ printf("[WARNING] TQPainter::tabStops unimplemented!\n\r");
+}
+
+void TQPainter::setTabStops( int ts )
+{
+ printf("[WARNING] TQPainter::setTabStops unimplemented!\n\r");
+
+// #if defined(TQT_CHECK_STATE)
+// if ( !isActive() )
+// qWarning( "TQPainter::setTabStops: Will be reset by begin()" );
+// #endif
+// tabstops = ts;
+// if ( isActive() && testf(ExtDev) ) { // tell extended tqdevice
+// TQPDevCmdParam param[1];
+// param[0].ival = ts;
+// pdev->cmd( TQPaintDevice::PdcSetTabStops, this, param );
+// }
+}
+
+int *TQPainter::tabArray() const
+{
+ printf("[WARNING] TQPainter::tabArray unimplemented!\n\r");
+}
+
+void TQPainter::setTabArray( int *ta )
+{
+ printf("[WARNING] TQPainter::setTabArray unimplemented!\n\r");
+
+// #if defined(TQT_CHECK_STATE)
+// if ( !isActive() )
+// qWarning( "TQPainter::setTabArray: Will be reset by begin()" );
+// #endif
+// if ( ta != tabarray ) {
+// tabarraylen = 0;
+// if ( tabarray ) // Avoid purify complaint
+// delete [] tabarray; // delete old array
+// if ( ta ) { // tabarray = copy of 'ta'
+// while ( ta[tabarraylen] )
+// tabarraylen++;
+// tabarraylen++; // and 0 terminator
+// tabarray = new int[tabarraylen]; // duplicate ta
+// memcpy( tabarray, ta, sizeof(int)*tabarraylen );
+// } else {
+// tabarray = 0;
+// }
+// }
+// if ( isActive() && testf(ExtDev) ) { // tell extended tqdevice
+// TQPDevCmdParam param[2];
+// param[0].ival = tabarraylen;
+// param[1].ivec = tabarray;
+// pdev->cmd( TQPaintDevice::PdcSetTabArray, this, param );
+// }
+}
+
+void TQPainter::drawImage( int x, int y, const TQImage image, int sx, int sy, int sw, int sh, int conversionFlags ) {
+ QPainter::drawImage(x, y, image, sx, sy, sw, sh, (Qt::ImageConversionFlags)conversionFlags);
+}
+
+void TQPainter::drawImage( const TQPoint p, const TQImage image, const TQRect sr, int conversionFlags ) {
+ QPainter::drawImage(p, image, sr, (Qt::ImageConversionFlags)conversionFlags);
+}
+
+void TQPainter::drawImage( const TQPoint p, const TQImage image, int conversion_flags ) {
+ TQ_UNUSED(conversion_flags);
+ QPainter::drawImage(p, image);
+}
+
+void TQPainter::drawImage( const TQRect r, const TQImage image ) {
+ QPainter::drawImage(r, image);
+}
+
+void TQPainter::resetXForm() {
+ resetTransform();
+}
+
+// [FIXME] The drawWinFocusRect methods below probably need tweaking to exactly match the old Qt3 behaviour
+void TQPainter::drawWinFocusRect( int x, int y, int w, int h ) {
+ drawWinFocusRect( x, y, w, h, TRUE, TQt::color0 );
+}
+
+void TQPainter::drawWinFocusRect( int x, int y, int w, int h, const TQColor &bgColor ) {
+ drawWinFocusRect( x, y, w, h, FALSE, bgColor );
+}
+
+void TQPainter::drawWinFocusRect( const TQRect &tqr ) {
+ drawWinFocusRect( tqr.x(), tqr.y(), tqr.width(), tqr.height() );
+}
+
+void TQPainter::drawWinFocusRect( const TQRect &tqr, const TQColor &bgColor ) {
+ drawWinFocusRect( tqr.x(), tqr.y(), tqr.width(), tqr.height(), bgColor );
+}
+
+void TQPainter::setBackgroundColor(const QColor &color) {
+ setBackground(color);
+}
+
+const QColor &TQPainter::backgroundColor() const {
+ return background().color();
+}
+
+void TQPainter::setClipRect(const QRectF &qrf, Qt::ClipOperation op) {
+ QPainter::setClipRect(qrf, op);
+}
+
+void TQPainter::setClipRect(const QRect &qr, Qt::ClipOperation op) {
+ QPainter::setClipRect(qr, op);
+}
+
+void TQPainter::setClipRect( int x, int y, int w, int h, TQPainter::CoordinateMode cm ) {
+ TQRect r(x, y, w, h);
+ setClipRect(r, cm);
+}
+
+void TQPainter::redirect(QPaintDevice *pdev, QPaintDevice *replacement) {
+ if (replacement == 0) {
+ restoreRedirected(pdev);
+ }
+ else {
+ setRedirected(pdev, replacement);
+ }
+}
+
+TQPaintDevice *TQPainter::redirect(QPaintDevice *pdev) {
+ return static_cast<TQPaintDevice*>(const_cast<QPaintDevice*>(redirected(pdev)));
+}
+
+void TQPainter::setWorldXForm(bool enabled) {
+ setMatrixEnabled(enabled);
+}
+
+bool TQPainter::hasWorldXForm() const {
+ return matrixEnabled();
+}
+
+void TQPainter::setViewXForm(bool enabled) {
+ setViewTransformEnabled(enabled);
+}
+
+bool TQPainter::hasViewXForm() const {
+ return viewTransformEnabled();
+}
+
+// [FIXME]
+void TQPainter::initialize() {
+ printf("[WARNING] TQColor static void initialize() not implemented\n\r");
+}
+
+// [FIXME]
+void TQPainter::cleanup() {
+ printf("[WARNING] TQColor static void cleanup() not implemented\n\r");
+}
+
+void TQPainter::moveTo( const TQPoint &p )
+{
+ moveTo( p.x(), p.y() );
+}
+
+void TQPainter::lineTo( const TQPoint &p )
+{
+ lineTo( p.x(), p.y() );
+}
+
+void TQPainter::drawRect(const QRect &r)
+{
+ QPainter::drawRect(adjustedRectangle(r));
+}
+
+void TQPainter::drawEllipse(const QRect &r)
+{
+ QPainter::drawEllipse(adjustedRectangle(r));
+}
+
+void TQPainter::drawRoundRect(const QRect &r, int xrnd, int yrnd)
+{
+ QPainter::drawRoundRect(adjustedRectangle(r), xrnd, yrnd);
+}
+
+void TQPainter::drawArc(const QRect &r, int angle, int arcLength)
+{
+ QPainter::drawArc(adjustedRectangle(r), angle, arcLength);
+}
+
+void TQPainter::drawPie(const QRect &r, int angle, int arcLength)
+{
+ QPainter::drawPie(adjustedRectangle(r), angle, arcLength);
+}
+
+void TQPainter::drawChord(const QRect &r, int angle, int arcLength)
+{
+ QPainter::drawChord(adjustedRectangle(r), angle, arcLength);
+}
+
+void TQPainter::tqdrawTextItem( const TQPoint& p, const TQTextItem &ti, int textflags )
+{
+ tqdrawTextItem( p.x(), p.y(), ti, textflags );
+}
+
+// [FIXME]
+// Verify these mappings...
+// They will need to be kept in sync with the code inside tqpainter_x11.cpp
+TQt::RasterOp TQPainter::rasterOp() const
+{
+ TQt::RasterOp cm;
+ switch (rop) {
+ case QPainter::CompositionMode_SourceOver:
+ cm=CopyROP;
+ break;
+ case QPainter::RasterOp_SourceOrDestination:
+ cm=OrROP;
+ break;
+ case QPainter::RasterOp_SourceXorDestination:
+ cm=XorROP;
+ break;
+ case QPainter::RasterOp_NotSourceAndDestination:
+ cm=NotAndROP;
+ break;
+ case QPainter::RasterOp_NotSource:
+ cm=NotCopyROP;
+ break;
+ case QPainter::RasterOp_NotSourceXorDestination:
+ cm=NotXorROP;
+ break;
+ case QPainter::RasterOp_SourceAndDestination:
+ cm=AndROP;
+ break;
+ case QPainter::CompositionMode_Clear:
+ cm=ClearROP;
+ break;
+ case QPainter::CompositionMode_Destination:
+ cm=NopROP;
+ break;
+ case QPainter::RasterOp_SourceAndNotDestination:
+ cm=AndNotROP;
+ break;
+ case QPainter::RasterOp_NotSourceOrNotDestination:
+ cm=NandROP;
+ break;
+ case QPainter::RasterOp_NotSourceAndNotDestination:
+ cm=NorROP;
+ break;
+ default:
+ cm=CopyROP;
+ break;
+ }
+ return cm;
+}
+
+/*!
+ \fn TQPainter::TQPainter()
+
+ Constructs a TQPainter.
+*/
+
+/*!
+ \fn TQPainter::TQPainter(QPaintDevice *pdev)
+
+ Constructs a TQPainter that operates on tqdevice \a pdev.
+*/
+
+/*!
+ \internal
+*/
+
+int TQPainter::rectSubtraction() const {
+ return pen().style() != Qt::NoPen && pen().width() == 0 ? 1 : 0;
+}
+
+/*!
+ \internal
+*/
+QRect TQPainter::adjustedRectangle(const QRect &r)
+{
+ QRect rect = r.normalized();
+ int subtract = rectSubtraction();
+ if (subtract != 0)
+ rect.setSize(QSize(rect.width() - subtract, rect.height() - subtract));
+ return rect;
+}
+
+
+/*!
+ \fn void TQPainter::drawRect(int x, int y, int w, int h)
+
+ \overload
+
+ Draws the rectangle that fits inside the bounds specified by \a x,
+ \a y, \a w and \a h using the current pen and brush.
+*/
+
+/*!
+ \fn void TQPainter::drawRect(const QRect &r)
+
+ Draws a rectangle that fits inside the rectangle \a r using the
+ current pen and brush.
+
+*/
+
+
+
+/*!
+ \fn TQPainter::drawEllipse(const QRect &r)
+
+ Draws the ellipse that fits inside the bounds \a r using the
+ current pen and brush.
+
+*/
+
+/*!
+ \fn TQPainter::drawEllipse(int x, int y, int width, int height)
+
+ \overload
+
+ Draws an ellipse that fits inside the bounds specified by \a x,
+ \a y, \a width and \a height using the current pen and brush.
+
+*/
+
+/*!
+ \fn void TQPainter::drawPie(int x, int y, int w, int h, int
+ startAngle, int spanAngle)
+
+ \overload
+
+ Draws a pie segment that fits inside the bounds (\a{x}, \a{y},
+ \a{w}, \a{h}) with the given \a startAngle and \a spanAngle.
+*/
+
+/*!
+ \fn void TQPainter::drawPie(const QRect &r, int a, int alen)
+
+ Draws a pie defined by the rectangle \a r, the start angle \a a
+ and the arc length \a alen.
+
+ The pie is filled with the current brush().
+
+ The angles \a a and \a alen are 1/16th of a degree, i.e. a full
+ circle equals 5760 (16*360). Positive values of \a a and \a alen
+ mean counter-clockwise while negative values mean the clockwise
+ direction. Zero degrees is at the 3 o'clock position.
+
+ \sa drawArc(), drawChord()
+*/
+
+/*!
+ \fn void TQPainter::drawArc(int x, int y, int w, int h, int
+ startAngle, int spanAngle)
+
+ \overload
+
+ Draws the arc that fits inside the rectangle (\a{x}, \a{y}, \a{w},
+ \a{h}), with the given \a startAngle and \a spanAngle.
+*/
+
+/*!
+ \fn void TQPainter::drawArc(const QRect &r, int a, int alen)
+
+ Draws an arc defined by the rectangle \a r, the start angle \a a
+ and the arc length \a alen.
+
+ The angles \a a and \a alen are 1/16th of a degree, i.e. a full
+ circle equals 5760 (16*360). Positive values of \a a and \a alen
+ mean counter-clockwise while negative values mean the clockwise
+ direction. Zero degrees is at the 3 o'clock position.
+
+ Example:
+ \snippet doc/src/snippets/code/src_qt3support_painting_q3painter.cpp 0
+
+ \sa drawPie(), drawChord()
+*/
+
+/*!
+ \fn void TQPainter::drawChord(int x, int y, int w, int h, int
+ startAngle, int spanAngle)
+
+ \overload
+
+ Draws a chord that fits inside the rectangle (\a{x}, \a{y}, \a{w},
+ \a{h}) with the given \a startAngle and \a spanAngle.
+*/
+
+
+/*!
+ \fn void TQPainter::drawChord(const QRect &r, int a, int alen)
+
+ Draws a chord defined by the rectangle \a r, the start angle \a a
+ and the arc length \a alen.
+
+ The chord is filled with the current brush().
+
+ The angles \a a and \a alen are 1/16th of a degree, i.e. a full
+ circle equals 5760 (16*360). Positive values of \a a and \a alen
+ mean counter-clockwise while negative values mean the clockwise
+ direction. Zero degrees is at the 3 o'clock position.
+
+ \sa drawArc(), drawPie()
+*/
+
+/*!
+ \fn void TQPainter::drawRoundRect(const QRect &r, int xrnd, int yrnd)
+
+ Draws a rounded rect that fits into the bounds \a r using the current
+ pen and brush. The parameters \a xrnd and \a yrnd specifies the roundness
+ in x and y direction.
+*/
+
+/*!
+ \fn void TQPainter::drawRoundRect(int x, int y, int w, int h, int xrnd, int yrnd)
+
+ \overload
+
+ Draws a rounded rect that fits into the bounds \a x, \a y, \a w
+ and \a h using the current pen and brush. The parameters \a xrnd
+ and \a yrnd specifies the roundness in x and y direction.
+*/
+
+/*!
+ \fn void QPainter::drawLineSegments(const QPolygon &polygon, int
+ index, int count)
+
+ Draws \a count separate lines from points defined by the \a
+ polygon, starting at \a{polygon}\e{[index]} (\a index defaults to
+ 0). If \a count is -1 (the default) all points until the end of
+ the array are used.
+
+ Use drawLines() combined with QPolygon::constData() instead.
+
+ \oldcode
+ QPainter painter(this);
+ painter.drawLineSegments(polygon, index, count);
+ \newcode
+ int lineCount = (count == -1) ? (polygon.size() - index) / 2 : count;
+
+ QPainter painter(this);
+ painter.drawLines(polygon.constData() + index * 2, lineCount);
+ \endcode
+*/
+
+void TQPainter::drawLineSegments(const QPolygon &polygon, int index, int count)
+{
+ int lineCount = (count == -1) ? (polygon.size() - index) / 2 : count;
+
+ drawLines(polygon.constData() + index * 2, lineCount);
+}
+
+/*!
+ \obsolete
+
+ Use the worldTransform() combined with QTransform::dx() instead.
+
+ \oldcode
+ QPainter painter(this);
+ qreal x = painter.translationX();
+ \newcode
+ QPainter painter(this);
+ qreal x = painter.worldTransform().dx();
+ \endcode
+*/
+qreal TQPainter::translationX() const
+{
+ return worldTransform().dx();
+}
+
+/*!
+ \obsolete
+
+ Use the worldTransform() combined with QTransform::dy() instead.
+
+ \oldcode
+ QPainter painter(this);
+ qreal y = painter.translationY();
+ \newcode
+ QPainter painter(this);
+ qreal y = painter.worldTransform().dy();
+ \endcode
+*/
+qreal TQPainter::translationY() const
+{
+ return worldTransform().dy();
+}
+
+/*!
+ \fn void TQPainter::map(int x, int y, int *rx, int *ry) const
+
+ \internal
+
+ Sets (\a{rx}, \a{ry}) to the point that results from applying the
+ painter's current transformation on the point (\a{x}, \a{y}).
+*/
+void TQPainter::map(int x, int y, int *rx, int *ry) const
+{
+ QPoint p(x, y);
+ p = p * combinedMatrix();
+ *rx = p.x();
+ *ry = p.y();
+}
+
+/*!
+ \internal
+ Maps a rectangle from logical coordinates to device coordinates.
+ This internal function does not handle rotation and/or shear.
+*/
+
+void TQPainter::map( int x, int y, int w, int h, int *rx, int *ry, int *rw, int *rh ) const
+{
+ TQRect qr(x, y, w, h);
+ QTransform dtrans = combinedTransform();
+ TQRect tqr = dtrans.mapRect(qr);
+ *rx = tqr.x();
+ *ry = tqr.y();
+ *rw = tqr.width();
+ *rh = tqr.height();
+}
+
+/*!
+ \fn TQPoint TQPainter::xForm(const QPoint &point) const
+
+ Use combinedTransform() instead.
+*/
+
+TQPoint TQPainter::xForm(const QPoint &p) const
+{
+ if (combinedTransform().type() == QTransform::TxNone)
+ return p;
+ return p * combinedMatrix();
+}
+
+
+/*!
+ \fn TQRect TQPainter::xForm(const QRect &rectangle) const
+ \overload
+
+ Use combinedTransform() instead of this function and call
+ mapRect() on the result to obtain a QRect.
+*/
+
+TQRect TQPainter::xForm(const QRect &r) const
+{
+ if (combinedTransform().type() == QTransform::TxNone)
+ return r;
+ return combinedMatrix().mapRect(r);
+}
+
+bool TQPainter::testf( uint b ) const {
+// printf("[WARNING] QPainter::testf() disabled\n\r");
+// return 0;
+
+ // Map to Qt4 flags and functions...
+ if ((b&IsActive)!=0) {
+ if (QPainter::isActive()) return TRUE;
+ }
+// if ((b&ExtDev)!=0) {
+// printf("[WARNING] Assuming ExtDev==false in QPainter::testf()\n\r");
+// }
+// if ((b&IsStartingUp)!=0) {
+// }
+// if ((b&NoCache)!=0) {
+// }
+ if ((b&VxF)!=0) {
+ if (QPainter::viewTransformEnabled()) return TRUE;
+ }
+ if ((b&WxF)!=0) {
+ if (QPainter::worldMatrixEnabled()) return TRUE;
+ }
+ if ((b&ClipOn)!=0) {
+ if (QPainter::hasClipping()) return TRUE;
+ }
+
+ printf("[WARNING] Assuming test flag 0x%x == false in QPainter::testf()\n\r", b);
+ return 0;
+}
+
+/*!
+ \fn TQPolygon TQPainter::xForm(const QPolygon &polygon) const
+ \overload
+
+ Use combinedTransform() instead.
+*/
+
+// TQPolygon TQPainter::xForm(const QPolygon &a) const
+// {
+// Q_D(const QPainter);
+// if (!d->engine) {
+// qWarning("QPainter::xForm: Painter not active");
+// return QPolygon();
+// }
+// if (d->state->matrix.type() == QTransform::TxNone)
+// return a;
+// return a * combinedMatrix();
+// }
+
+/*!
+ \fn TQPolygon TQPainter::xForm(const QPolygon &polygon, int index, int count) const
+ \overload
+
+ Use combinedTransform() combined with QPolygon::mid() instead.
+
+ \oldcode
+ QPainter painter(this);
+ QPolygon transformed = painter.xForm(polygon, index, count)
+ \newcode
+ QPainter painter(this);
+ QPolygon transformed = polygon.mid(index, count) * painter.combinedTransform();
+ \endcode
+*/
+
+// TQPolygon TQPainter::xForm(const QPolygon &av, int index, int npoints) const
+// {
+// int lastPoint = npoints < 0 ? av.size() : index+npoints;
+// QPolygon a(lastPoint-index);
+// memcpy(a.data(), av.data()+index, (lastPoint-index)*sizeof(QPoint));
+// return a * combinedMatrix();
+// }
+
+/*!
+ \fn TQPoint TQPainter::xFormDev(const QPoint &point) const
+ \overload
+ \obsolete
+
+ Use combinedTransform() combined with QTransform::inverted() instead.
+
+ \oldcode
+ QPainter painter(this);
+ QPoint transformed = painter.xFormDev(point);
+ \newcode
+ QPainter painter(this);
+ QPoint transformed = point * painter.combinedTransform().inverted();
+ \endcode
+*/
+
+TQPoint TQPainter::xFormDev(const QPoint &p) const
+{
+ if(combinedTransform().type() == QTransform::TxNone)
+ return p;
+ return p * combinedMatrix().inverted();
+}
+
+/*!
+ \fn TQRect TQPainter::xFormDev(const QRect &rectangle) const
+ \overload
+ \obsolete
+
+ Use combinedTransform() combined with QTransform::inverted() instead.
+
+ \oldcode
+ QPainter painter(this);
+ QRect transformed = painter.xFormDev(rectangle);
+ \newcode
+ QPainter painter(this);
+ QRegion region = QRegion(rectangle) * painter.combinedTransform().inverted();
+ QRect transformed = region.boundingRect();
+ \endcode
+*/
+
+TQRect TQPainter::xFormDev(const QRect &r) const
+{
+ if (combinedTransform().type() == QTransform::TxNone)
+ return r;
+ return combinedMatrix().inverted().mapRect(r);
+}
+
+/*!
+ \overload
+
+ \fn TQPoint TQPainter::xFormDev(const QPolygon &polygon) const
+ \obsolete
+
+ Use combinedTransform() combined with QTransform::inverted() instead.
+
+ \oldcode
+ QPainter painter(this);
+ QPolygon transformed = painter.xFormDev(rectangle);
+ \newcode
+ QPainter painter(this);
+ QPolygon transformed = polygon * painter.combinedTransform().inverted();
+ \endcode
+*/
+
+// TQPolygon TQPainter::xFormDev(const QPolygon &a) const
+// {
+// Q_D(const QPainter);
+// if (!d->engine) {
+// qWarning("QPainter::xFormDev: Painter not active");
+// return QPolygon();
+// }
+// if (d->state->matrix.type() == QTransform::TxNone)
+// return a;
+// return a * combinedMatrix().inverted();
+// }
+
+/*!
+ \fn TQPolygon TQPainter::xFormDev(const QPolygon &polygon, int index, int count) const
+ \overload
+ \obsolete
+
+ Use combinedTransform() combined with QPolygon::mid() and QTransform::inverted() instead.
+
+ \oldcode
+ QPainter painter(this);
+ QPolygon transformed = painter.xFormDev(polygon, index, count);
+ \newcode
+ QPainter painter(this);
+ QPolygon transformed = polygon.mid(index, count) * painter.combinedTransform().inverted();
+ \endcode
+*/
+
+// TQPolygon TQPainter::xFormDev(const QPolygon &ad, int index, int npoints) const
+// {
+// Q_D(const QPainter);
+// int lastPoint = npoints < 0 ? ad.size() : index+npoints;
+// QPolygon a(lastPoint-index);
+// memcpy(a.data(), ad.data()+index, (lastPoint-index)*sizeof(QPoint));
+// if (d->state->matrix.type() == QTransform::TxNone)
+// return a;
+// return a * combinedMatrix().inverted();
+// }
+
+/*! \obsolete
+ Sets the current pen position to \a (x, y)
+
+ \sa lineTo(), pos()
+*/
+
+void TQPainter::moveTo( int x, int y )
+{
+ QPainterPath path;
+ path.moveTo(x, y);
+ drawPath(path);
+ current_penpos = QPoint(x, y);
+}
+
+/*! \obsolete
+ Use drawLine() instead.
+
+ Draws a line from the current pen position to \a (x, y) and sets
+ \a (x, y) to be the new current pen position.
+
+ \sa TQPen moveTo(), drawLine(), pos()
+*/
+
+void TQPainter::lineTo( int x, int y )
+{
+ QPainterPath path;
+ path.moveTo(current_penpos.x(), current_penpos.y());
+ path.lineTo(x, y);
+ drawPath(path);
+ current_penpos = QPoint(x, y);
+}
+
+static void bitBlt_helper(QPaintDevice *dst, const QPoint &dp,
+ const QPaintDevice *src, const QRect &sr, bool)
+{
+ Q_ASSERT(dst);
+ Q_ASSERT(src);
+
+ if (src->devType() == QInternal::Pixmap) {
+ const QPixmap *pixmap = static_cast<const QPixmap *>(src);
+ QPainter pt(dst);
+ pt.drawPixmap(dp, *pixmap, sr);
+
+ } else {
+ qWarning("QPainter: bitBlt only works when source is of type pixmap");
+ }
+}
+
+void bitBlt(QPaintDevice *dst, int dx, int dy,
+ const QPaintDevice *src, int sx, int sy, int sw, int sh,
+ bool ignoreMask )
+{
+ bitBlt_helper(dst, QPoint(dx, dy), src, QRect(sx, sy, sw, sh), ignoreMask);
+}
+
+void bitBlt(QPaintDevice *dst, const QPoint &dp, const QPaintDevice *src, const QRect &sr, bool ignoreMask)
+{
+ bitBlt_helper(dst, dp, src, sr, ignoreMask);
+}
+
+void bitBlt(QPaintDevice *dst, int dx, int dy,
+ const QImage *src, int sx, int sy, int sw, int sh, int fl)
+{
+ Qt::ImageConversionFlags flags(fl);
+ QPixmap srcPixmap = QPixmap::fromImage(*src, flags);
+ bitBlt_helper(dst, QPoint(dx, dy), &srcPixmap, QRect(sx, sy, sw, sh), false);
+}
+
+const TQWMatrix &TQPainter::tqworldMatrix() const {
+ return (*(static_cast<const TQWMatrix*>(&worldMatrix())));
+}
+
+/*!
+ \fn void TQPainter::tqdrawTextItem(const TQPoint &, const TQTextItem &, int)
+ \internal
+*/
+
+static inline void fix_neg_rect( int *x, int *y, int *w, int *h )
+{
+ if ( *w < 0 ) {
+ *w = -*w + 2;
+ *x -= *w - 1;
+ }
+ if ( *h < 0 ) {
+ *h = -*h + 2;
+ *y -= *h - 1;
+ }
+}
+void TQPainter::fix_neg_rect( int *x, int *y, int *w, int *h )
+{
+ ::fix_neg_rect(x,y,w,h);
+}
+
+TQRegion TQPainter::clipRegion( CoordinateMode cm ) const {
+ QRegion qr = QPainter::clipRegion();
+ QRegion tqr = qr;
+ if (cm == CoordDevice) {
+ // Convert to device coordinates
+ QTransform dtrans = combinedTransform();
+ tqr = dtrans.map(qr);
+ }
+ return tqr;
+}
+
+void TQPainter::setClipRegion( const QRegion &qr, CoordinateMode cm ) {
+ QRegion tqr = qr;
+
+ if (cm == CoordDevice) {
+ // Convert from device coordinates
+ QTransform itrans = combinedTransform().inverted();
+ tqr = itrans.map(qr);
+
+ QPainter::setClipRegion( tqr, Qt::ReplaceClip );
+ }
+ else {
+ QPainter::setClipRegion( tqr, Qt::ReplaceClip );
+ }
+}
+
+void TQPainter::setClipRect( const TQRect &qr, CoordinateMode cm ) {
+ QRect tqr = qr;
+
+ if (cm == CoordDevice) {
+ // Convert from device coordinates
+ QTransform itrans = combinedTransform().inverted();
+ tqr = itrans.mapRect(qr);
+
+ QPainter::setClipRect( tqr, Qt::ReplaceClip );
+ }
+ else {
+ QPainter::setClipRect( tqr, Qt::ReplaceClip );
+ }
+}
+
+#ifndef TQT_NO_BEZIER
+void TQPainter::drawCubicBezier(const TQPointArray &a, int index)
+{
+ if ((int)a.size() - index < 4) {
+ qWarning("QPainter::drawCubicBezier: Cubic Bezier needs 4 control "
+ "points");
+ return;
+ }
+
+ QPainterPath path;
+ path.moveTo(a.at(index));
+ path.cubicTo(a.at(index+1), a.at(index+2), a.at(index+3));
+ strokePath(path, pen());
+}
+#endif // TQT_NO_BEZIER
+
+#ifndef TQT_NO_PICTURE
+void TQPainter::drawPicture( const QPicture pic ) {
+ QPainter::drawPicture(0, 0, pic);
+}
+
+void TQPainter::drawPicture( int x, int y, const QPicture pic ) {
+ QPainter::drawPicture(x, y, pic);
+}
+
+void TQPainter::drawPicture( const QPoint point, const QPicture pic ) {
+ QPainter::drawPicture(point.x(), point.y(), pic);
+}
+#endif // TQT_NO_PICTURE
+
+/*! \obsolete
+
+ We recommend using save() instead.
+*/
+
+void TQPainter::saveWorldMatrix() {
+ save();
+}
+
+/*! \obsolete
+ We recommend using restore() instead.
+*/
+
+void TQPainter::restoreWorldMatrix() {
+ restore();
+}
+
+/*!
+ \overload
+
+ Returns the point array \a av transformed from model coordinates
+ to tqdevice coordinates.
+
+ \sa xFormDev(), TQWMatrix::map()
+*/
+
+TQPointArray TQPainter::xForm( const TQPointArray &av ) const
+{
+ TQPointArray a = av;
+ if ( combinedTransform().type() != QTransform::TxNone )
+ {
+ return TQT_TQWMATRIX_OBJECT(combinedMatrix()) * av;
+ }
+ return a;
+}
+
+/*!
+ \overload
+
+ Returns the point array \a av transformed from model coordinates
+ to tqdevice coordinates. The \a index is the first point in the
+ array and \a npoints denotes the number of points to be
+ transformed. If \a npoints is negative, all points from \a
+ av[index] until the last point in the array are transformed.
+
+ The returned point array consists of the number of points that
+ were transformed.
+
+ Example:
+ \code
+ TQPointArray a(10);
+ TQPointArray b;
+ b = painter.xForm(a, 2, 4); // b.size() == 4
+ b = painter.xForm(a, 2, -1); // b.size() == 8
+ \endcode
+
+ \sa xFormDev(), TQWMatrix::map()
+*/
+
+TQPointArray TQPainter::xForm( const TQPointArray &av, int index,
+ int npoints ) const
+{
+ int lastPoint = npoints < 0 ? av.size() : index+npoints;
+ TQPointArray a( lastPoint-index );
+ memcpy( a.data(), av.data()+index, (lastPoint-index)*sizeof( TQPoint ) );
+ return TQT_TQWMATRIX_OBJECT(combinedMatrix()) * a;
+}
+
+/*!
+ \overload
+
+ Returns the point array \a ad transformed from tqdevice coordinates
+ to model coordinates.
+
+ \sa xForm(), TQWMatrix::map()
+*/
+
+TQPointArray TQPainter::xFormDev( const TQPointArray &ad ) const
+{
+ if ( combinedTransform().type() == QTransform::TxNone )
+ return ad;
+ return TQT_TQWMATRIX_OBJECT(combinedMatrix().inverted()) * ad;
+}
+
+/*!
+ \overload
+
+ Returns the point array \a ad transformed from tqdevice coordinates
+ to model coordinates. The \a index is the first point in the array
+ and \a npoints denotes the number of points to be transformed. If
+ \a npoints is negative, all points from \a ad[index] until the
+ last point in the array are transformed.
+
+ The returned point array consists of the number of points that
+ were transformed.
+
+ Example:
+ \code
+ TQPointArray a(10);
+ TQPointArray b;
+ b = painter.xFormDev(a, 1, 3); // b.size() == 3
+ b = painter.xFormDev(a, 1, -1); // b.size() == 9
+ \endcode
+
+ \sa xForm(), TQWMatrix::map()
+*/
+
+TQPointArray TQPainter::xFormDev( const TQPointArray &ad, int index, int npoints ) const
+{
+ int lastPoint = npoints < 0 ? ad.size() : index+npoints;
+ TQPointArray a( lastPoint-index );
+ memcpy( a.data(), ad.data()+index, (lastPoint-index)*sizeof( TQPoint ) );
+ if ( combinedTransform().type() == QTransform::TxNone )
+ return a;
+ return TQT_TQWMATRIX_OBJECT(combinedMatrix().inverted()) * a;
+}
+
+/*!
+ Draws/plots an array of points, \a a, using the current pen.
+
+ If \a index is non-zero (the default is zero) only points from \a
+ index are drawn. If \a npoints is negative (the default) the rest
+ of the points from \a index are drawn. If \a npoints is zero or
+ greater, \a npoints points are drawn.
+
+ \warning On X11, coordinates that do not fit into 16-bit signed
+ values are truncated. This limitation is expected to go away in
+ TQt 4.
+*/
+
+void TQPainter::drawPoints( const TQPointArray& a, int index, int npoints )
+{
+ if ( npoints < 0 )
+ npoints = a.size() - index;
+ if ( index + npoints > (int)a.size() )
+ npoints = a.size() - index;
+ if ( !isActive() || npoints < 1 || index < 0 )
+ return;
+ TQPointArray pa = a;
+ for (int i=0; i<npoints; i++) {
+ TQPoint p( pa[index+i].x(), pa[index+i].y() );
+ drawPoint(p);
+ }
+}
+
+/*!
+ Returns the font info for the painter, if the painter is active.
+ It is not possible to obtain font information for an inactive
+ painter, so the return value is undefined if the painter is not
+ active.
+
+ \sa fontMetrics(), isActive()
+*/
+
+TQFontInfo TQPainter::fontInfo() const
+{
+ printf("[WARNING] TQFontInfo TQPainter::fontInfo() partially implemented!\n\r");
+
+ QFontInfo qfi = QPainter::fontInfo();
+ TQFontInfo tqfi = TQFontInfo(*static_cast<TQFontInfo*>(&qfi));
+ return tqfi;
+
+// if ( pdev && pdev->devType() == TQInternal::Picture )
+// return TQFontInfo( cfont );
+//
+// return TQFontInfo(this);
+}
+
+QT_END_NAMESPACE
+
+#else // USE_QT4
+
+/****************************************************************************
+**
+** Implementation of TQPainter, TQPen and TQBrush classes
+**
+** Created : 940112
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the kernel module of the TQt GUI Toolkit.
+**
+** 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.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file. Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** 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 "tqpainter_p.h"
+#include "tqbitmap.h"
+#include "tqptrstack.h"
+#include "tqptrdict.h"
+#include "tqdatastream.h"
+#include "tqwidget.h"
+#include "tqimage.h"
+#include "tqpaintdevicemetrics.h"
+#include "tqapplication.h"
+#include "tqrichtext_p.h"
+#include "tqregexp.h"
+#include "tqcleanuphandler.h"
+#ifdef TQ_WS_TQWS
+#include "tqgfx_qws.h"
+#endif
+#include <string.h>
+
+#include "tqtextlayout_p.h"
+#include "tqfontengine_p.h"
+
+#ifndef TQT_NO_TRANSFORMATIONS
+typedef TQPtrStack<TQWMatrix> TQWMatrixStack;
+#endif
+
+// POSIX Large File Support redefines truncate -> truncate64
+#if defined(truncate)
+# undef truncate
+#endif
+
+/*!
+ \class TQPainter tqpainter.h
+ \brief The TQPainter class does low-level painting e.g. on widgets.
+
+ \ingroup graphics
+ \ingroup images
+ \mainclass
+
+ The painter provides highly optimized functions to do most of the
+ drawing GUI programs require. TQPainter can draw everything from
+ simple lines to complex tqshapes like pies and chords. It can also
+ draw aligned text and pixmaps. Normally, it draws in a "natural"
+ coordinate system, but it can also do view and world
+ transformation.
+
+ The typical use of a painter is:
+
+ \list
+ \i Construct a painter.
+ \i Set a pen, a brush etc.
+ \i Draw.
+ \i Destroy the painter.
+ \endlist
+
+ Mostly, all this is done inside a paint event. (In fact, 99% of
+ all TQPainter use is in a reimplementation of
+ TQWidget::paintEvent(), and the painter is heavily optimized for
+ such use.) Here's one very simple example:
+
+ \code
+ void SimpleExampleWidget::paintEvent()
+ {
+ TQPainter paint( this );
+ paint.setPen( TQt::blue );
+ paint.drawText( rect(), AlignCenter, "The Text" );
+ }
+ \endcode
+
+ Usage is simple, and there are many settings you can use:
+
+ \list
+
+ \i font() is the currently set font. If you set a font that isn't
+ available, TQt tqfinds a close match. In fact font() returns what
+ you set using setFont() and fontInfo() returns the font actually
+ being used (which may be the same).
+
+ \i brush() is the currently set brush; the color or pattern that's
+ used for filling e.g. circles.
+
+ \i pen() is the currently set pen; the color or stipple that's
+ used for drawing lines or boundaries.
+
+ \i backgroundMode() is \c Opaque or \c Transtqparent, i.e. whether
+ backgroundColor() is used or not.
+
+ \i backgroundColor() only applies when backgroundMode() is Opaque
+ and pen() is a stipple. In that case, it describes the color of
+ the background pixels in the stipple.
+
+ \i rasterOp() is how pixels drawn interact with the pixels already
+ there.
+
+ \i brushOrigin() is the origin of the tiled brushes, normally the
+ origin of the window.
+
+ \i viewport(), window(), tqworldMatrix() and many more make up the
+ painter's coordinate transformation system. See \link
+ coordsys.html The Coordinate System \endlink for an explanation of
+ this, or see below for a very brief overview of the functions.
+
+ \i hasClipping() is whether the painter clips at all. (The paint
+ tqdevice clips, too.) If the painter clips, it clips to clipRegion().
+
+ \i pos() is the current position, set by moveTo() and used by
+ lineTo().
+
+ \endlist
+
+ Note that some of these settings mirror settings in some paint
+ tqdevices, e.g. TQWidget::font(). TQPainter::begin() (or the TQPainter
+ constructor) copies these attributes from the paint tqdevice.
+ Calling, for example, TQWidget::setFont() doesn't take effect until
+ the next time a painter begins painting on it.
+
+ save() saves all of these settings on an internal stack, restore()
+ pops them back.
+
+ The core functionality of TQPainter is drawing, and there are
+ functions to draw most primitives: drawPoint(), drawPoints(),
+ drawLine(), drawRect(), drawWinFocusRect(), drawRoundRect(),
+ drawEllipse(), drawArc(), drawPie(), drawChord(),
+ drawLineSegments(), drawPolyline(), drawPolygon(),
+ drawConvexPolygon() and drawCubicBezier(). All of these functions
+ take integer coordinates; there are no floating-point versions
+ since we want drawing to be as fast as possible.
+
+ There are functions to draw pixmaps/images, namely drawPixmap(),
+ drawImage() and drawTiledPixmap(). drawPixmap() and drawImage()
+ produce the same result, except that drawPixmap() is faster
+ on-screen and drawImage() faster and sometimes better on TQPrinter
+ and TQPicture.
+
+ Text drawing is done using drawText(), and when you need
+ fine-grained positioning, boundingRect() tells you where a given
+ drawText() command would draw.
+
+ There is a drawPicture() function that draws the contents of an
+ entire TQPicture using this painter. drawPicture() is the only
+ function that disregards all the painter's settings: the TQPicture
+ has its own settings.
+
+ Normally, the TQPainter operates on the tqdevice's own coordinate
+ system (usually pixels), but TQPainter has good support for
+ coordinate transformation. See \link coordsys.html The Coordinate
+ System \endlink for a more general overview and a simple example.
+
+ The most common functions used are scale(), rotate(), translate()
+ and shear(), all of which operate on the tqworldMatrix().
+ setWorldMatrix() can tqreplace or add to the currently set
+ tqworldMatrix().
+
+ setViewport() sets the rectangle on which TQPainter operates. The
+ default is the entire tqdevice, which is usually fine, except on
+ printers. setWindow() sets the coordinate system, that is, the
+ rectangle that maps to viewport(). What's drawn inside the
+ window() ends up being inside the viewport(). The window's
+ default is the same as the viewport, and if you don't use the
+ transformations, they are optimized away, gaining another little
+ bit of speed.
+
+ After all the coordinate transformation is done, TQPainter can clip
+ the drawing to an arbitrary rectangle or region. hasClipping() is
+ TRUE if TQPainter clips, and clipRegion() returns the clip region.
+ You can set it using either setClipRegion() or setClipRect().
+ Note that the clipping can be slow. It's all system-dependent,
+ but as a rule of thumb, you can assume that drawing speed is
+ inversely proportional to the number of rectangles in the clip
+ region.
+
+ After TQPainter's clipping, the paint tqdevice may also clip. For
+ example, most widgets clip away the pixels used by child widgets,
+ and most printers clip away an area near the edges of the paper.
+ This additional clipping is not reflected by the return value of
+ clipRegion() or hasClipping().
+
+ TQPainter also includes some less-used functions that are very
+ useful on those occasions when they're needed.
+
+ isActive() indicates whether the painter is active. begin() (and
+ the most usual constructor) makes it active. end() (and the
+ destructor) deactivates it. If the painter is active, tqdevice()
+ returns the paint tqdevice on which the painter paints.
+
+ Sometimes it is desirable to make someone else paint on an unusual
+ TQPaintDevice. TQPainter supports a static function to do this,
+ redirect(). We recommend not using it, but for some hacks it's
+ perfect.
+
+ setTabStops() and setTabArray() can change where the tab stops
+ are, but these are very seldomly used.
+
+ \warning Note that TQPainter does not attempt to work around
+ coordinate limitations in the underlying window system. Some
+ platforms may behave incorrectly with coordinates as small as
+ +/-4000.
+
+ \headerfile tqdrawutil.h
+
+ \sa TQPaintDevice TQWidget TQPixmap TQPrinter TQPicture
+ \link simple-application.html Application Walkthrough \endlink
+ \link coordsys.html Coordinate System Overview \endlink
+*/
+
+/*!
+ \fn TQGfx * TQPainter::internalGfx()
+
+ \internal
+*/
+
+/*!
+ \enum TQPainter::CoordinateMode
+ \value CoordDevice
+ \value CoordPainter
+
+ \sa clipRegion()
+*/
+/*!
+ \enum TQPainter::TextDirection
+ \value Auto
+ \value RTL right to left
+ \value LTR left to right
+
+ \sa drawText()
+*/
+
+/*!
+ \enum TQt::PaintUnit
+ \value PixelUnit
+ \value LoMetricUnit \e obsolete
+ \value HiMetricUnit \e obsolete
+ \value LoEnglishUnit \e obsolete
+ \value HiEnglishUnit \e obsolete
+ \value TwipsUnit \e obsolete
+*/
+
+/*!
+ \enum TQt::BrushStyle
+
+ \value NoBrush
+ \value SolidPattern
+ \value Dense1Pattern
+ \value Dense2Pattern
+ \value Dense3Pattern
+ \value Dense4Pattern
+ \value Dense5Pattern
+ \value Dense6Pattern
+ \value Dense7Pattern
+ \value HorPattern
+ \value VerPattern
+ \value CrossPattern
+ \value BDiagPattern
+ \value FDiagPattern
+ \value DiagCrossPattern
+ \value CustomPattern
+
+ \img brush-styles.png Brush Styles
+
+*/
+
+/*!
+ \enum TQt::RasterOp
+
+ This enum type is used to describe the way things are written to
+ the paint tqdevice. Each bit of the \e src (what you write)
+ interacts with the corresponding bit of the \e dst pixel.
+
+ \value CopyROP dst = src
+ \value OrROP dst = src OR dst
+ \value XorROP dst = src XOR dst
+ \value NotAndROP dst = (NOT src) AND dst
+ \value EraseROP an alias for \c NotAndROP
+ \value NotCopyROP dst = NOT src
+ \value NotOrROP dst = (NOT src) OR dst
+ \value NotXorROP dst = (NOT src) XOR dst
+ \value AndROP dst = src AND dst
+ \value NotEraseROP an alias for \c AndROP
+ \value NotROP dst = NOT dst
+ \value ClearROP dst = 0
+ \value SetROP dst = 1
+ \value NopROP dst = dst
+ \value AndNotROP dst = src AND (NOT dst)
+ \value OrNotROP dst = src OR (NOT dst)
+ \value NandROP dst = NOT (src AND dst)
+ \value NorROP dst = NOT (src OR dst)
+
+ By far the most useful ones are \c CopyROP and \c XorROP.
+
+ On TQt/Embedded, only \c CopyROP, \c XorROP, and \c NotROP are supported.
+*/
+
+/*!
+ \enum TQt::AlignmentFlags
+
+ This enum type is used to describe tqalignment. It tqcontains
+ horizontal and vertical flags.
+
+ The horizontal flags are:
+
+ \value AlignAuto Aligns according to the language. Left for most,
+ right for Arabic and Hebrew.
+ \value AlignLeft Aligns with the left edge.
+ \value AlignRight Aligns with the right edge.
+ \value AlignHCenter Centers horizontally in the available space.
+ \value AlignJustify Justifies the text in the available space.
+ Does not work for everything and may be interpreted as
+ AlignAuto in some cases.
+
+ The vertical flags are:
+
+ \value AlignTop Aligns with the top.
+ \value AlignBottom Aligns with the bottom.
+ \value AlignVCenter Centers vertically in the available space.
+
+ You can use only one of the horizontal flags at a time. There is
+ one two-dimensional flag:
+
+ \value AlignCenter Centers in both dimensions.
+
+ You can use at most one horizontal and one vertical flag at a time. \c
+ AlignCenter counts as both horizontal and vertical.
+
+ Masks:
+
+ \value AlignHorizontal_Mask
+ \value AlignVertical_Mask
+
+ Conflicting combinations of flags have undefined meanings.
+*/
+
+/*!
+ \enum TQt::TextFlags
+
+ This enum type is used to define some modifier flags. Some of
+ these flags only make sense in the context of printing:
+
+ \value SingleLine Treats all whitespace as spaces and prints just
+ one line.
+ \value DontClip If it's impossible to stay within the given bounds,
+ it prints outside.
+ \value ExpandTabs Makes the U+0009 (ASCII tab) character move to
+ the next tab stop.
+ \value ShowPrefix Displays the string "\&P" as <u>P</u>
+ (see TQButton for an example). For an ampersand, use "\&\&".
+ \value WordBreak Breaks lines at appropriate points, e.g. at word
+ boundaries.
+ \value BreakAnywhere Breaks lines anywhere, even within words.
+ \value NoAccel Same as ShowPrefix but doesn't draw the underlines.
+
+ You can use as many modifier flags as you want, except that \c
+ SingleLine and \c WordBreak cannot be combined.
+
+ Flags that are inappropriate for a given use (e.g. ShowPrefix to
+ TQGridLayout::addWidget()) are generally ignored.
+
+*/
+
+/*!
+ \enum TQt::PenStyle
+
+ This enum type defines the pen styles that can be drawn using
+ TQPainter. The styles are
+
+ \value NoPen no line at all. For example, TQPainter::drawRect()
+ fills but does not draw any boundary line.
+
+ \value SolidLine a simple line.
+
+ \value DashLine dashes separated by a few pixels.
+
+ \value DotLine dots separated by a few pixels.
+
+ \value DashDotLine alternate dots and dashes.
+
+ \value DashDotDotLine one dash, two dots, one dash, two dots.
+
+ \value MPenStyle tqmask of the pen styles.
+
+ \img pen-styles.png Pen Styles
+*/
+
+/*!
+ \enum TQt::PenCapStyle
+
+ This enum type defines the pen cap styles supported by TQt, i.e.
+ the line end caps that can be drawn using TQPainter.
+
+ \value FlatCap a square line end that does not cover the end
+ point of the line.
+ \value SquareCap a square line end that covers the end point and
+ extends beyond it with half the line width.
+ \value RoundCap a rounded line end.
+ \value MPenCapStyle tqmask of the pen cap styles.
+
+ \img pen-cap-styles.png Pen Cap Styles
+*/
+
+/*!
+ \enum TQt::PenJoinStyle
+
+ This enum type defines the pen join styles supported by TQt, i.e.
+ which joins between two connected lines can be drawn using
+ TQPainter.
+
+ \value MiterJoin The outer edges of the lines are extended to
+ meet at an angle, and this area is filled.
+ \value BevelJoin The triangular notch between the two lines is filled.
+ \value RoundJoin A circular arc between the two lines is filled.
+ \value MPenJoinStyle tqmask of the pen join styles.
+
+ \img pen-join-styles.png Pen Join Styles
+*/
+
+/*!
+ \enum TQt::BGMode
+
+ Background mode
+
+ \value TransparentMode
+ \value OpaqueMode
+*/
+
+/*!
+ Constructs a painter.
+
+ Notice that all painter settings (setPen, setBrush etc.) are reset
+ to default values when begin() is called.
+
+ \sa begin(), end()
+*/
+
+TQPainter::TQPainter()
+{
+ init();
+}
+
+
+/*!
+ Constructs a painter that begins painting the paint tqdevice \a pd
+ immediately. Depending on the underlying graphic system the
+ painter will paint over tqchildren of the painttqdevice if \a
+ unclipped is TRUE.
+
+ This constructor is convenient for short-lived painters, e.g. in a
+ \link TQWidget::paintEvent() paint event\endlink and should be used
+ only once. The constructor calls begin() for you and the TQPainter
+ destructor automatically calls end().
+
+ Here's an example using begin() and end():
+ \code
+ void MyWidget::paintEvent( TQPaintEvent * )
+ {
+ TQPainter p;
+ p.begin( this );
+ p.drawLine( ... ); // drawing code
+ p.end();
+ }
+ \endcode
+
+ The same example using this constructor:
+ \code
+ void MyWidget::paintEvent( TQPaintEvent * )
+ {
+ TQPainter p( this );
+ p.drawLine( ... ); // drawing code
+ }
+ \endcode
+
+ Since the constructor cannot provide feedback when the initialization
+ of the painter failed you should rather use begin() and end() to paint
+ on external tqdevices, e.g. printers.
+
+ \sa begin(), end()
+*/
+
+TQPainter::TQPainter( const TQPaintDevice *pd, bool unclipped )
+{
+ init();
+ if ( begin( pd, unclipped ) )
+ flags |= CtorBegin;
+}
+
+
+/*!
+ Constructs a painter that begins painting the paint tqdevice \a pd
+ immediately, with the default arguments taken from \a
+ copyAttributes. The painter will paint over tqchildren of the paint
+ tqdevice if \a unclipped is TRUE (although this is not supported on
+ all platforms).
+
+ \sa begin()
+*/
+
+TQPainter::TQPainter( const TQPaintDevice *pd,
+ const TQWidget *copyAttributes, bool unclipped )
+{
+ init();
+ if ( begin( pd, copyAttributes, unclipped ) )
+ flags |= CtorBegin;
+}
+
+
+/*!
+ Destroys the painter.
+*/
+
+TQPainter::~TQPainter()
+{
+ if ( isActive() )
+ end();
+ else
+ killPStack();
+ if ( tabarray ) // delete tab array
+ delete [] tabarray;
+#ifndef TQT_NO_TRANSFORMATIONS
+ if ( wm_stack )
+ delete (TQWMatrixStack *)wm_stack;
+#endif
+ destroy();
+}
+
+
+/*!
+ \overload bool TQPainter::begin( const TQPaintDevice *pd, const TQWidget *copyAttributes, bool unclipped )
+
+ This version opens the painter on a paint tqdevice \a pd and sets
+ the initial pen, background color and font from \a copyAttributes,
+ painting over the paint tqdevice's tqchildren when \a unclipped is
+ TRUE. This is equivalent to:
+
+ \code
+ TQPainter p;
+ p.begin( pd );
+ p.setPen( copyAttributes->foregroundColor() );
+ p.setBackgroundColor( copyAttributes->backgroundColor() );
+ p.setFont( copyAttributes->font() );
+ \endcode
+
+ This begin function is convenient for double buffering. When you
+ draw in a pixmap instead of directly in a widget (to later bitBlt
+ the pixmap into the widget) you will need to set the widget's
+ font etc. This function does exactly that.
+
+ Example:
+ \code
+ void MyWidget::paintEvent( TQPaintEvent * )
+ {
+ TQPixmap pm(size());
+ TQPainter p;
+ p.begin(&pm, this);
+ // ... potentially flickering paint operation ...
+ p.end();
+ bitBlt(this, 0, 0, &pm);
+ }
+ \endcode
+
+ \sa end()
+*/
+
+bool TQPainter::begin( const TQPaintDevice *pd, const TQWidget *copyAttributes, bool unclipped )
+{
+ if ( copyAttributes == 0 ) {
+#if defined(TQT_CHECK_NULL)
+ qWarning( "TQPainter::begin: The widget to copy attributes from cannot "
+ "be null" );
+#endif
+ return FALSE;
+ }
+ if ( begin( pd, unclipped ) ) {
+ setPen( copyAttributes->foregroundColor() );
+ setBackgroundColor( copyAttributes->backgroundColor() );
+ setFont( copyAttributes->font() );
+ return TRUE;
+ }
+ return FALSE;
+}
+
+
+/*!
+ \internal
+ Sets or clears a pointer flag.
+*/
+
+void TQPainter::setf( uint b, bool v )
+{
+ if ( v )
+ setf( b );
+ else
+ clearf( b );
+}
+
+
+/*!
+ \fn bool TQPainter::isActive() const
+
+ Returns TRUE if the painter is active painting, i.e. begin() has
+ been called and end() has not yet been called; otherwise returns
+ FALSE.
+
+ \sa TQPaintDevice::paintingActive()
+*/
+
+/*!
+ \fn TQPaintDevice *TQPainter::tqdevice() const
+
+ Returns the paint tqdevice on which this painter is currently
+ painting, or 0 if the painter is not active.
+
+ \sa TQPaintDevice::paintingActive()
+*/
+
+
+struct TQPState { // painter state
+ TQFont font;
+ TQPen pen;
+ TQPoint curPt;
+ TQBrush brush;
+ TQColor bgc;
+ uchar bgm;
+ uchar rop;
+ TQPoint bro;
+ TQRect wr, vr;
+#ifndef TQT_NO_TRANSFORMATIONS
+ TQWMatrix wm;
+#else
+ int xlatex;
+ int xlatey;
+#endif
+ bool vxf;
+ bool wxf;
+ TQRegion rgn;
+ bool clip;
+ int ts;
+ int *ta;
+ void* wm_stack;
+};
+
+//TODO lose the worldmatrix stack
+
+typedef TQPtrStack<TQPState> TQPStateStack;
+
+
+void TQPainter::killPStack()
+{
+#if defined(TQT_CHECK_STATE)
+ if ( ps_stack && !((TQPStateStack *)ps_stack)->isEmpty() )
+ qWarning( "TQPainter::killPStack: non-empty save/restore stack when "
+ "end() was called" );
+#endif
+ delete (TQPStateStack *)ps_stack;
+ ps_stack = 0;
+}
+
+/*!
+ Saves the current painter state (pushes the state onto a stack). A
+ save() must be followed by a corresponding restore(). end()
+ unwinds the stack.
+
+ \sa restore()
+*/
+
+void TQPainter::save()
+{
+ if ( testf(ExtDev) ) {
+ if ( testf(DirtyFont) )
+ updateFont();
+ if ( testf(DirtyPen) )
+ updatePen();
+ if ( testf(DirtyBrush) )
+ updateBrush();
+ pdev->cmd( TQPaintDevice::PdcSave, this, 0 );
+ }
+ TQPStateStack *pss = (TQPStateStack *)ps_stack;
+ if ( pss == 0 ) {
+ pss = new TQPtrStack<TQPState>;
+ TQ_CHECK_PTR( pss );
+ pss->setAutoDelete( TRUE );
+ ps_stack = pss;
+ }
+ TQPState *ps = new TQPState;
+ TQ_CHECK_PTR( ps );
+ ps->font = cfont;
+ ps->pen = cpen;
+ ps->curPt = pos();
+ ps->brush = cbrush;
+ ps->bgc = bg_col;
+ ps->bgm = bg_mode;
+ ps->rop = rop;
+ ps->bro = bro;
+#ifndef TQT_NO_TRANSFORMATIONS
+ ps->wr = TQRect( wx, wy, ww, wh );
+ ps->vr = TQRect( vx, vy, vw, vh );
+ ps->wm = wxmat;
+ ps->vxf = testf(VxF);
+ ps->wxf = testf(WxF);
+#else
+ ps->xlatex = xlatex;
+ ps->xlatey = xlatey;
+#endif
+ ps->rgn = crgn;
+ ps->clip = testf(ClipOn);
+ ps->ts = tabstops;
+ ps->ta = tabarray;
+ ps->wm_stack = wm_stack;
+ wm_stack = 0;
+ pss->push( ps );
+}
+
+/*!
+ Restores the current painter state (pops a saved state off the
+ stack).
+
+ \sa save()
+*/
+
+void TQPainter::restore()
+{
+ if ( testf(ExtDev) ) {
+ pdev->cmd( TQPaintDevice::PdcRestore, this, 0 );
+ if ( pdev->devType() == TQInternal::Picture )
+ block_ext = TRUE;
+ }
+ TQPStateStack *pss = (TQPStateStack *)ps_stack;
+ if ( pss == 0 || pss->isEmpty() ) {
+#if defined(TQT_CHECK_STATE)
+ qWarning( "TQPainter::restore: Empty stack error" );
+#endif
+ return;
+ }
+ TQPState *ps = pss->pop();
+ bool hardRestore = testf(VolatileDC);
+
+ if ( ps->font != cfont || hardRestore )
+ setFont( ps->font );
+ if ( ps->pen != cpen || hardRestore )
+ setPen( ps->pen );
+ if ( ps->brush != cbrush || hardRestore )
+ setBrush( ps->brush );
+ if ( ps->bgc != bg_col || hardRestore )
+ setBackgroundColor( ps->bgc );
+ if ( ps->bgm != bg_mode || hardRestore )
+ setBackgroundMode( (BGMode)ps->bgm );
+ if ( ps->rop != rop || hardRestore )
+ setRasterOp( (RasterOp)ps->rop );
+ if ( ps->bro != bro || hardRestore )
+ setBrushOrigin( ps->bro );
+#ifndef TQT_NO_TRANSFORMATIONS
+ TQRect wr( wx, wy, ww, wh );
+ TQRect vr( vx, vy, vw, vh );
+ if ( ps->wr != wr || hardRestore )
+ setWindow( ps->wr );
+ if ( ps->vr != vr || hardRestore )
+ setViewport( ps->vr );
+ if ( ps->wm != wxmat || hardRestore )
+ setWorldMatrix( ps->wm );
+ if ( ps->vxf != testf(VxF) || hardRestore )
+ setViewXForm( ps->vxf );
+ if ( ps->wxf != testf(WxF) || hardRestore )
+ setWorldXForm( ps->wxf );
+#else
+ xlatex = ps->xlatex;
+ xlatey = ps->xlatey;
+ setf( VxF, xlatex || xlatey );
+#endif
+ if ( ps->curPt != pos() || hardRestore )
+ moveTo( ps->curPt );
+ if ( ps->rgn != crgn || hardRestore )
+ setClipRegion( ps->rgn );
+ if ( ps->clip != testf(ClipOn) || hardRestore )
+ setClipping( ps->clip );
+ tabstops = ps->ts;
+ tabarray = ps->ta;
+
+#ifndef TQT_NO_TRANSFORMATIONS
+ if ( wm_stack )
+ delete (TQWMatrixStack *)wm_stack;
+ wm_stack = ps->wm_stack;
+#endif
+ delete ps;
+ block_ext = FALSE;
+}
+
+typedef TQPtrDict<TQPaintDevice> TQPaintDeviceDict;
+static TQPaintDeviceDict *pdev_dict = 0;
+
+/*!
+ Redirects all paint commands for a paint tqdevice, \a pdev, to
+ another paint tqdevice, \a tqreplacement, unless \a tqreplacement is 0.
+ If \a tqreplacement is 0, the redirection for \a pdev is removed.
+
+ In general, you'll probably tqfind calling TQPixmap::grabWidget() or
+ TQPixmap::grabWindow() is an easier solution.
+*/
+
+void TQPainter::redirect( TQPaintDevice *pdev, TQPaintDevice *tqreplacement )
+{
+ if ( pdev_dict == 0 ) {
+ if ( tqreplacement == 0 )
+ return;
+ pdev_dict = new TQPaintDeviceDict;
+ TQ_CHECK_PTR( pdev_dict );
+ }
+#if defined(TQT_CHECK_NULL)
+ if ( pdev == 0 )
+ qWarning( "TQPainter::redirect: The pdev argument cannot be 0" );
+#endif
+ if ( tqreplacement ) {
+ pdev_dict->insert( pdev, tqreplacement );
+ } else {
+ pdev_dict->remove( pdev );
+ if ( pdev_dict->count() == 0 ) {
+ delete pdev_dict;
+ pdev_dict = 0;
+ }
+ }
+}
+
+/*!
+ \internal
+ Returns the tqreplacement for \a pdev, or 0 if there is no tqreplacement.
+*/
+TQPaintDevice *TQPainter::redirect( TQPaintDevice *pdev )
+{
+ return pdev_dict ? pdev_dict->tqfind( pdev ) : 0;
+}
+
+/*!
+ Returns the font metrics for the painter, if the painter is
+ active. It is not possible to obtain metrics for an inactive
+ painter, so the return value is undefined if the painter is not
+ active.
+
+ \sa fontInfo(), isActive()
+*/
+
+TQFontMetrics TQPainter::fontMetrics() const
+{
+ if ( pdev && pdev->devType() == TQInternal::Picture )
+ return TQFontMetrics( cfont );
+
+ return TQFontMetrics(this);
+}
+
+/*!
+ Returns the font info for the painter, if the painter is active.
+ It is not possible to obtain font information for an inactive
+ painter, so the return value is undefined if the painter is not
+ active.
+
+ \sa fontMetrics(), isActive()
+*/
+
+TQFontInfo TQPainter::fontInfo() const
+{
+ if ( pdev && pdev->devType() == TQInternal::Picture )
+ return TQFontInfo( cfont );
+
+ return TQFontInfo(this);
+}
+
+
+/*!
+ \fn const TQPen &TQPainter::pen() const
+
+ Returns the painter's current pen.
+
+ \sa setPen()
+*/
+
+/*!
+ Sets a new painter pen.
+
+ The \a pen defines how to draw lines and outlines, and it also
+ defines the text color.
+
+ \sa pen()
+*/
+
+void TQPainter::setPen( const TQPen &pen )
+{
+#if defined(TQT_CHECK_STATE)
+ if ( !isActive() )
+ qWarning( "TQPainter::setPen: Will be reset by begin()" );
+#endif
+ if ( cpen == pen )
+ return;
+ cpen = pen;
+ updatePen();
+}
+
+/*!
+ \overload
+
+ Sets the painter's pen to have style \a style, width 0 and black
+ color.
+
+ \sa pen(), TQPen
+*/
+
+void TQPainter::setPen( PenStyle style )
+{
+#if defined(TQT_CHECK_STATE)
+ if ( !isActive() )
+ qWarning( "TQPainter::setPen: Will be reset by begin()" );
+#endif
+ TQPen::TQPenData *d = cpen.data; // low level access
+ if ( d->style == style && d->linest == style && !d->width && d->color == TQt::black )
+ return;
+ if ( d->count != 1 ) {
+ cpen.detach();
+ d = cpen.data;
+ }
+ d->style = style;
+ d->width = 0;
+ d->color = TQt::black;
+ d->linest = style;
+ updatePen();
+}
+
+/*!
+ \overload
+
+ Sets the painter's pen to have style \c SolidLine, width 0 and the
+ specified \a color.
+
+ \sa pen(), TQPen
+*/
+
+void TQPainter::setPen( const TQColor &color )
+{
+#if defined(TQT_CHECK_STATE)
+ if ( !isActive() )
+ qWarning( "TQPainter::setPen: Will be reset by begin()" );
+#endif
+ TQPen::TQPenData *d = cpen.data; // low level access
+ if ( d->color == color && !d->width && d->style == SolidLine && d->linest == SolidLine )
+ return;
+ if ( d->count != 1 ) {
+ cpen.detach();
+ d = cpen.data;
+ }
+ d->style = SolidLine;
+ d->width = 0;
+ d->color = color;
+ d->linest = SolidLine;
+ updatePen();
+}
+
+/*!
+ \fn const TQBrush &TQPainter::brush() const
+
+ Returns the painter's current brush.
+
+ \sa TQPainter::setBrush()
+*/
+
+/*!
+ \overload
+
+ Sets the painter's brush to \a brush.
+
+ The \a brush defines how tqshapes are filled.
+
+ \sa brush()
+*/
+
+void TQPainter::setBrush( const TQBrush &brush )
+{
+#if defined(TQT_CHECK_STATE)
+ if ( !isActive() )
+ qWarning( "TQPainter::setBrush: Will be reset by begin()" );
+#endif
+ if ( cbrush == brush )
+ return;
+ cbrush = brush;
+ updateBrush();
+}
+
+/*!
+ Sets the painter's brush to black color and the specified \a
+ style.
+
+ \sa brush(), TQBrush
+*/
+
+void TQPainter::setBrush( BrushStyle style )
+{
+#if defined(TQT_CHECK_STATE)
+ if ( !isActive() )
+ qWarning( "TQPainter::setBrush: Will be reset by begin()" );
+#endif
+ TQBrush::TQBrushData *d = cbrush.data; // low level access
+ if ( d->style == style && d->color == TQt::black && !d->pixmap )
+ return;
+ if ( d->count != 1 ) {
+ cbrush.detach();
+ d = cbrush.data;
+ }
+ d->style = style;
+ d->color = TQt::black;
+ if ( d->pixmap ) {
+ delete d->pixmap;
+ d->pixmap = 0;
+ }
+ updateBrush();
+}
+
+/*!
+ \overload
+
+ Sets the painter's brush to have style \c SolidPattern and the
+ specified \a color.
+
+ \sa brush(), TQBrush
+*/
+
+void TQPainter::setBrush( const TQColor &color )
+{
+#if defined(TQT_CHECK_STATE)
+ if ( !isActive() )
+ qWarning( "TQPainter::setBrush: Will be reset by begin()" );
+#endif
+ TQBrush::TQBrushData *d = cbrush.data; // low level access
+ if ( d->color == color && d->style == SolidPattern && !d->pixmap )
+ return;
+ if ( d->count != 1 ) {
+ cbrush.detach();
+ d = cbrush.data;
+ }
+ d->style = SolidPattern;
+ d->color = color;
+ if ( d->pixmap ) {
+ delete d->pixmap;
+ d->pixmap = 0;
+ }
+ updateBrush();
+}
+
+
+/*!
+ \fn const TQColor &TQPainter::backgroundColor() const
+
+ Returns the current background color.
+
+ \sa setBackgroundColor() TQColor
+*/
+
+/*!
+ \fn BGMode TQPainter::backgroundMode() const
+
+ Returns the current background mode.
+
+ \sa setBackgroundMode() BGMode
+*/
+
+/*!
+ \fn RasterOp TQPainter::rasterOp() const
+
+ Returns the current \link TQt::RasterOp raster operation \endlink.
+
+ \sa setRasterOp() RasterOp
+*/
+
+/*!
+ \fn const TQPoint &TQPainter::brushOrigin() const
+
+ Returns the brush origin currently set.
+
+ \sa setBrushOrigin()
+*/
+
+
+/*!
+ \fn int TQPainter::tabStops() const
+
+ Returns the tab stop setting.
+
+ \sa setTabStops()
+*/
+
+/*!
+ Set the tab stop width to \a ts, i.e. locates tab stops at \a ts,
+ 2*\a ts, 3*\a ts and so on.
+
+ Tab stops are used when drawing formatted text with \c ExpandTabs
+ set. This fixed tab stop value is used only if no tab array is set
+ (which is the default case).
+
+ A value of 0 (the default) implies a tabstop setting of 8 times the width of the
+ character 'x' in the font currently set on the painter.
+
+ \sa tabStops(), setTabArray(), drawText(), fontMetrics()
+*/
+
+void TQPainter::setTabStops( int ts )
+{
+#if defined(TQT_CHECK_STATE)
+ if ( !isActive() )
+ qWarning( "TQPainter::setTabStops: Will be reset by begin()" );
+#endif
+ tabstops = ts;
+ if ( isActive() && testf(ExtDev) ) { // tell extended tqdevice
+ TQPDevCmdParam param[1];
+ param[0].ival = ts;
+ pdev->cmd( TQPaintDevice::PdcSetTabStops, this, param );
+ }
+}
+
+/*!
+ \fn int *TQPainter::tabArray() const
+
+ Returns the currently set tab stop array.
+
+ \sa setTabArray()
+*/
+
+/*!
+ Sets the tab stop array to \a ta. This puts tab stops at \a ta[0],
+ \a ta[1] and so on. The array is null-terminated.
+
+ If both a tab array and a tab top size is set, the tab array wins.
+
+ \sa tabArray(), setTabStops(), drawText(), fontMetrics()
+*/
+
+void TQPainter::setTabArray( int *ta )
+{
+#if defined(TQT_CHECK_STATE)
+ if ( !isActive() )
+ qWarning( "TQPainter::setTabArray: Will be reset by begin()" );
+#endif
+ if ( ta != tabarray ) {
+ tabarraylen = 0;
+ if ( tabarray ) // Avoid purify complaint
+ delete [] tabarray; // delete old array
+ if ( ta ) { // tabarray = copy of 'ta'
+ while ( ta[tabarraylen] )
+ tabarraylen++;
+ tabarraylen++; // and 0 terminator
+ tabarray = new int[tabarraylen]; // duplicate ta
+ memcpy( tabarray, ta, sizeof(int)*tabarraylen );
+ } else {
+ tabarray = 0;
+ }
+ }
+ if ( isActive() && testf(ExtDev) ) { // tell extended tqdevice
+ TQPDevCmdParam param[2];
+ param[0].ival = tabarraylen;
+ param[1].ivec = tabarray;
+ pdev->cmd( TQPaintDevice::PdcSetTabArray, this, param );
+ }
+}
+
+
+/*!
+ \fn HANDLE TQPainter::handle() const
+
+ Returns the platform-dependent handle used for drawing. Using this
+ function is not portable.
+*/
+
+
+/*****************************************************************************
+ TQPainter xform settings
+ *****************************************************************************/
+
+#ifndef TQT_NO_TRANSFORMATIONS
+
+/*!
+ Enables view transformations if \a enable is TRUE, or disables
+ view transformations if \a enable is FALSE.
+
+ \sa hasViewXForm(), setWindow(), setViewport(), setWorldMatrix(),
+ setWorldXForm(), xForm()
+*/
+
+void TQPainter::setViewXForm( bool enable )
+{
+#if defined(TQT_CHECK_STATE)
+ if ( !isActive() )
+ qWarning( "TQPainter::setViewXForm: Will be reset by begin()" );
+#endif
+ if ( !isActive() || enable == testf(VxF) )
+ return;
+ setf( VxF, enable );
+ if ( testf(ExtDev) ) {
+ TQPDevCmdParam param[1];
+ param[0].ival = enable;
+ pdev->cmd( TQPaintDevice::PdcSetVXform, this, param );
+ }
+ updateXForm();
+}
+
+/*!
+ \fn bool TQPainter::hasViewXForm() const
+
+ Returns TRUE if view transformation is enabled; otherwise returns
+ FALSE.
+
+ \sa setViewXForm(), xForm()
+*/
+
+/*!
+ Returns the window rectangle.
+
+ \sa setWindow(), setViewXForm()
+*/
+
+TQRect TQPainter::window() const
+{
+ return TQRect( wx, wy, ww, wh );
+}
+
+/*!
+ Sets the window rectangle view transformation for the painter and
+ enables view transformation.
+
+ The window rectangle is part of the view transformation. The
+ window specifies the logical coordinate system and is specified by
+ the \a x, \a y, \a w width and \a h height parameters. Its sister,
+ the viewport(), specifies the tqdevice coordinate system.
+
+ The default window rectangle is the same as the tqdevice's
+ rectangle. See the \link coordsys.html Coordinate System Overview
+ \endlink for an overview of coordinate transformation.
+
+ \sa window(), setViewport(), setViewXForm(), setWorldMatrix(),
+ setWorldXForm()
+*/
+
+void TQPainter::setWindow( int x, int y, int w, int h )
+{
+#if defined(TQT_CHECK_STATE)
+ if ( !isActive() )
+ qWarning( "TQPainter::setWindow: Will be reset by begin()" );
+#endif
+ wx = x;
+ wy = y;
+ ww = w;
+ wh = h;
+ if ( testf(ExtDev) ) {
+ TQRect r( x, y, w, h );
+ TQPDevCmdParam param[1];
+ param[0].rect = (TQRect*)&r;
+ pdev->cmd( TQPaintDevice::PdcSetWindow, this, param );
+ }
+ if ( testf(VxF) )
+ updateXForm();
+ else
+ setViewXForm( TRUE );
+}
+
+/*!
+ Returns the viewport rectangle.
+
+ \sa setViewport(), setViewXForm()
+*/
+
+TQRect TQPainter::viewport() const // get viewport
+{
+ return TQRect( vx, vy, vw, vh );
+}
+
+/*!
+ Sets the viewport rectangle view transformation for the painter
+ and enables view transformation.
+
+ The viewport rectangle is part of the view transformation. The
+ viewport specifies the tqdevice coordinate system and is specified
+ by the \a x, \a y, \a w width and \a h height parameters. Its
+ sister, the window(), specifies the logical coordinate system.
+
+ The default viewport rectangle is the same as the tqdevice's
+ rectangle. See the \link coordsys.html Coordinate System Overview
+ \endlink for an overview of coordinate transformation.
+
+ \sa viewport(), setWindow(), setViewXForm(), setWorldMatrix(),
+ setWorldXForm(), xForm()
+*/
+
+void TQPainter::setViewport( int x, int y, int w, int h )
+{
+#if defined(TQT_CHECK_STATE)
+ if ( !isActive() )
+ qWarning( "TQPainter::setViewport: Will be reset by begin()" );
+#endif
+ vx = x;
+ vy = y;
+ vw = w;
+ vh = h;
+ if ( testf(ExtDev) ) {
+ TQRect r( x, y, w, h );
+ TQPDevCmdParam param[1];
+ param[0].rect = (TQRect*)&r;
+ pdev->cmd( TQPaintDevice::PdcSetViewport, this, param );
+ }
+ if ( testf(VxF) )
+ updateXForm();
+ else
+ setViewXForm( TRUE );
+}
+
+
+/*!
+ Enables world transformations if \a enable is TRUE, or disables
+ world transformations if \a enable is FALSE. The world
+ transformation matrix is not changed.
+
+ \sa setWorldMatrix(), setWindow(), setViewport(), setViewXForm(),
+ xForm()
+*/
+
+void TQPainter::setWorldXForm( bool enable )
+{
+#if defined(TQT_CHECK_STATE)
+ if ( !isActive() )
+ qWarning( "TQPainter::setWorldXForm: Will be reset by begin()" );
+#endif
+ if ( !isActive() || enable == testf(WxF) )
+ return;
+ setf( WxF, enable );
+ if ( testf(ExtDev) && !block_ext ) {
+ TQPDevCmdParam param[1];
+ param[0].ival = enable;
+ pdev->cmd( TQPaintDevice::PdcSetWXform, this, param );
+ }
+ updateXForm();
+}
+
+/*!
+ \fn bool TQPainter::hasWorldXForm() const
+
+ Returns TRUE if world transformation is enabled; otherwise returns
+ FALSE.
+
+ \sa setWorldXForm()
+*/
+
+/*!
+ Returns the world transformation matrix.
+
+ \sa setWorldMatrix()
+*/
+
+const TQWMatrix &TQPainter::tqworldMatrix() const
+{
+ return wxmat;
+}
+
+/*!
+ Sets the world transformation matrix to \a m and enables world
+ transformation.
+
+ If \a combine is TRUE, then \a m is combined with the current
+ transformation matrix, otherwise \a m tqreplaces the current
+ transformation matrix.
+
+ If \a m is the identity matrix and \a combine is FALSE, this
+ function calls setWorldXForm(FALSE). (The identity matrix is the
+ matrix where TQWMatrix::m11() and TQWMatrix::m22() are 1.0 and the
+ rest are 0.0.)
+
+ World transformations are applied after the view transformations
+ (i.e. \link setWindow() window\endlink and \link setViewport()
+ viewport\endlink).
+
+ The following functions can transform the coordinate system without using
+ a TQWMatrix:
+ \list
+ \i translate()
+ \i scale()
+ \i shear()
+ \i rotate()
+ \endlist
+
+ They operate on the painter's tqworldMatrix() and are implemented like this:
+
+ \code
+ void TQPainter::rotate( double a )
+ {
+ TQWMatrix m;
+ m.rotate( a );
+ setWorldMatrix( m, TRUE );
+ }
+ \endcode
+
+ Note that you should always use \a combine when you are drawing
+ into a TQPicture. Otherwise it may not be possible to replay the
+ picture with additional transformations. Using translate(),
+ scale(), etc., is safe.
+
+ For a brief overview of coordinate transformation, see the \link
+ coordsys.html Coordinate System Overview. \endlink
+
+ \sa tqworldMatrix() setWorldXForm() setWindow() setViewport()
+ setViewXForm() xForm() TQWMatrix
+*/
+
+void TQPainter::setWorldMatrix( const TQWMatrix &m, bool combine )
+{
+ if ( !isActive() ) {
+#if defined(TQT_CHECK_STATE)
+ qWarning( "TQPainter::setWorldMatrix: Will be reset by begin()" );
+#endif
+ return;
+ }
+ if ( combine )
+ wxmat = m * wxmat; // combines
+ else
+ wxmat = m; // set new matrix
+ bool identity = wxmat.m11() == 1.0F && wxmat.m22() == 1.0F &&
+ wxmat.m12() == 0.0F && wxmat.m21() == 0.0F &&
+ wxmat.dx() == 0.0F && wxmat.dy() == 0.0F;
+ if ( testf(ExtDev) && !block_ext ) {
+ TQPDevCmdParam param[2];
+ param[0].matrix = &m;
+ param[1].ival = combine;
+ pdev->cmd( TQPaintDevice::PdcSetWMatrix, this, param );
+ }
+ if ( identity && pdev->devType() != TQInternal::Picture )
+ setWorldXForm( FALSE );
+ else if ( !testf(WxF) )
+ setWorldXForm( TRUE );
+ else
+ updateXForm();
+}
+
+/*! \obsolete
+
+ We recommend using save() instead.
+*/
+
+void TQPainter::saveWorldMatrix()
+{
+ TQWMatrixStack *stack = (TQWMatrixStack *)wm_stack;
+ if ( stack == 0 ) {
+ stack = new TQPtrStack<TQWMatrix>;
+ TQ_CHECK_PTR( stack );
+ stack->setAutoDelete( TRUE );
+ wm_stack = stack;
+ }
+
+ stack->push( new TQWMatrix( wxmat ) );
+
+}
+
+/*! \obsolete
+ We recommend using restore() instead.
+*/
+
+void TQPainter::restoreWorldMatrix()
+{
+ TQWMatrixStack *stack = (TQWMatrixStack *)wm_stack;
+ if ( stack == 0 || stack->isEmpty() ) {
+#if defined(TQT_CHECK_STATE)
+ qWarning( "TQPainter::restoreWorldMatrix: Empty stack error" );
+#endif
+ return;
+ }
+ TQWMatrix* m = stack->pop();
+ setWorldMatrix( *m );
+ delete m;
+}
+
+#endif // TQT_NO_TRANSFORMATIONS
+
+/*!
+ Translates the coordinate system by \a (dx, dy). After this call,
+ \a (dx, dy) is added to points.
+
+ For example, the following code draws the same point twice:
+ \code
+ void MyWidget::paintEvent()
+ {
+ TQPainter paint( this );
+
+ paint.drawPoint( 0, 0 );
+
+ paint.translate( 100.0, 40.0 );
+ paint.drawPoint( -100, -40 );
+ }
+ \endcode
+
+ \sa scale(), shear(), rotate(), resetXForm(), setWorldMatrix(), xForm()
+*/
+
+void TQPainter::translate( double dx, double dy )
+{
+#ifndef TQT_NO_TRANSFORMATIONS
+ TQWMatrix m;
+ m.translate( dx, dy );
+ setWorldMatrix( m, TRUE );
+#else
+ xlatex += (int)dx;
+ xlatey += (int)dy;
+ setf( VxF, xlatex || xlatey );
+#endif
+}
+
+
+#ifndef TQT_NO_TRANSFORMATIONS
+/*!
+ Scales the coordinate system by \a (sx, sy).
+
+ \sa translate(), shear(), rotate(), resetXForm(), setWorldMatrix(),
+ xForm()
+*/
+
+void TQPainter::scale( double sx, double sy )
+{
+ TQWMatrix m;
+ m.scale( sx, sy );
+ setWorldMatrix( m, TRUE );
+}
+
+/*!
+ Shears the coordinate system by \a (sh, sv).
+
+ \sa translate(), scale(), rotate(), resetXForm(), setWorldMatrix(),
+ xForm()
+*/
+
+void TQPainter::shear( double sh, double sv )
+{
+ TQWMatrix m;
+ m.shear( sv, sh );
+ setWorldMatrix( m, TRUE );
+}
+
+/*!
+ Rotates the coordinate system \a a degrees counterclockwise.
+
+ \sa translate(), scale(), shear(), resetXForm(), setWorldMatrix(),
+ xForm()
+*/
+
+void TQPainter::rotate( double a )
+{
+ TQWMatrix m;
+ m.rotate( a );
+ setWorldMatrix( m, TRUE );
+}
+
+
+/*!
+ Resets any transformations that were made using translate(), scale(),
+ shear(), rotate(), setWorldMatrix(), setViewport() and
+ setWindow().
+
+ \sa tqworldMatrix(), viewport(), window()
+*/
+
+void TQPainter::resetXForm()
+{
+ if ( !isActive() )
+ return;
+ wx = wy = vx = vy = 0; // default view origins
+ ww = vw = pdev->metric( TQPaintDeviceMetrics::PdmWidth );
+ wh = vh = pdev->metric( TQPaintDeviceMetrics::PdmHeight );
+ wxmat = TQWMatrix();
+ setWorldXForm( FALSE );
+ setViewXForm( FALSE );
+}
+
+/*!
+ \internal
+ Updates an internal integer transformation matrix.
+*/
+
+void TQPainter::updateXForm()
+{
+ TQWMatrix m;
+ if ( testf(VxF) ) {
+ double scaleW = (double)vw/(double)ww;
+ double scaleH = (double)vh/(double)wh;
+ m.setMatrix( scaleW, 0, 0, scaleH, vx - wx*scaleW, vy - wy*scaleH );
+ }
+ if ( testf(WxF) ) {
+ if ( testf(VxF) )
+ m = wxmat * m;
+ else
+ m = wxmat;
+ }
+ xmat = m;
+
+ txinv = FALSE; // no inverted matrix
+ txop = TxNone;
+ if ( m12()==0.0 && m21()==0.0 && m11() >= 0.0 && m22() >= 0.0 ) {
+ if ( m11()==1.0 && m22()==1.0 ) {
+ if ( dx()!=0.0 || dy()!=0.0 )
+ txop = TxTranslate;
+ } else {
+ txop = TxScale;
+#if defined(TQ_WS_WIN)
+ setf(DirtyFont);
+#endif
+ }
+ } else {
+ txop = TxRotShear;
+#if defined(TQ_WS_WIN)
+ setf(DirtyFont);
+#endif
+ }
+}
+
+
+/*!
+ \internal
+ Updates an internal integer inverse transformation matrix.
+*/
+
+void TQPainter::updateInvXForm()
+{
+#if defined(TQT_CHECK_STATE)
+ TQ_ASSERT( txinv == FALSE );
+#endif
+ txinv = TRUE; // creating inverted matrix
+ bool invertible;
+ TQWMatrix m;
+ if ( testf(VxF) ) {
+ m.translate( vx, vy );
+ m.scale( 1.0*vw/ww, 1.0*vh/wh );
+ m.translate( -wx, -wy );
+ }
+ if ( testf(WxF) ) {
+ if ( testf(VxF) )
+ m = wxmat * m;
+ else
+ m = wxmat;
+ }
+ ixmat = m.invert( &invertible ); // invert matrix
+}
+
+#else
+void TQPainter::resetXForm()
+{
+ xlatex = 0;
+ xlatey = 0;
+ clearf( VxF );
+}
+#endif // TQT_NO_TRANSFORMATIONS
+
+
+extern bool qt_old_transformations;
+
+/*!
+ \internal
+ Maps a point from logical coordinates to tqdevice coordinates.
+*/
+
+void TQPainter::map( int x, int y, int *rx, int *ry ) const
+{
+#ifndef TQT_NO_TRANSFORMATIONS
+ if ( qt_old_transformations ) {
+ switch ( txop ) {
+ case TxNone:
+ *rx = x; *ry = y;
+ break;
+ case TxTranslate:
+ // #### "Why no rounding here?", Warwick asked of Haavard.
+ *rx = int(x + dx());
+ *ry = int(y + dy());
+ break;
+ case TxScale: {
+ double tx = m11()*x + dx();
+ double ty = m22()*y + dy();
+ *rx = tx >= 0 ? int(tx + 0.5) : int(tx - 0.5);
+ *ry = ty >= 0 ? int(ty + 0.5) : int(ty - 0.5);
+ } break;
+ default: {
+ double tx = m11()*x + m21()*y+dx();
+ double ty = m12()*x + m22()*y+dy();
+ *rx = tx >= 0 ? int(tx + 0.5) : int(tx - 0.5);
+ *ry = ty >= 0 ? int(ty + 0.5) : int(ty - 0.5);
+ } break;
+ }
+ } else {
+ switch ( txop ) {
+ case TxNone:
+ *rx = x;
+ *ry = y;
+ break;
+ case TxTranslate:
+ *rx = tqRound( x + dx() );
+ *ry = tqRound( y + dy() );
+ break;
+ case TxScale:
+ *rx = tqRound( m11()*x + dx() );
+ *ry = tqRound( m22()*y + dy() );
+ break;
+ default:
+ *rx = tqRound( m11()*x + m21()*y+dx() );
+ *ry = tqRound( m12()*x + m22()*y+dy() );
+ break;
+ }
+ }
+#else
+ *rx = x + xlatex;
+ *ry = y + xlatey;
+#endif
+}
+
+/*!
+ \internal
+ Maps a rectangle from logical coordinates to tqdevice coordinates.
+ This internal function does not handle rotation and/or shear.
+*/
+
+void TQPainter::map( int x, int y, int w, int h,
+ int *rx, int *ry, int *rw, int *rh ) const
+{
+#ifndef TQT_NO_TRANSFORMATIONS
+ if ( qt_old_transformations ) {
+ switch ( txop ) {
+ case TxNone:
+ *rx = x; *ry = y;
+ *rw = w; *rh = h;
+ break;
+ case TxTranslate:
+ // #### "Why no rounding here?", Warwick asked of Haavard.
+ *rx = int(x + dx());
+ *ry = int(y + dy());
+ *rw = w; *rh = h;
+ break;
+ case TxScale: {
+ double tx1 = m11()*x + dx();
+ double ty1 = m22()*y + dy();
+ double tx2 = m11()*(x + w - 1) + dx();
+ double ty2 = m22()*(y + h - 1) + dy();
+ *rx = tqRound( tx1 );
+ *ry = tqRound( ty1 );
+ *rw = tqRound( tx2 ) - *rx + 1;
+ *rh = tqRound( ty2 ) - *ry + 1;
+ } break;
+ default:
+#if defined(TQT_CHECK_STATE)
+ qWarning( "TQPainter::map: Internal error" );
+#endif
+ break;
+ }
+ } else {
+ switch ( txop ) {
+ case TxNone:
+ *rx = x; *ry = y;
+ *rw = w; *rh = h;
+ break;
+ case TxTranslate:
+ *rx = tqRound(x + dx() );
+ *ry = tqRound(y + dy() );
+ *rw = w; *rh = h;
+ break;
+ case TxScale:
+ *rx = tqRound( m11()*x + dx() );
+ *ry = tqRound( m22()*y + dy() );
+ *rw = tqRound( m11()*w );
+ *rh = tqRound( m22()*h );
+ break;
+ default:
+#if defined(TQT_CHECK_STATE)
+ qWarning( "TQPainter::map: Internal error" );
+#endif
+ break;
+ }
+ }
+#else
+ *rx = x + xlatex;
+ *ry = y + xlatey;
+ *rw = w; *rh = h;
+#endif
+}
+
+/*!
+ \internal
+ Maps a point from tqdevice coordinates to logical coordinates.
+*/
+
+void TQPainter::mapInv( int x, int y, int *rx, int *ry ) const
+{
+#ifndef TQT_NO_TRANSFORMATIONS
+#if defined(TQT_CHECK_STATE)
+ if ( !txinv )
+ qWarning( "TQPainter::mapInv: Internal error" );
+#endif
+ if ( qt_old_transformations ) {
+ double tx = im11()*x + im21()*y+idx();
+ double ty = im12()*x + im22()*y+idy();
+ *rx = tx >= 0 ? int(tx + 0.5) : int(tx - 0.5);
+ *ry = ty >= 0 ? int(ty + 0.5) : int(ty - 0.5);
+ } else {
+ *rx = tqRound( im11()*x + im21()*y + idx() );
+ *ry = tqRound( im12()*x + im22()*y + idy() );
+ }
+#else
+ *rx = x - xlatex;
+ *ry = y - xlatey;
+#endif
+}
+
+/*!
+ \internal
+ Maps a rectangle from tqdevice coordinates to logical coordinates.
+ Cannot handle rotation and/or shear.
+*/
+
+void TQPainter::mapInv( int x, int y, int w, int h,
+ int *rx, int *ry, int *rw, int *rh ) const
+{
+#ifndef TQT_NO_TRANSFORMATIONS
+#if defined(TQT_CHECK_STATE)
+ if ( !txinv || txop == TxRotShear )
+ qWarning( "TQPainter::mapInv: Internal error" );
+#endif
+ if ( qt_old_transformations ) {
+ double tx = im11()*x + idx();
+ double ty = im22()*y + idy();
+ double tw = im11()*w;
+ double th = im22()*h;
+ *rx = tx >= 0 ? int(tx + 0.5) : int(tx - 0.5);
+ *ry = ty >= 0 ? int(ty + 0.5) : int(ty - 0.5);
+ *rw = tw >= 0 ? int(tw + 0.5) : int(tw - 0.5);
+ *rh = th >= 0 ? int(th + 0.5) : int(th - 0.5);
+ } else {
+ *rx = tqRound( im11()*x + idx() );
+ *ry = tqRound( im22()*y + idy() );
+ *rw = tqRound( im11()*w );
+ *rh = tqRound( im22()*h );
+ }
+#else
+ *rx = x - xlatex;
+ *ry = y - xlatey;
+ *rw = w;
+ *rh = h;
+#endif
+}
+
+
+/*!
+ Returns the point \a pv transformed from model coordinates to
+ tqdevice coordinates.
+
+ \sa xFormDev(), TQWMatrix::map()
+*/
+
+TQPoint TQPainter::xForm( const TQPoint &pv ) const
+{
+#ifndef TQT_NO_TRANSFORMATIONS
+ if ( txop == TxNone )
+ return pv;
+ int x=pv.x(), y=pv.y();
+ map( x, y, &x, &y );
+ return TQPoint( x, y );
+#else
+ return TQPoint( pv.x()+xlatex, pv.y()+xlatey );
+#endif
+}
+
+/*!
+ \overload
+
+ Returns the rectangle \a rv transformed from model coordinates to
+ tqdevice coordinates.
+
+ If world transformation is enabled and rotation or shearing has
+ been specified, then the bounding rectangle is returned.
+
+ \sa xFormDev(), TQWMatrix::map()
+*/
+
+TQRect TQPainter::xForm( const TQRect &rv ) const
+{
+#ifndef TQT_NO_TRANSFORMATIONS
+ if ( txop == TxNone )
+ return rv;
+ if ( txop == TxRotShear ) { // rotation/shear
+ return xmat.mapRect( rv );
+ }
+ // Just translation/scale
+ int x, y, w, h;
+ rv.rect( &x, &y, &w, &h );
+ map( x, y, w, h, &x, &y, &w, &h );
+ return TQRect( x, y, w, h );
+#else
+ return TQRect( rv.x()+xlatex, rv.y()+xlatey, rv.width(), rv.height() );
+#endif
+}
+
+/*!
+ \overload
+
+ Returns the point array \a av transformed from model coordinates
+ to tqdevice coordinates.
+
+ \sa xFormDev(), TQWMatrix::map()
+*/
+
+TQPointArray TQPainter::xForm( const TQPointArray &av ) const
+{
+ TQPointArray a = av;
+#ifndef TQT_NO_TRANSFORMATIONS
+ if ( txop != TxNone )
+ {
+ return xmat * av;
+ }
+#else
+ a.translate( xlatex, xlatey );
+#endif
+ return a;
+}
+
+/*!
+ \overload
+
+ Returns the point array \a av transformed from model coordinates
+ to tqdevice coordinates. The \a index is the first point in the
+ array and \a npoints denotes the number of points to be
+ transformed. If \a npoints is negative, all points from \a
+ av[index] until the last point in the array are transformed.
+
+ The returned point array consists of the number of points that
+ were transformed.
+
+ Example:
+ \code
+ TQPointArray a(10);
+ TQPointArray b;
+ b = painter.xForm(a, 2, 4); // b.size() == 4
+ b = painter.xForm(a, 2, -1); // b.size() == 8
+ \endcode
+
+ \sa xFormDev(), TQWMatrix::map()
+*/
+
+TQPointArray TQPainter::xForm( const TQPointArray &av, int index,
+ int npoints ) const
+{
+ int lastPoint = npoints < 0 ? av.size() : index+npoints;
+ TQPointArray a( lastPoint-index );
+ memcpy( a.data(), av.data()+index, (lastPoint-index)*sizeof( TQPoint ) );
+#ifndef TQT_NO_TRANSFORMATIONS
+ return xmat*a;
+#else
+ a.translate( xlatex, xlatey );
+ return a;
+#endif
+}
+
+/*!
+ \overload
+
+ Returns the point \a pd transformed from tqdevice coordinates to
+ model coordinates.
+
+ \sa xForm(), TQWMatrix::map()
+*/
+
+TQPoint TQPainter::xFormDev( const TQPoint &pd ) const
+{
+#ifndef TQT_NO_TRANSFORMATIONS
+ if ( txop == TxNone )
+ return pd;
+ if ( !txinv ) {
+ TQPainter *that = (TQPainter*)this; // mutable
+ that->updateInvXForm();
+ }
+#endif
+ int x=pd.x(), y=pd.y();
+ mapInv( x, y, &x, &y );
+ return TQPoint( x, y );
+}
+
+/*!
+ Returns the rectangle \a rd transformed from tqdevice coordinates to
+ model coordinates.
+
+ If world transformation is enabled and rotation or shearing is
+ used, then the bounding rectangle is returned.
+
+ \sa xForm(), TQWMatrix::map()
+*/
+
+TQRect TQPainter::xFormDev( const TQRect &rd ) const
+{
+#ifndef TQT_NO_TRANSFORMATIONS
+ if ( txop == TxNone )
+ return rd;
+ if ( !txinv ) {
+ TQPainter *that = (TQPainter*)this; // mutable
+ that->updateInvXForm();
+ }
+ if ( txop == TxRotShear ) { // rotation/shear
+ return ixmat.mapRect( rd );
+ }
+#endif
+ // Just translation/scale
+ int x, y, w, h;
+ rd.rect( &x, &y, &w, &h );
+ mapInv( x, y, w, h, &x, &y, &w, &h );
+ return TQRect( x, y, w, h );
+}
+
+/*!
+ \overload
+
+ Returns the point array \a ad transformed from tqdevice coordinates
+ to model coordinates.
+
+ \sa xForm(), TQWMatrix::map()
+*/
+
+TQPointArray TQPainter::xFormDev( const TQPointArray &ad ) const
+{
+#ifndef TQT_NO_TRANSFORMATIONS
+ if ( txop == TxNone )
+ return ad;
+ if ( !txinv ) {
+ TQPainter *that = (TQPainter*)this; // mutable
+ that->updateInvXForm();
+ }
+ return ixmat * ad;
+#else
+ // ###
+ return ad;
+#endif
+}
+
+/*!
+ \overload
+
+ Returns the point array \a ad transformed from tqdevice coordinates
+ to model coordinates. The \a index is the first point in the array
+ and \a npoints denotes the number of points to be transformed. If
+ \a npoints is negative, all points from \a ad[index] until the
+ last point in the array are transformed.
+
+ The returned point array consists of the number of points that
+ were transformed.
+
+ Example:
+ \code
+ TQPointArray a(10);
+ TQPointArray b;
+ b = painter.xFormDev(a, 1, 3); // b.size() == 3
+ b = painter.xFormDev(a, 1, -1); // b.size() == 9
+ \endcode
+
+ \sa xForm(), TQWMatrix::map()
+*/
+
+TQPointArray TQPainter::xFormDev( const TQPointArray &ad, int index,
+ int npoints ) const
+{
+ int lastPoint = npoints < 0 ? ad.size() : index+npoints;
+ TQPointArray a( lastPoint-index );
+ memcpy( a.data(), ad.data()+index, (lastPoint-index)*sizeof( TQPoint ) );
+#ifndef TQT_NO_TRANSFORMATIONS
+ if ( txop == TxNone )
+ return a;
+ if ( !txinv ) {
+ TQPainter *that = (TQPainter*)this; // mutable
+ that->updateInvXForm();
+ }
+ return ixmat * a;
+#else
+ // ###
+ return a;
+#endif
+}
+
+
+/*!
+ Fills the rectangle \a (x, y, w, h) with the \a brush.
+
+ You can specify a TQColor as \a brush, since there is a TQBrush
+ constructor that takes a TQColor argument and creates a solid
+ pattern brush.
+
+ \sa drawRect()
+*/
+
+void TQPainter::fillRect( int x, int y, int w, int h, const TQBrush &brush )
+{
+ TQPen oldPen = pen(); // save pen
+ TQBrush oldBrush = this->brush(); // save brush
+ setPen( NoPen );
+ setBrush( brush );
+ drawRect( x, y, w, h ); // draw filled rect
+ setBrush( oldBrush ); // restore brush
+ setPen( oldPen ); // restore pen
+}
+
+
+/*!
+ \overload void TQPainter::setBrushOrigin( const TQPoint &p )
+
+ Sets the brush origin to point \a p.
+*/
+
+/*!
+ \overload void TQPainter::setWindow( const TQRect &r )
+
+ Sets the painter's window to rectangle \a r.
+*/
+
+
+/*!
+ \overload void TQPainter::setViewport( const TQRect &r )
+
+ Sets the painter's viewport to rectangle \a r.
+*/
+
+
+/*!
+ \fn bool TQPainter::hasClipping() const
+
+ Returns TRUE if clipping has been set; otherwise returns FALSE.
+
+ \sa setClipping()
+*/
+
+/*!
+ Returns the currently set clip region. Note that the clip region
+ is given in physical tqdevice coordinates and \e not subject to any
+ \link coordsys.html coordinate transformation \endlink if \a m is
+ equal to \c CoordDevice (the default). If \a m equals \c
+ CoordPainter the returned region is in model coordinates.
+
+ \sa setClipRegion(), setClipRect(), setClipping() TQPainter::CoordinateMode
+*/
+TQRegion TQPainter::clipRegion( CoordinateMode m ) const
+{
+ // ### FIXME in 4.0:
+ // If the transformation mode is CoordPainter, we should transform the
+ // clip region with painter transformations.
+
+#ifndef TQT_NO_TRANSFORMATIONS
+ TQRegion r;
+ if ( m == CoordDevice ) {
+ r = crgn;
+ } else {
+ if ( !txinv ) {
+ TQPainter *that = (TQPainter*)this; // mutable
+ that->updateInvXForm();
+ }
+
+ r = ixmat * crgn;
+ }
+ return r;
+#else
+ return crgn;
+#endif
+}
+
+/*!
+ \fn void TQPainter::setClipRect( int x, int y, int w, int h, CoordinateMode m)
+
+ Sets the clip region to the rectangle \a x, \a y, \a w, \a h and
+ enables clipping. The clip mode is set to \a m.
+
+ If \a m is \c CoordDevice (the default), the coordinates given for
+ the clip region are taken to be physical tqdevice coordinates and
+ are \e not subject to any \link coordsys.html coordinate
+ transformations\endlink. If \a m is \c CoordPainter, the
+ coordinates given for the clip region are taken to be model
+ coordinates.
+
+ \sa setClipRegion(), clipRegion(), setClipping() TQPainter::CoordinateMode
+*/
+
+/*!
+ \overload void TQPainter::drawPoint( const TQPoint &p )
+
+ Draws the point \a p.
+*/
+
+
+/*!
+ \overload void TQPainter::moveTo( const TQPoint &p )
+
+ Moves to the point \a p.
+*/
+
+/*!
+ \overload void TQPainter::lineTo( const TQPoint &p )
+
+ Draws a line to the point \a p.
+*/
+
+/*!
+ \overload void TQPainter::drawLine( const TQPoint &p1, const TQPoint &p2 )
+
+ Draws a line from point \a p1 to point \a p2.
+*/
+
+/*!
+ \overload void TQPainter::drawRect( const TQRect &r )
+
+ Draws the rectangle \a r.
+*/
+
+/*!
+ \overload void TQPainter::drawWinFocusRect( const TQRect &r )
+
+ Draws rectangle \a r as a window focus rectangle.
+*/
+
+/*!
+ \overload void TQPainter::drawWinFocusRect( const TQRect &r, const TQColor &bgColor )
+
+ Draws rectangle \a r as a window focus rectangle using background
+ color \a bgColor.
+*/
+
+
+#if !defined(TQ_WS_X11) && !defined(TQ_WS_TQWS) && !defined(TQ_WS_MAC)
+// The doc and X implementation of this functions is in qpainter_x11.cpp
+void TQPainter::drawWinFocusRect( int, int, int, int,
+ bool, const TQColor & )
+{
+ // do nothing, only called from X11 specific functions
+}
+#endif
+
+
+/*!
+ \overload void TQPainter::drawRoundRect( const TQRect &r, int xRnd, int yRnd )
+
+ Draws a rounded rectangle \a r, rounding to the x position \a xRnd
+ and the y position \a yRnd on each corner.
+*/
+
+/*!
+ \overload void TQPainter::drawEllipse( const TQRect &r )
+
+ Draws the ellipse that fits inside rectangle \a r.
+*/
+
+/*!
+ \overload void TQPainter::drawArc( const TQRect &r, int a, int alen )
+
+ Draws the arc that fits inside the rectangle \a r with start angle
+ \a a and arc length \a alen.
+*/
+
+/*!
+ \overload void TQPainter::drawPie( const TQRect &r, int a, int alen )
+
+ Draws a pie segment that fits inside the rectangle \a r with start
+ angle \a a and arc length \a alen.
+*/
+
+/*!
+ \overload void TQPainter::drawChord( const TQRect &r, int a, int alen )
+
+ Draws a chord that fits inside the rectangle \a r with start angle
+ \a a and arc length \a alen.
+*/
+
+/*!
+ \overload void TQPainter::drawPixmap( const TQPoint &p, const TQPixmap &pm, const TQRect &sr )
+
+ Draws the rectangle \a sr of pixmap \a pm with its origin at point
+ \a p.
+*/
+
+/*!
+ \overload void TQPainter::drawPixmap( const TQPoint &p, const TQPixmap &pm )
+
+ Draws the pixmap \a pm with its origin at point \a p.
+*/
+
+void TQPainter::drawPixmap( const TQPoint &p, const TQPixmap &pm )
+{
+ drawPixmap( p.x(), p.y(), pm, 0, 0, pm.width(), pm.height() );
+}
+
+#if !defined(TQT_NO_IMAGE_SMOOTHSCALE) || !defined(TQT_NO_PIXMAP_TRANSFORMATION)
+
+/*!
+ \overload
+
+ Draws the pixmap \a pm into the rectangle \a r. The pixmap is
+ scaled to fit the rectangle, if image and rectangle size disagree.
+*/
+void TQPainter::drawPixmap( const TQRect &r, const TQPixmap &pm )
+{
+ int rw = r.width();
+ int rh = r.height();
+ int iw= pm.width();
+ int ih = pm.height();
+ if ( rw <= 0 || rh <= 0 || iw <= 0 || ih <= 0 )
+ return;
+ bool scale = ( rw != iw || rh != ih );
+ float scaleX = (float)rw/(float)iw;
+ float scaleY = (float)rh/(float)ih;
+ bool smooth = ( scaleX < 1.5 || scaleY < 1.5 );
+
+ if ( testf(ExtDev) ) {
+ TQPDevCmdParam param[2];
+ param[0].rect = &r;
+ param[1].pixmap = &pm;
+#if defined(TQ_WS_WIN)
+ if ( !pdev->cmd( TQPaintDevice::PdcDrawPixmap, this, param ) || !hdc )
+ return;
+#elif defined(TQ_WS_TQWS)
+ pdev->cmd( TQPaintDevice::PdcDrawPixmap, this, param );
+ return;
+#elif defined(TQ_WS_MAC)
+ if ( !pdev->cmd( TQPaintDevice::PdcDrawPixmap, this, param ) || !pdev->handle())
+ return;
+#else
+ if ( !pdev->cmd( TQPaintDevice::PdcDrawPixmap, this, param ) || !hd )
+ return;
+#endif
+ }
+
+ TQPixmap pixmap = pm;
+
+ if ( scale ) {
+#ifndef TQT_NO_IMAGE_SMOOTHSCALE
+# ifndef TQT_NO_PIXMAP_TRANSFORMATION
+ if ( smooth )
+# endif
+ {
+ TQImage i = pm.convertToImage();
+ pixmap = TQPixmap( i.smoothScale( rw, rh ) );
+ }
+# ifndef TQT_NO_PIXMAP_TRANSFORMATION
+ else
+# endif
+#endif
+#ifndef TQT_NO_PIXMAP_TRANSFORMATION
+ {
+ pixmap = pm.xForm( TQWMatrix( scaleX, 0, 0, scaleY, 0, 0 ) );
+ }
+#endif
+ }
+ drawPixmap( r.x(), r.y(), pixmap );
+}
+
+#endif
+
+/*!
+ \overload void TQPainter::drawImage( const TQPoint &, const TQImage &, const TQRect &sr, int conversionFlags = 0 );
+
+ Draws the rectangle \a sr from the image at the given point.
+*/
+
+/*
+ Draws at point \a p the \sr rect from image \a pm, using \a
+ conversionFlags if the image needs to be converted to a pixmap.
+ The default value for \a conversionFlags is 0; see
+ convertFromImage() for information about what other values do.
+
+ This function may convert \a image to a pixmap and then draw it, if
+ tqdevice() is a TQPixmap or a TQWidget, or else draw it directly, if
+ tqdevice() is a TQPrinter or TQPicture.
+*/
+
+/*!
+ Draws at (\a x, \a y) the \a sw by \a sh area of pixels from (\a
+ sx, \a sy) in \a image, using \a conversionFlags if the image
+ needs to be converted to a pixmap. The default value for \a
+ conversionFlags is 0; see convertFromImage() for information about
+ what other values do.
+
+ This function may convert \a image to a pixmap and then draw it,
+ if tqdevice() is a TQPixmap or a TQWidget, or else draw it directly,
+ if tqdevice() is a TQPrinter or TQPicture.
+
+ Currently alpha masks of the image are ignored when painting on a TQPrinter.
+
+ \sa drawPixmap() TQPixmap::convertFromImage()
+*/
+void TQPainter::drawImage( int x, int y, const TQImage & image,
+ int sx, int sy, int sw, int sh,
+ int conversionFlags )
+{
+#ifdef TQ_WS_TQWS
+ //### Hackish
+# ifndef TQT_NO_TRANSFORMATIONS
+ if ( !image.isNull() && gfx &&
+ (txop==TxNone||txop==TxTranslate) && !testf(ExtDev) )
+# else
+ if ( !image.isNull() && gfx && !testf(ExtDev) )
+# endif
+ {
+ if(sw<0)
+ sw=image.width();
+ if(sh<0)
+ sh=image.height();
+
+ TQImage image2 = qt_screen->mapToDevice( image );
+
+ // This is a bit dubious
+ if(image2.depth()==1) {
+ image2.setNumColors( 2 );
+ image2.setColor( 0, tqRgb(255,255,255) );
+ image2.setColor( 1, tqRgb(0,0,0) );
+ }
+ if ( image2.hasAlphaBuffer() )
+ gfx->setAlphaType(TQGfx::InlineAlpha);
+ else
+ gfx->setAlphaType(TQGfx::IgnoreAlpha);
+ gfx->setSource(&image2);
+ if ( testf(VxF|WxF) ) {
+ map( x, y, &x, &y );
+ }
+ gfx->blt(x,y,sw,sh,sx,sy);
+ return;
+ }
+#endif
+
+ if ( !isActive() || image.isNull() )
+ return;
+
+ // right/bottom
+ if ( sw < 0 )
+ sw = image.width() - sx;
+ if ( sh < 0 )
+ sh = image.height() - sy;
+
+ // Sanity-check clipping
+ if ( sx < 0 ) {
+ x -= sx;
+ sw += sx;
+ sx = 0;
+ }
+ if ( sw + sx > image.width() )
+ sw = image.width() - sx;
+ if ( sy < 0 ) {
+ y -= sy;
+ sh += sy;
+ sy = 0;
+ }
+ if ( sh + sy > image.height() )
+ sh = image.height() - sy;
+
+ if ( sw <= 0 || sh <= 0 )
+ return;
+
+ bool all = image.rect().intersect(TQRect(sx,sy,sw,sh)) == image.rect();
+ TQImage subimage = all ? image : image.copy(sx,sy,sw,sh);
+
+ if ( testf(ExtDev) ) {
+ TQPDevCmdParam param[2];
+ TQRect r( x, y, subimage.width(), subimage.height() );
+ param[0].rect = &r;
+ param[1].image = &subimage;
+#if defined(TQ_WS_WIN)
+ if ( !pdev->cmd( TQPaintDevice::PdcDrawImage, this, param ) || !hdc )
+ return;
+#elif defined (TQ_WS_TQWS)
+ pdev->cmd( TQPaintDevice::PdcDrawImage, this, param );
+ return;
+#elif defined(TQ_WS_MAC)
+ if(!pdev->cmd( TQPaintDevice::PdcDrawImage, this, param ) || !pdev->handle() )
+ return;
+#else
+ if ( !pdev->cmd( TQPaintDevice::PdcDrawImage, this, param ) || !hd )
+ return;
+#endif
+ }
+
+ TQPixmap pm;
+ pm.convertFromImage( subimage, conversionFlags );
+ drawPixmap( x, y, pm );
+}
+
+/*!
+ \overload void TQPainter::drawImage( const TQPoint &p, const TQImage &i, int conversion_flags )
+
+ Draws the image \a i at point \a p.
+
+ If the image needs to be modified to fit in a lower-resolution
+ result (e.g. converting from 32-bit to 8-bit), use the \a
+ conversion_flags to specify how you'd prefer this to happen.
+
+ \sa TQt::ImageConversionFlags
+*/
+void TQPainter::drawImage( const TQPoint & p, const TQImage & i,
+ int conversion_flags )
+{
+ drawImage(p, i, i.rect(), conversion_flags);
+}
+
+#if !defined(TQT_NO_IMAGE_TRANSFORMATION) || !defined(TQT_NO_IMAGE_SMOOTHSCALE)
+
+/*!
+ \overload
+
+ Draws the image \a i into the rectangle \a r. The image will be
+ scaled to fit the rectangle if image and rectangle dimensions
+ differ.
+*/
+void TQPainter::drawImage( const TQRect &r, const TQImage &i )
+{
+ int rw = r.width();
+ int rh = r.height();
+ int iw= i.width();
+ int ih = i.height();
+ if ( rw <= 0 || rh <= 0 || iw <= 0 || ih <= 0 )
+ return;
+
+ if ( testf(ExtDev) ) {
+ TQPDevCmdParam param[2];
+ param[0].rect = &r;
+ param[1].image = &i;
+#if defined(TQ_WS_WIN)
+ if ( !pdev->cmd( TQPaintDevice::PdcDrawImage, this, param ) || !hdc )
+ return;
+#elif defined(TQ_WS_TQWS)
+ pdev->cmd( TQPaintDevice::PdcDrawImage, this, param );
+ return;
+#elif defined(TQ_WS_MAC)
+ if ( !pdev->cmd( TQPaintDevice::PdcDrawImage, this, param ) || !pdev->handle() )
+ return;
+#else
+ if ( !pdev->cmd( TQPaintDevice::PdcDrawImage, this, param ) || !hd )
+ return;
+#endif
+ }
+
+
+ bool scale = ( rw != iw || rh != ih );
+ float scaleX = (float)rw/(float)iw;
+ float scaleY = (float)rh/(float)ih;
+ bool smooth = ( scaleX < 1.5 || scaleY < 1.5 );
+
+ TQImage img = scale
+ ? (
+#if defined(TQT_NO_IMAGE_TRANSFORMATION)
+ i.smoothScale( rw, rh )
+#elif defined(TQT_NO_IMAGE_SMOOTHSCALE)
+ i.scale( rw, rh )
+#else
+ smooth ? i.smoothScale( rw, rh ) : i.scale( rw, rh )
+#endif
+ )
+ : i;
+
+ drawImage( r.x(), r.y(), img );
+}
+
+#endif
+
+
+void bitBlt( TQPaintDevice *dst, int dx, int dy,
+ const TQImage *src, int sx, int sy, int sw, int sh,
+ int conversion_flags )
+{
+ TQPixmap tmp;
+ if ( sx == 0 && sy == 0
+ && (sw<0 || sw==src->width()) && (sh<0 || sh==src->height()) )
+ {
+ tmp.convertFromImage( *src, conversion_flags );
+ } else {
+ tmp.convertFromImage( src->copy( sx, sy, sw, sh, conversion_flags),
+ conversion_flags );
+ }
+ bitBlt( dst, dx, dy, &tmp );
+}
+
+
+/*!
+ \overload void TQPainter::drawTiledPixmap( const TQRect &r, const TQPixmap &pm, const TQPoint &sp )
+
+ Draws a tiled pixmap, \a pm, inside rectangle \a r with its origin
+ at point \a sp.
+*/
+
+/*!
+ \overload void TQPainter::drawTiledPixmap( const TQRect &r, const TQPixmap &pm )
+
+ Draws a tiled pixmap, \a pm, inside rectangle \a r.
+*/
+
+/*!
+ \overload void TQPainter::fillRect( const TQRect &r, const TQBrush &brush )
+
+ Fills the rectangle \a r using brush \a brush.
+*/
+
+/*!
+ \fn void TQPainter::eraseRect( int x, int y, int w, int h )
+
+ Erases the area inside \a x, \a y, \a w, \a h. Equivalent to
+ \c{fillRect( x, y, w, h, backgroundColor() )}.
+*/
+
+/*!
+ \overload void TQPainter::eraseRect( const TQRect &r )
+
+ Erases the area inside the rectangle \a r.
+*/
+
+/*!
+ \fn TQPainter::drawText( int x, int y, const TQString &, int len = -1, TextDirection dir = Auto )
+
+ \overload
+
+ Draws the given text at position \a x, \a y. If \a len is -1 (the
+ default) all the text is drawn, otherwise the first \a len
+ characters are drawn. The text's direction is given by \a dir.
+
+ \sa TQPainter::TextDirection
+*/
+
+/*!
+ \fn void TQPainter::drawText( int x, int y, int w, int h, int flags,
+ const TQString&, int len = -1, TQRect *br=0,
+ TQTextParag **internal=0 )
+
+ \overload
+
+ Draws the given text within the rectangle starting at \a x, \a y,
+ with width \a w and height \a h. If \a len is -1 (the default) all
+ the text is drawn, otherwise the first \a len characters are
+ drawn. The text's flags that are given in the \a flags parameter
+ are \l{TQt::AlignmentFlags} and \l{TQt::TextFlags} OR'd together. \a
+ br (if not null) is set to the actual bounding rectangle of the
+ output. The \a internal parameter is for internal use only.
+*/
+
+/*!
+ \fn void TQPainter::drawText( const TQPoint &, const TQString &, int len = -1, TextDirection dir = Auto );
+
+ \overload
+
+ Draws the text at the given point.
+
+ \sa TQPainter::TextDirection
+*/
+
+/*
+ Draws the text in \a s at point \a p. If \a len is -1 the entire
+ string is drawn, otherwise just the first \a len characters. The
+ text's direction is specified by \a dir.
+*/
+
+
+/*!
+ \fn void TQPainter::drawText( int x, int y, const TQString &, int pos, int len, TextDirection dir = Auto );
+
+ \overload
+
+ Draws the text from position \a pos, at point \a (x, y). If \a len is
+ -1 the entire string is drawn, otherwise just the first \a len
+ characters. The text's direction is specified by \a dir.
+*/
+
+/*!
+ \fn void TQPainter::drawText( const TQPoint &p, const TQString &, int pos, int len, TextDirection dir = Auto );
+
+ Draws the text from position \a pos, at point \a p. If \a len is
+ -1 the entire string is drawn, otherwise just the first \a len
+ characters. The text's direction is specified by \a dir.
+
+ Note that the meaning of \e y is not the same for the two
+ drawText() varieties. For overloads that take a simple \e x, \e y
+ pair (or a point), the \e y value is the text's baseline; for
+ overloads that take a rectangle, \e rect.y() is the top of the
+ rectangle and the text is aligned within that rectangle in
+ accordance with the tqalignment flags.
+
+ \sa TQPainter::TextDirection
+*/
+
+/*!
+ \fn void TQPainter::tqdrawTextItem(const TQPoint &, const TQTextItem &, int)
+ \internal
+*/
+
+static inline void fix_neg_rect( int *x, int *y, int *w, int *h )
+{
+ if ( *w < 0 ) {
+ *w = -*w + 2;
+ *x -= *w - 1;
+ }
+ if ( *h < 0 ) {
+ *h = -*h + 2;
+ *y -= *h - 1;
+ }
+}
+void TQPainter::fix_neg_rect( int *x, int *y, int *w, int *h )
+{
+ ::fix_neg_rect(x,y,w,h);
+}
+
+//
+// The drawText function takes two special parameters; 'internal' and 'brect'.
+//
+// The 'internal' parameter tqcontains a pointer to an array of encoded
+// information that keeps internal tqgeometry data.
+// If the drawText function is called repeatedly to display the same text,
+// it makes sense to calculate text width and linebreaks the first time,
+// and use these parameters later to print the text because we save a lot of
+// CPU time.
+// The 'internal' parameter will not be used if it is a null pointer.
+// The 'internal' parameter will be generated if it is not null, but points
+// to a null pointer, i.e. internal != 0 && *internal == 0.
+// The 'internal' parameter will be used if it tqcontains a non-null pointer.
+//
+// If the 'brect parameter is a non-null pointer, then the bounding rectangle
+// of the text will be returned in 'brect'.
+//
+
+/*!
+ \overload
+
+ Draws at most \a len characters from \a str in the rectangle \a r.
+
+ This function draws formatted text. The \a tf text format is
+ really of type \l TQt::AlignmentFlags and \l TQt::TextFlags OR'd
+ together.
+
+ Horizontal tqalignment defaults to AlignAuto and vertical tqalignment
+ defaults to AlignTop.
+
+ \a brect (if not null) is set to the actual bounding rectangle of
+ the output. \a internal is, yes, internal.
+
+ \sa boundingRect()
+*/
+
+void TQPainter::drawText( const TQRect &r, int tf,
+ const TQString& str, int len, TQRect *brect,
+ TQTextParag **internal )
+{
+ if ( !isActive() )
+ return;
+ if ( len < 0 )
+ len = str.length();
+ if ( len == 0 ) // empty string
+ return;
+
+ if ( testf(DirtyFont|ExtDev) ) {
+ if ( testf(DirtyFont) )
+ updateFont();
+ if ( testf(ExtDev) && (tf & DontPrint) == 0 ) {
+ TQPDevCmdParam param[3];
+ TQString newstr = str;
+ newstr.truncate( len );
+ param[0].rect = &r;
+ param[1].ival = tf;
+ param[2].str = &newstr;
+ if ( pdev->devType() != TQInternal::Printer ) {
+#if defined(TQ_WS_WIN)
+ if ( !pdev->cmd( TQPaintDevice::PdcDrawText2Formatted,
+ this, param) ||
+ !hdc )
+ return; // TQPrinter wants PdcDrawText2
+#elif defined(TQ_WS_TQWS)
+ pdev->cmd( TQPaintDevice::PdcDrawText2Formatted, this, param);
+ return;
+#elif defined(TQ_WS_MAC)
+ if ( !pdev->cmd( TQPaintDevice::PdcDrawText2Formatted, this, param) ||
+ !pdev->handle())
+ return; // TQPrinter wants PdcDrawText2
+#else
+ if ( !pdev->cmd( TQPaintDevice::PdcDrawText2Formatted,
+ this, param) ||
+ !hd )
+ return; // TQPrinter wants PdcDrawText2
+#endif
+ }
+ }
+ }
+
+ qt_format_text(font(), r, tf, str, len, brect,
+ tabstops, tabarray, tabarraylen, internal, this);
+}
+
+//#define TQT_FORMAT_TEXT_DEBUG
+
+#define TQChar_linesep TQChar(0x2028U)
+
+void qt_format_text( const TQFont& font, const TQRect &_r,
+ int tf, const TQString& str, int len, TQRect *brect,
+ int tabstops, int* tabarray, int tabarraylen,
+ TQTextParag **, TQPainter* painter )
+{
+ // we need to copy r here to protect against the case (&r == brect).
+ TQRect r( _r );
+
+ bool dontclip = (tf & TQt::DontClip) == TQt::DontClip;
+ bool wordbreak = (tf & TQt::WordBreak) == TQt::WordBreak;
+ bool singleline = (tf & TQt::SingleLine) == TQt::SingleLine;
+ bool showprefix = (tf & TQt::ShowPrefix) == TQt::ShowPrefix;
+ bool noaccel = ( tf & TQt::NoAccel ) == TQt::NoAccel;
+
+ bool isRightToLeft = str.isRightToLeft();
+ if ( ( tf & TQt::AlignHorizontal_Mask ) == TQt::AlignAuto )
+ tf |= isRightToLeft ? TQt::AlignRight : TQt::AlignLeft;
+
+ bool expandtabs = ( (tf & TQt::ExpandTabs) &&
+ ( ( (tf & TQt::AlignLeft) && !isRightToLeft ) ||
+ ( (tf & TQt::AlignRight) && isRightToLeft ) ) );
+
+ if ( !painter )
+ tf |= TQt::DontPrint;
+
+ int maxUnderlines = 0;
+ int numUnderlines = 0;
+ int underlinePositionStack[32];
+ int *underlinePositions = underlinePositionStack;
+
+ TQFont fnt(painter ? (painter->pfont ? *painter->pfont : painter->cfont) : font);
+ TQFontMetrics fm( fnt );
+
+ TQString text = str;
+ // str.setLength() always does a deep copy, so the tqreplacement
+ // code below is safe.
+ text.setLength( len );
+ // compatible behaviour to the old implementation. Replace
+ // tabs by spaces
+ TQChar *chr = (TQChar*)text.tqunicode();
+ const TQChar *end = chr + len;
+ bool haveLineSep = FALSE;
+ while ( chr != end ) {
+ if ( *chr == '\r' || ( singleline && *chr == '\n' ) ) {
+ *chr = ' ';
+ } else if ( *chr == '\n' ) {
+ *chr = TQChar_linesep;
+ haveLineSep = TRUE;
+ } else if ( *chr == '&' ) {
+ ++maxUnderlines;
+ }
+ ++chr;
+ }
+ if ( !expandtabs ) {
+ chr = (TQChar*)text.tqunicode();
+ while ( chr != end ) {
+ if ( *chr == '\t' )
+ *chr = ' ';
+ ++chr;
+ }
+ } else if (!tabarraylen && !tabstops) {
+ tabstops = fm.width('x')*8;
+ }
+
+ if ( noaccel || showprefix ) {
+ if ( maxUnderlines > 32 )
+ underlinePositions = new int[maxUnderlines];
+ TQChar *cout = (TQChar*)text.tqunicode();
+ TQChar *cin = cout;
+ int l = len;
+ while ( l ) {
+ if ( *cin == '&' ) {
+ ++cin;
+ --l;
+ if ( !l )
+ break;
+ if ( *cin != '&' )
+ underlinePositions[numUnderlines++] = cout - text.tqunicode();
+ }
+ *cout = *cin;
+ ++cout;
+ ++cin;
+ --l;
+ }
+ uint newlen = cout - text.tqunicode();
+ if ( newlen != text.length())
+ text.setLength( newlen );
+ }
+
+ // no need to do extra work for underlines if we don't paint
+ if ( tf & TQt::DontPrint )
+ numUnderlines = 0;
+
+ int height = 0;
+ int left = r.width();
+ int right = 0;
+
+ TQTextLayout textLayout( text, fnt );
+ int rb = TQMAX( 0, -fm.minRightBearing() );
+ int lb = TQMAX( 0, -fm.minLeftBearing() );
+
+ if ( text.isEmpty() ) {
+ height = fm.height();
+ left = right = 0;
+ tf |= TQPainter::DontPrint;
+ } else {
+ textLayout.beginLayout((haveLineSep || expandtabs || wordbreak) ?
+ TQTextLayout::MultiLine :
+ (tf & TQt::DontPrint) ? TQTextLayout::NoBidi : TQTextLayout::SingleLine );
+
+ // break underline chars into items of their own
+ for( int i = 0; i < numUnderlines; i++ ) {
+ textLayout.setBoundary( underlinePositions[i] );
+ textLayout.setBoundary( underlinePositions[i]+1 );
+ }
+
+ int lineWidth = wordbreak ? TQMAX(0, r.width()-rb-lb) : INT_MAX;
+ if(!wordbreak)
+ tf |= TQt::IncludeTrailingSpaces;
+
+ int leading = fm.leading();
+ int asc = fm.ascent();
+ int desc = fm.descent();
+ height = -leading;
+
+ //qDebug("\n\nbeginLayout: lw = %d, rectwidth=%d", lineWidth , r.width());
+ while ( !textLayout.atEnd() ) {
+ height += leading;
+ textLayout.beginLine( lineWidth == INT_MAX ? lineWidth : lineWidth );
+ //qDebug("-----beginLine( %d )-----", lineWidth );
+ bool linesep = FALSE;
+ while ( 1 ) {
+ TQTextItem ti = textLayout.currentItem();
+ //qDebug("item: from=%d, ch=%x", ti.from(), text.tqunicode()[ti.from()].tqunicode() );
+ if ( expandtabs && ti.isTab() ) {
+ int tw = 0;
+ int x = textLayout.widthUsed();
+ if ( tabarraylen ) {
+// qDebug("tabarraylen=%d", tabarraylen );
+ int tab = 0;
+ while ( tab < tabarraylen ) {
+ if ( tabarray[tab] > x ) {
+ tw = tabarray[tab] - x;
+ break;
+ }
+ ++tab;
+ }
+ } else {
+ tw = tabstops - (x % tabstops);
+ }
+ //qDebug("tw = %d", tw );
+ if ( tw )
+ ti.setWidth( tw );
+ }
+ if ( ti.isObject() && text.tqunicode()[ti.from()] == TQChar_linesep )
+ linesep = TRUE;
+
+ if ( linesep || textLayout.addCurrentItem() != TQTextLayout::Ok || textLayout.atEnd() )
+ break;
+ }
+
+ int ascent = asc, descent = desc, lineLeft, lineRight;
+ textLayout.setLineWidth( r.width()-rb-lb );
+ textLayout.endLine( 0, height, tf, &ascent, &descent,
+ &lineLeft, &lineRight );
+ //qDebug("finalizing line: lw=%d ascent = %d, descent=%d lineleft=%d lineright=%d", lineWidth, ascent, descent,lineLeft, lineRight );
+ left = TQMIN( left, lineLeft );
+ right = TQMAX( right, lineRight );
+ height += ascent + descent + 1;
+ if ( linesep )
+ textLayout.nextItem();
+ }
+ }
+
+ int yoff = 0;
+ if ( tf & TQt::AlignBottom )
+ yoff = r.height() - height;
+ else if ( tf & TQt::AlignVCenter )
+ yoff = (r.height() - height)/2;
+
+ if ( brect ) {
+ *brect = TQRect( r.x() + left, r.y() + yoff, right-left + lb+rb, height );
+ //qDebug("br = %d %d %d/%d, left=%d, right=%d", brect->x(), brect->y(), brect->width(), brect->height(), left, right);
+ }
+
+ if (!(tf & TQPainter::DontPrint)) {
+ bool restoreClipping = FALSE;
+ bool painterHasClip = FALSE;
+ TQRegion painterClipRegion;
+ if ( !dontclip ) {
+#ifndef TQT_NO_TRANSFORMATIONS
+ TQRegion reg = painter->xmat * r;
+#else
+ TQRegion reg = r;
+ reg.translate( painter->xlatex, painter->xlatey );
+#endif
+ if ( painter->hasClipping() )
+ reg &= painter->clipRegion();
+
+ painterHasClip = painter->hasClipping();
+ painterClipRegion = painter->clipRegion();
+ restoreClipping = TRUE;
+ painter->setClipRegion( reg );
+ } else {
+ if ( painter->hasClipping() ){
+ painterHasClip = painter->hasClipping();
+ painterClipRegion = painter->clipRegion();
+ restoreClipping = TRUE;
+ painter->setClipping( FALSE );
+ }
+ }
+
+ int cUlChar = 0;
+ int _tf = 0;
+ if (fnt.underline()) _tf |= TQt::Underline;
+ if (fnt.overline()) _tf |= TQt::Overline;
+ if (fnt.strikeOut()) _tf |= TQt::StrikeOut;
+
+ //qDebug("have %d items",textLayout.numItems());
+ for ( int i = 0; i < textLayout.numItems(); i++ ) {
+ TQTextItem ti = textLayout.itemAt( i );
+ //qDebug("Item %d: from=%d, length=%d, space=%d x=%d", i, ti.from(), ti.length(), ti.isSpace(), ti.x() );
+ if ( ti.isTab() || ti.isObject() )
+ continue;
+ int textFlags = _tf;
+ if ( !noaccel && numUnderlines > cUlChar && ti.from() == underlinePositions[cUlChar] ) {
+ textFlags |= TQt::Underline;
+ cUlChar++;
+ }
+#if defined(TQ_WS_X11) || defined(TQ_WS_TQWS)
+ if ( painter->bg_mode == TQt::OpaqueMode ) {
+ int h = ti.ascent() + ti.descent() + 1;
+ if (ti.y() + h < height)
+ // don't add leading to last line
+ h += fm.leading();
+ qt_draw_background( painter, r.x()+lb + ti.x(), r.y() + yoff + ti.y() - ti.ascent(),
+ ti.width(), h);
+ }
+#endif
+ painter->tqdrawTextItem( r.x()+lb, r.y() + yoff, ti, textFlags );
+ }
+
+ if ( restoreClipping ) {
+ painter->setClipRegion( painterClipRegion );
+ painter->setClipping( painterHasClip );
+ }
+ }
+
+ if ( underlinePositions != underlinePositionStack )
+ delete [] underlinePositions;
+}
+
+/*!
+ \overload
+
+ Returns the bounding rectangle of the aligned text that would be
+ printed with the corresponding drawText() function using the first
+ \a len characters from \a str if \a len is > -1, or the whole of
+ \a str if \a len is -1. The drawing, and hence the bounding
+ rectangle, is constrained to the rectangle \a r, or to the
+ rectangle required to draw the text, whichever is the larger.
+
+ The \a internal parameter should not be used.
+
+ \sa drawText(), fontMetrics(), TQFontMetrics::boundingRect(), TQt::TextFlags
+*/
+
+TQRect TQPainter::boundingRect( const TQRect &r, int flags,
+ const TQString& str, int len, TQTextParag **internal )
+{
+ TQRect brect;
+ if ( str.isEmpty() )
+ brect.setRect( r.x(),r.y(), 0,0 );
+ else
+ drawText( r, flags | DontPrint, str, len, &brect, internal );
+ return brect;
+}
+
+/*!
+ \fn TQRect TQPainter::boundingRect( int x, int y, int w, int h, int flags, const TQString&, int len = -1, TQTextParag **intern=0 );
+
+ Returns the bounding rectangle of the aligned text that would be
+ printed with the corresponding drawText() function using the first
+ \a len characters of the string if \a len is > -1, or the whole of
+ the string if \a len is -1. The drawing, and hence the bounding
+ rectangle, is constrained to the rectangle that begins at point \a
+ (x, y) with width \a w and hight \a h, or to the
+ rectangle required to draw the text, whichever is the larger.
+
+ The \a flags argument is
+ the bitwise OR of the following flags:
+ \table
+ \header \i Flag \i Meaning
+ \row \i \c AlignAuto \i aligns according to the language, usually left.
+ \row \i \c AlignLeft \i aligns to the left border.
+ \row \i \c AlignRight \i aligns to the right border.
+ \row \i \c AlignHCenter \i aligns horizontally centered.
+ \row \i \c AlignTop \i aligns to the top border.
+ \row \i \c AlignBottom \i aligns to the bottom border.
+ \row \i \c AlignVCenter \i aligns vertically centered.
+ \row \i \c AlignCenter \i (== \c AlignHCenter | \c AlignVCenter).
+ \row \i \c SingleLine \i ignores newline characters in the text.
+ \row \i \c ExpandTabs \i expands tabs.
+ \row \i \c ShowPrefix \i interprets "&x" as "<u>x</u>".
+ \row \i \c WordBreak \i breaks the text to fit the rectangle.
+ \endtable
+
+ Horizontal tqalignment defaults to \c AlignLeft and vertical
+ tqalignment defaults to \c AlignTop.
+
+ If several of the horizontal or several of the vertical tqalignment flags
+ are set, the resulting tqalignment is undefined.
+
+ The \a intern parameter should not be used.
+
+ \sa TQt::TextFlags
+*/
+
+
+
+/*****************************************************************************
+ TQPen member functions
+ *****************************************************************************/
+
+/*!
+ \class TQPen tqpen.h
+ \brief The TQPen class defines how a TQPainter should draw lines and outlines
+ of tqshapes.
+
+ \ingroup graphics
+ \ingroup images
+ \ingroup shared
+ \mainclass
+
+ A pen has a style, width, color, cap style and join style.
+
+ The pen style defines the line type. The default pen style is \c
+ TQt::SolidLine. Setting the style to \c NoPen tells the painter to
+ not draw lines or outlines.
+
+ When drawing 1 pixel wide diagonal lines you can either use a very
+ fast algorithm (specified by a line width of 0, which is the
+ default), or a slower but more accurate algorithm (specified by a
+ line width of 1). For horizontal and vertical lines a line width
+ of 0 is the same as a line width of 1. The cap and join style have
+ no effect on 0-width lines.
+
+ The pen color defines the color of lines and text. The default
+ line color is black. The TQColor documentation lists predefined
+ colors.
+
+ The cap style defines how the end points of lines are drawn. The
+ join style defines how the joins between two lines are drawn when
+ multiple connected lines are drawn (TQPainter::drawPolyline()
+ etc.). The cap and join styles only apply to wide lines, i.e. when
+ the width is 1 or greater.
+
+ Use the TQBrush class to specify fill styles.
+
+ Example:
+ \code
+ TQPainter painter;
+ TQPen pen( red, 2 ); // red solid line, 2 pixels wide
+ painter.begin( &anyPaintDevice ); // paint something
+ painter.setPen( pen ); // set the red, wide pen
+ painter.drawRect( 40,30, 200,100 ); // draw a rectangle
+ painter.setPen( blue ); // set blue pen, 0 pixel width
+ painter.drawLine( 40,30, 240,130 ); // draw a diagonal in rectangle
+ painter.end(); // painting done
+ \endcode
+
+ See the \l TQt::PenStyle enum type for a complete list of pen
+ styles.
+
+ With reference to the end points of lines, for wide (non-0-width)
+ pens it depends on the cap style whether the end point is drawn or
+ not. TQPainter will try to make sure that the end point is drawn
+ for 0-width pens, but this cannot be absolutely guaranteed because
+ the underlying drawing engine is free to use any (typically
+ accelerated) algorithm for drawing 0-width lines. On all tested
+ systems, however, the end point of at least all non-diagonal lines
+ are drawn.
+
+ A pen's color(), width(), style(), capStyle() and joinStyle() can
+ be set in the constructor or later with setColor(), setWidth(),
+ setStyle(), setCapStyle() and setJoinStyle(). Pens may also be
+ compared and streamed.
+
+ \img pen-styles.png Pen styles
+
+ \sa TQPainter, TQPainter::setPen()
+*/
+
+
+/*!
+ \internal
+ Initializes the pen.
+*/
+
+void TQPen::init( const TQColor &color, uint width, uint linestyle )
+{
+ data = new TQPenData;
+ TQ_CHECK_PTR( data );
+ data->style = (PenStyle)(linestyle & MPenStyle);
+ data->width = width;
+ data->color = color;
+ data->linest = linestyle;
+}
+
+/*!
+ Constructs a default black solid line pen with 0 width, which
+ renders lines 1 pixel wide (fast diagonals).
+*/
+
+TQPen::TQPen()
+{
+ init( TQt::black, 0, SolidLine ); // default pen
+}
+
+/*!
+ Constructs a black pen with 0 width (fast diagonals) and style \a
+ style.
+
+ \sa setStyle()
+*/
+
+TQPen::TQPen( PenStyle style )
+{
+ init( TQt::black, 0, style );
+}
+
+/*!
+ Constructs a pen with the specified \a color, \a width and \a
+ style.
+
+ \sa setWidth(), setStyle(), setColor()
+*/
+
+TQPen::TQPen( const TQColor &color, uint width, PenStyle style )
+{
+ init( color, width, style );
+}
+
+/*!
+ Constructs a pen with the specified color \a cl and width \a w.
+ The pen style is set to \a s, the pen cap style to \a c and the
+ pen join style to \a j.
+
+ A line width of 0 will produce a 1 pixel wide line using a fast
+ algorithm for diagonals. A line width of 1 will also produce a 1
+ pixel wide line, but uses a slower more accurate algorithm for
+ diagonals. For horizontal and vertical lines a line width of 0 is
+ the same as a line width of 1. The cap and join style have no
+ effect on 0-width lines.
+
+ \sa setWidth(), setStyle(), setColor()
+*/
+
+TQPen::TQPen( const TQColor &cl, uint w, PenStyle s, PenCapStyle c,
+ PenJoinStyle j )
+{
+ init( cl, w, s | c | j );
+}
+
+/*!
+ Constructs a pen that is a copy of \a p.
+*/
+
+TQPen::TQPen( const TQPen &p )
+{
+ data = p.data;
+ data->ref();
+}
+
+/*!
+ Destroys the pen.
+*/
+
+TQPen::~TQPen()
+{
+ if ( data->deref() )
+ delete data;
+}
+
+
+/*!
+ Detaches from shared pen data to make sure that this pen is the
+ only one referring the data.
+
+ If multiple pens share common data, this pen dereferences the data
+ and gets a copy of the data. Nothing is done if there is just a
+ single reference.
+*/
+
+void TQPen::detach()
+{
+ if ( data->count != 1 )
+ *this = copy();
+}
+
+
+/*!
+ Assigns \a p to this pen and returns a reference to this pen.
+*/
+
+TQPen &TQPen::operator=( const TQPen &p )
+{
+ p.data->ref();
+ if ( data->deref() )
+ delete data;
+ data = p.data;
+ return *this;
+}
+
+
+/*!
+ Returns a \link shclass.html deep copy\endlink of the pen.
+*/
+
+TQPen TQPen::copy() const
+{
+ TQPen p( data->color, data->width, data->style, capStyle(), joinStyle() );
+ return p;
+}
+
+
+/*!
+ \fn PenStyle TQPen::style() const
+
+ Returns the pen style.
+
+ \sa setStyle()
+*/
+
+/*!
+ Sets the pen style to \a s.
+
+ See the \l TQt::PenStyle documentation for a list of all the
+ styles.
+
+ \warning On Mac OS X the style setting (other than \c NoPen and \c
+ SolidLine) have no effect as they are not implemented by the
+ underlying system.
+
+ \warning On Windows 95/98, the style setting (other than \c NoPen
+ and \c SolidLine) has no effect for lines with width greater than
+ 1.
+
+ \sa style()
+*/
+
+void TQPen::setStyle( PenStyle s )
+{
+ if ( data->style == s )
+ return;
+ detach();
+ data->style = s;
+ data->linest = (data->linest & ~MPenStyle) | s;
+}
+
+
+/*!
+ \fn uint TQPen::width() const
+
+ Returns the pen width.
+
+ \sa setWidth()
+*/
+
+/*!
+ Sets the pen width to \a w.
+
+ A line width of 0 will produce a 1 pixel wide line using a fast
+ algorithm for diagonals. A line width of 1 will also produce a 1
+ pixel wide line, but uses a slower more accurate algorithm for
+ diagonals. For horizontal and vertical lines a line width of 0 is
+ the same as a line width of 1. The cap and join style have no
+ effect on 0-width lines.
+
+ \sa width()
+*/
+
+void TQPen::setWidth( uint w )
+{
+ if ( data->width == w )
+ return;
+ detach();
+ data->width = w;
+}
+
+
+/*!
+ Returns the pen's cap style.
+
+ \sa setCapStyle()
+*/
+TQt::PenCapStyle TQPen::capStyle() const
+{
+ return (PenCapStyle)(data->linest & MPenCapStyle);
+}
+
+/*!
+ Sets the pen's cap style to \a c.
+
+ The default value is \c FlatCap. The cap style has no effect on
+ 0-width pens.
+
+ \img pen-cap-styles.png Pen Cap Styles
+
+ \warning On Windows 95/98 and Macintosh, the cap style setting has
+ no effect. Wide lines are rendered as if the cap style was \c
+ SquareCap.
+
+ \sa capStyle()
+*/
+
+void TQPen::setCapStyle( PenCapStyle c )
+{
+ if ( (data->linest & MPenCapStyle) == c )
+ return;
+ detach();
+ data->linest = (data->linest & ~MPenCapStyle) | c;
+}
+
+/*!
+ Returns the pen's join style.
+
+ \sa setJoinStyle()
+*/
+TQt::PenJoinStyle TQPen::joinStyle() const
+{
+ return (PenJoinStyle)(data->linest & MPenJoinStyle);
+}
+
+/*!
+ Sets the pen's join style to \a j.
+
+ The default value is \c MiterJoin. The join style has no effect on
+ 0-width pens.
+
+ \img pen-join-styles.png Pen Join Styles
+
+ \warning On Windows 95/98 and Macintosh, the join style setting
+ has no effect. Wide lines are rendered as if the join style was \c
+ BevelJoin.
+
+ \sa joinStyle()
+*/
+
+void TQPen::setJoinStyle( PenJoinStyle j )
+{
+ if ( (data->linest & MPenJoinStyle) == j )
+ return;
+ detach();
+ data->linest = (data->linest & ~MPenJoinStyle) | j;
+}
+
+/*!
+ \fn const TQColor &TQPen::color() const
+
+ Returns the pen color.
+
+ \sa setColor()
+*/
+
+/*!
+ Sets the pen color to \a c.
+
+ \sa color()
+*/
+
+void TQPen::setColor( const TQColor &c )
+{
+ detach();
+ data->color = c;
+}
+
+
+/*!
+ \fn bool TQPen::operator!=( const TQPen &p ) const
+
+ Returns TRUE if the pen is different from \a p; otherwise returns
+ FALSE.
+
+ Two pens are different if they have different styles, widths or
+ colors.
+
+ \sa operator==()
+*/
+
+/*!
+ Returns TRUE if the pen is equal to \a p; otherwise returns FALSE.
+
+ Two pens are equal if they have equal styles, widths and colors.
+
+ \sa operator!=()
+*/
+
+bool TQPen::operator==( const TQPen &p ) const
+{
+ return (p.data == data) || (p.data->linest == data->linest &&
+ p.data->width == data->width && p.data->color == data->color);
+}
+
+
+/*****************************************************************************
+ TQPen stream functions
+ *****************************************************************************/
+#ifndef TQT_NO_DATASTREAM
+/*!
+ \relates TQPen
+
+ Writes the pen \a p to the stream \a s and returns a reference to
+ the stream.
+
+ \sa \link datastreamformat.html Format of the TQDataStream operators \endlink
+*/
+
+TQDataStream &operator<<( TQDataStream &s, const TQPen &p )
+{
+ // ### width() should not be restricted to 8-bit values
+ if ( s.version() < 3 )
+ return s << (TQ_UINT8)p.style() << (TQ_UINT8)p.width() << p.color();
+ else
+ return s << (TQ_UINT8)( p.style() | p.capStyle() | p.joinStyle() )
+ << (TQ_UINT8)p.width() << p.color();
+}
+
+/*!
+ \relates TQPen
+
+ Reads a pen from the stream \a s into \a p and returns a reference
+ to the stream.
+
+ \sa \link datastreamformat.html Format of the TQDataStream operators \endlink
+*/
+
+TQDataStream &operator>>( TQDataStream &s, TQPen &p )
+{
+ TQ_UINT8 style, width;
+ TQColor color;
+ s >> style;
+ s >> width;
+ s >> color;
+ p = TQPen( color, (uint)width, (TQt::PenStyle)style ); // owl
+ return s;
+}
+#endif //TQT_NO_DATASTREAM
+
+/*****************************************************************************
+ TQBrush member functions
+ *****************************************************************************/
+
+/*!
+ \class TQBrush tqbrush.h
+
+ \brief The TQBrush class defines the fill pattern of tqshapes drawn by a TQPainter.
+
+ \ingroup graphics
+ \ingroup images
+ \ingroup shared
+
+ A brush has a style and a color. One of the brush styles is a
+ custom pattern, which is defined by a TQPixmap.
+
+ The brush style defines the fill pattern. The default brush style
+ is \c NoBrush (depending on how you construct a brush). This style
+ tells the painter to not fill tqshapes. The standard style for
+ filling is \c SolidPattern.
+
+ The brush color defines the color of the fill pattern. The TQColor
+ documentation lists the predefined colors.
+
+ Use the TQPen class for specifying line/outline styles.
+
+ Example:
+ \code
+ TQPainter painter;
+ TQBrush brush( yellow ); // yellow solid pattern
+ painter.begin( &anyPaintDevice ); // paint something
+ painter.setBrush( brush ); // set the yellow brush
+ painter.setPen( NoPen ); // do not draw outline
+ painter.drawRect( 40,30, 200,100 ); // draw filled rectangle
+ painter.setBrush( NoBrush ); // do not fill
+ painter.setPen( black ); // set black pen, 0 pixel width
+ painter.drawRect( 10,10, 30,20 ); // draw rectangle outline
+ painter.end(); // painting done
+ \endcode
+
+ See the setStyle() function for a complete list of brush styles.
+
+ \img brush-styles.png Brush Styles
+
+ \sa TQPainter, TQPainter::setBrush(), TQPainter::setBrushOrigin()
+*/
+
+inline TQPixmap *TQBrush::pixmap() const {
+ if (style() != Qt::TexturePattern)
+ return 0;
+ QTexturedBrushData *data = static_cast<QTexturedBrushData*>(d.data());
+ QPixmap &pixmap = data->pixmap();
+ return pixmap.isNull() ? 0 : &pixmap;
+}
+
+/*!
+ \internal
+ Initializes the brush.
+*/
+
+void TQBrush::init( const TQColor &color, BrushStyle style )
+{
+ data = new TQBrushData;
+ TQ_CHECK_PTR( data );
+ data->style = style;
+ data->color = color;
+ data->pixmap = 0;
+}
+
+/*!
+ Constructs a default black brush with the style \c NoBrush (will
+ not fill tqshapes).
+*/
+
+TQBrush::TQBrush()
+{
+ static TQBrushData* defBrushData = 0;
+ if ( !defBrushData ) {
+ static TQSharedCleanupHandler<TQBrushData> defBrushCleanup;
+ defBrushData = new TQBrushData;
+ defBrushData->style = NoBrush;
+ defBrushData->color = TQt::black;
+ defBrushData->pixmap = 0;
+ defBrushCleanup.set( &defBrushData );
+ }
+ data = defBrushData;
+ data->ref();
+}
+
+/*!
+ Constructs a black brush with the style \a style.
+
+ \sa setStyle()
+*/
+
+TQBrush::TQBrush( BrushStyle style )
+{
+ init( TQt::black, style );
+}
+
+/*!
+ Constructs a brush with the color \a color and the style \a style.
+
+ \sa setColor(), setStyle()
+*/
+
+TQBrush::TQBrush( const TQColor &color, BrushStyle style )
+{
+ init( color, style );
+}
+
+/*!
+ Constructs a brush with the color \a color and a custom pattern
+ stored in \a pixmap.
+
+ The color will only have an effect for monochrome pixmaps, i.e.
+ for TQPixmap::depth() == 1.
+
+ Pixmap brushes are currently not supported when printing on X11.
+
+ \sa setColor(), setPixmap()
+*/
+
+TQBrush::TQBrush( const TQColor &color, const TQPixmap &pixmap )
+{
+ init( color, CustomPattern );
+ setPixmap( pixmap );
+}
+
+/*!
+ Constructs a brush that is a \link shclass.html shallow
+ copy\endlink of \a b.
+*/
+
+TQBrush::TQBrush( const TQBrush &b )
+{
+ data = b.data;
+ data->ref();
+}
+
+/*!
+ Destroys the brush.
+*/
+
+TQBrush::~TQBrush()
+{
+ if ( data->deref() ) {
+ delete data->pixmap;
+ delete data;
+ }
+}
+
+
+/*!
+ Detaches from shared brush data to make sure that this brush is
+ the only one referring the data.
+
+ If multiple brushes share common data, this brush dereferences the
+ data and gets a copy of the data. Nothing is done if there is just
+ a single reference.
+*/
+
+void TQBrush::detach()
+{
+ if ( data->count != 1 )
+ *this = copy();
+}
+
+
+/*!
+ Assigns \a b to this brush and returns a reference to this brush.
+*/
+
+TQBrush &TQBrush::operator=( const TQBrush &b )
+{
+ b.data->ref(); // beware of b = b
+ if ( data->deref() ) {
+ delete data->pixmap;
+ delete data;
+ }
+ data = b.data;
+ return *this;
+}
+
+
+/*!
+ Returns a \link shclass.html deep copy\endlink of the brush.
+*/
+
+TQBrush TQBrush::copy() const
+{
+ if ( data->style == CustomPattern ) { // brush has pixmap
+ TQBrush b( data->color, *data->pixmap );
+ return b;
+ } else { // brush has std pattern
+ TQBrush b( data->color, data->style );
+ return b;
+ }
+}
+
+
+/*!
+ \fn BrushStyle TQBrush::style() const
+
+ Returns the brush style.
+
+ \sa setStyle()
+*/
+
+/*!
+ Sets the brush style to \a s.
+
+ The brush styles are:
+ \table
+ \header \i Pattern \i Meaning
+ \row \i NoBrush \i will not fill tqshapes (default).
+ \row \i SolidPattern \i solid (100%) fill pattern.
+ \row \i Dense1Pattern \i11 94% fill pattern.
+ \row \i Dense2Pattern \i11 88% fill pattern.
+ \row \i Dense3Pattern \i11 63% fill pattern.
+ \row \i Dense4Pattern \i11 50% fill pattern.
+ \row \i Dense5Pattern \i11 37% fill pattern.
+ \row \i Dense6Pattern \i11 12% fill pattern.
+ \row \i Dense7Pattern \i11 6% fill pattern.
+ \row \i HorPattern \i horizontal lines pattern.
+ \row \i VerPattern \i vertical lines pattern.
+ \row \i CrossPattern \i crossing lines pattern.
+ \row \i BDiagPattern \i diagonal lines (directed /) pattern.
+ \row \i FDiagPattern \i diagonal lines (directed \) pattern.
+ \row \i DiagCrossPattern \i diagonal crossing lines pattern.
+ \row \i CustomPattern \i set when a pixmap pattern is being used.
+ \endtable
+
+ On Windows, dense and custom patterns cannot be transtqparent.
+
+ See the \link #details Detailed Description\endlink for a picture
+ of all the styles.
+
+ \sa style()
+*/
+
+void TQBrush::setStyle( BrushStyle s ) // set brush style
+{
+ if ( data->style == s )
+ return;
+#if defined(TQT_CHECK_RANGE)
+ if ( s == CustomPattern )
+ qWarning( "TQBrush::setStyle: CustomPattern is for internal use" );
+#endif
+ detach();
+ data->style = s;
+}
+
+
+/*!
+ \fn const TQColor &TQBrush::color() const
+
+ Returns the brush color.
+
+ \sa setColor()
+*/
+
+/*!
+ Sets the brush color to \a c.
+
+ \sa color(), setStyle()
+*/
+
+void TQBrush::setColor( const TQColor &c )
+{
+ detach();
+ data->color = c;
+}
+
+
+/*!
+ \fn TQPixmap *TQBrush::pixmap() const
+
+ Returns a pointer to the custom brush pattern, or 0 if no custom
+ brush pattern has been set.
+
+ \sa setPixmap()
+*/
+
+/*!
+ Sets the brush pixmap to \a pixmap. The style is set to \c
+ CustomPattern.
+
+ The current brush color will only have an effect for monochrome
+ pixmaps, i.e. for TQPixmap::depth() == 1.
+
+ Pixmap brushes are currently not supported when printing on X11.
+
+ \sa pixmap(), color()
+*/
+
+void TQBrush::setPixmap( const TQPixmap &pixmap )
+{
+ detach();
+ if ( data->pixmap )
+ delete data->pixmap;
+ if ( pixmap.isNull() ) {
+ data->style = NoBrush;
+ data->pixmap = 0;
+ } else {
+ data->style = CustomPattern;
+ data->pixmap = new TQPixmap( pixmap );
+ if ( data->pixmap->optimization() == TQPixmap::MemoryOptim )
+ data->pixmap->setOptimization( TQPixmap::NormalOptim );
+ }
+}
+
+
+/*!
+ \fn bool TQBrush::operator!=( const TQBrush &b ) const
+
+ Returns TRUE if the brush is different from \a b; otherwise
+ returns FALSE.
+
+ Two brushes are different if they have different styles, colors or
+ pixmaps.
+
+ \sa operator==()
+*/
+
+/*!
+ Returns TRUE if the brush is equal to \a b; otherwise returns
+ FALSE.
+
+ Two brushes are equal if they have equal styles, colors and
+ pixmaps.
+
+ \sa operator!=()
+*/
+
+bool TQBrush::operator==( const TQBrush &b ) const
+{
+ return (b.data == data) || (b.data->style == data->style &&
+ b.data->color == data->color &&
+ b.data->pixmap == data->pixmap);
+}
+
+
+/*!
+ \fn inline double TQPainter::translationX() const
+ \internal
+*/
+
+/*!
+ \fn inline double TQPainter::translationY() const
+ \internal
+*/
+
+
+/*****************************************************************************
+ TQBrush stream functions
+ *****************************************************************************/
+#ifndef TQT_NO_DATASTREAM
+/*!
+ \relates TQBrush
+
+ Writes the brush \a b to the stream \a s and returns a reference
+ to the stream.
+
+ \sa \link datastreamformat.html Format of the TQDataStream operators \endlink
+*/
+
+TQDataStream &operator<<( TQDataStream &s, const TQBrush &b )
+{
+ s << (TQ_UINT8)b.style() << b.color();
+ if ( b.style() == TQt::CustomPattern )
+#ifndef TQT_NO_IMAGEIO
+ s << *b.pixmap();
+#else
+ qWarning("No Image Brush I/O");
+#endif
+ return s;
+}
+
+/*!
+ \relates TQBrush
+
+ Reads the brush \a b from the stream \a s and returns a reference
+ to the stream.
+
+ \sa \link datastreamformat.html Format of the TQDataStream operators \endlink
+*/
+
+TQDataStream &operator>>( TQDataStream &s, TQBrush &b )
+{
+ TQ_UINT8 style;
+ TQColor color;
+ s >> style;
+ s >> color;
+ if ( style == TQt::CustomPattern ) {
+#ifndef TQT_NO_IMAGEIO
+ TQPixmap pm;
+ s >> pm;
+ b = TQBrush( color, pm );
+#else
+ qWarning("No Image Brush I/O");
+#endif
+ }
+ else
+ b = TQBrush( color, (TQt::BrushStyle)style );
+ return s;
+}
+#endif // TQT_NO_DATASTREAM
+
+#endif // USE_QT4