/****************************************************************************

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the test suite of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** 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.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <QtTest/QtTest>

#include <qpainter.h>

#include <qapplication.h>

#include <qwidget.h>

#include <qfontmetrics.h>

#include <qbitmap.h>

#include <qimage.h>

#include <limits.h>

#if !defined(Q_OS_WINCE) && !defined(Q_OS_SYMBIAN)

#include <qprinter.h>

#include <math.h>

#ifdef QT3_SUPPORT

#include <q3painter.h>

#endif

#endif

#include <qpaintengine.h>

#include <qdesktopwidget.h>

#include <qpixmap.h>

#include <qpainter.h>

#include <qlabel.h>

#include <qqueue.h>

#if defined(Q_OS_SYMBIAN)

# define SRCDIR "."

#endif

Q_DECLARE_METATYPE(QLine)

Q_DECLARE_METATYPE(QRect)

Q_DECLARE_METATYPE(QSize)

Q_DECLARE_METATYPE(QPoint)

Q_DECLARE_METATYPE(QPainterPath)

//TESTED_CLASS=

//TESTED_FILES=

class tst_QPainter : public QObject

{

Q_OBJECT

public:

    tst_QPainter();

    virtual ~tst_QPainter();

public slots:

    void init();

    void cleanup();

private slots:

    void getSetCheck();

    void qt_format_text_clip();

    void qt_format_text_boundingRect();

    void drawPixmap_comp_data();

    void drawPixmap_comp();

    void saveAndRestore_data();

    void saveAndRestore();

    void drawLine_data();

    void drawLine();

    void drawLine_clipped();

    void drawLine_task121143();

    void drawLine_task216948();

    void drawLine_task190634();

    void drawLine_task229459();

    void drawLine_task234891();

    void drawRect_data() { fillData(); }

    void drawRect();

    void drawRect2();

    void fillRect();

    void fillRect2();

    void fillRect3();

    void fillRect4();

    void drawEllipse_data();

    void drawEllipse();

    void drawClippedEllipse_data();

    void drawClippedEllipse();

    void drawPath_data();

    void drawPath();

    void drawPath2();

    void drawPath3();

    void drawRoundRect_data() { fillData(); }

    void drawRoundRect();

    void qimageFormats_data();

    void qimageFormats();

    void textOnTransparentImage();

    void initFrom();

    void setWindow();

    void combinedMatrix();

    void renderHints();

    void disableEnableClipping();

    void setClipRect();

    void setEqualClipRegionAndPath_data();

    void setEqualClipRegionAndPath();

    void clipRectSaveRestore();

    void clippedFillPath_data();

    void clippedFillPath();

    void clippedLines_data();

    void clippedLines();

    void clippedPolygon_data();

    void clippedPolygon();

    void clippedText();

    void setOpacity_data();

    void setOpacity();

    void drawhelper_blend_untransformed_data();

    void drawhelper_blend_untransformed();

    void drawhelper_blend_tiled_untransformed_data();

    void drawhelper_blend_tiled_untransformed();

    void porterDuff_warning();

    void drawhelper_blend_color();

    void childWidgetViewport();

    void fillRect_objectBoundingModeGradient();

    void fillRect_stretchToDeviceMode();

    void monoImages();

    void linearGradientSymmetry();

    void gradientInterpolation();

    void fpe_pixmapTransform();

    void fpe_zeroLengthLines();

    void fpe_divByZero();

    void fpe_steepSlopes_data();

    void fpe_steepSlopes();

    void fpe_rasterizeLine_task232012();

    void fpe_radialGradients();

    void rasterizer_asserts();

    void rasterizer_negativeCoords();

    void blendOverFlow_data();

    void blendOverFlow();

    void largeImagePainting_data();

    void largeImagePainting();

    void imageScaling_task206785();

    void outlineFillConsistency();

    void drawImage_task217400_data();

    void drawImage_task217400();

    void drawImage_1x1();

    void drawImage_task258776();

    void drawRect_task215378();

    void drawRect_task247505();

    void drawImage_data();

    void drawImage();

    void clippedImage();

    void stateResetBetweenQPainters();

    void imageCoordinateLimit();

    void imageBlending_data();

    void imageBlending();

    void imageBlending_clipped();

    void paintOnNullPixmap();

    void checkCompositionMode();

    void drawPolygon();

    void inactivePainter();

    void extendedBlendModes();

    void zeroOpacity();

    void clippingBug();

    void emptyClip();

    void taskQT4444_dontOverflowDashOffset();

    void painterBegin();

private:

    void fillData();

    QColor baseColor( int k, int intensity=255 );

    QImage getResImage( const QString &dir, const QString &addition, const QString &extension );

    QBitmap getBitmap( const QString &dir, const QString &filename, bool mask );

};

// Testing get/set functions

void tst_QPainter::getSetCheck()

{

    QImage img(QSize(10, 10), QImage::Format_ARGB32_Premultiplied);

    QPainter obj1;

    obj1.begin(&img);

    // CompositionMode QPainter::compositionMode()

    // void QPainter::setCompositionMode(CompositionMode)

    obj1.setCompositionMode(QPainter::CompositionMode(QPainter::CompositionMode_SourceOver));

    QCOMPARE(QPainter::CompositionMode(QPainter::CompositionMode_SourceOver), obj1.compositionMode());

    obj1.setCompositionMode(QPainter::CompositionMode(QPainter::CompositionMode_DestinationOver));

    QCOMPARE(QPainter::CompositionMode(QPainter::CompositionMode_DestinationOver), obj1.compositionMode());

    obj1.setCompositionMode(QPainter::CompositionMode(QPainter::CompositionMode_Clear));

    QCOMPARE(QPainter::CompositionMode(QPainter::CompositionMode_Clear), obj1.compositionMode());

    obj1.setCompositionMode(QPainter::CompositionMode(QPainter::CompositionMode_Source));

    QCOMPARE(QPainter::CompositionMode(QPainter::CompositionMode_Source), obj1.compositionMode());

    obj1.setCompositionMode(QPainter::CompositionMode(QPainter::CompositionMode_Destination));

    QCOMPARE(QPainter::CompositionMode(QPainter::CompositionMode_Destination), obj1.compositionMode());

    obj1.setCompositionMode(QPainter::CompositionMode(QPainter::CompositionMode_SourceIn));

    QCOMPARE(QPainter::CompositionMode(QPainter::CompositionMode_SourceIn), obj1.compositionMode());

    obj1.setCompositionMode(QPainter::CompositionMode(QPainter::CompositionMode_DestinationIn));

    QCOMPARE(QPainter::CompositionMode(QPainter::CompositionMode_DestinationIn), obj1.compositionMode());

    obj1.setCompositionMode(QPainter::CompositionMode(QPainter::CompositionMode_SourceOut));

    QCOMPARE(QPainter::CompositionMode(QPainter::CompositionMode_SourceOut), obj1.compositionMode());

    obj1.setCompositionMode(QPainter::CompositionMode(QPainter::CompositionMode_DestinationOut));

    QCOMPARE(QPainter::CompositionMode(QPainter::CompositionMode_DestinationOut), obj1.compositionMode());

    obj1.setCompositionMode(QPainter::CompositionMode(QPainter::CompositionMode_SourceAtop));

    QCOMPARE(QPainter::CompositionMode(QPainter::CompositionMode_SourceAtop), obj1.compositionMode());

    obj1.setCompositionMode(QPainter::CompositionMode(QPainter::CompositionMode_DestinationAtop));

    QCOMPARE(QPainter::CompositionMode(QPainter::CompositionMode_DestinationAtop), obj1.compositionMode());

    obj1.setCompositionMode(QPainter::CompositionMode(QPainter::CompositionMode_Xor));

    QCOMPARE(QPainter::CompositionMode(QPainter::CompositionMode_Xor), obj1.compositionMode());

    // const QPen & QPainter::pen()

    // void QPainter::setPen(const QPen &)

    QPen var3(Qt::red);

    obj1.setPen(var3);

    QCOMPARE(var3, obj1.pen());

    obj1.setPen(QPen());

    QCOMPARE(QPen(), obj1.pen());

    // const QBrush & QPainter::brush()

    // void QPainter::setBrush(const QBrush &)

    QBrush var4(Qt::red);

    obj1.setBrush(var4);

    QCOMPARE(var4, obj1.brush());

    obj1.setBrush(QBrush());

    QCOMPARE(QBrush(), obj1.brush());

    // const QBrush & QPainter::background()

    // void QPainter::setBackground(const QBrush &)

    QBrush var5(Qt::yellow);

    obj1.setBackground(var5);

    QCOMPARE(var5, obj1.background());

    obj1.setBackground(QBrush());

    QCOMPARE(QBrush(), obj1.background());

    // bool QPainter::matrixEnabled()

    // void QPainter::setMatrixEnabled(bool)

    obj1.setMatrixEnabled(false);

    QCOMPARE(false, obj1.matrixEnabled());

    obj1.setMatrixEnabled(true);

    QCOMPARE(true, obj1.matrixEnabled());

    // bool QPainter::viewTransformEnabled()

    // void QPainter::setViewTransformEnabled(bool)

    obj1.setViewTransformEnabled(false);

    QCOMPARE(false, obj1.viewTransformEnabled());

    obj1.setViewTransformEnabled(true);

    QCOMPARE(true, obj1.viewTransformEnabled());

}

Q_DECLARE_METATYPE(QPixmap)

Q_DECLARE_METATYPE(QPolygon)

Q_DECLARE_METATYPE(QBrush)

Q_DECLARE_METATYPE(QPen)

Q_DECLARE_METATYPE(QFont)

Q_DECLARE_METATYPE(QColor)

Q_DECLARE_METATYPE(QRegion)

tst_QPainter::tst_QPainter()

{

    // QtTestCase sets this to false, but this turns off alpha pixmaps on Unix.

    QApplication::setDesktopSettingsAware(TRUE);

}

tst_QPainter::~tst_QPainter()

{

}

void tst_QPainter::init()

{

}

void tst_QPainter::cleanup()

{

}

/* tests the clipping operations in qt_format_text, making sure

   the clip rectangle after the call is the same as before

*/

void tst_QPainter::qt_format_text_clip()

{

    QVERIFY(1);

    QSKIP( "Needs fixing...", SkipAll);

    QWidget *w = new QWidget( 0 );

    int modes[] = { Qt::AlignVCenter|Qt::TextSingleLine,

		   Qt::AlignVCenter|Qt::TextSingleLine|Qt::TextDontClip,

		   Qt::AlignVCenter|Qt::TextWordWrap,

		   Qt::AlignVCenter|Qt::TextWordWrap|Qt::TextDontClip,

		   0

    };

    int *m = modes;

    while( *m ) {

	{

	    QPainter p( w );

	    QRegion clipreg = p.clipRegion();

	    bool hasClipping = p.hasClipping();

	    qreal tx = p.matrix().dx();

	    qreal ty = p.matrix().dy();

	    p.drawText( 10, 10, 100, 100, *m,

			"fooo" );

	    QVERIFY( clipreg == p.clipRegion() );

	    QVERIFY( hasClipping == p.hasClipping() );

	    QCOMPARE( tx, p.matrix().dx() );

	    QCOMPARE( ty, p.matrix().dy() );

	    p.setClipRect( QRect( 5, 5, 50, 50 ) );

	    clipreg = p.clipRegion();

	    hasClipping = p.hasClipping();

	    p.drawText( 10, 10, 100, 100, *m,

			"fooo" );

	    QVERIFY( clipreg == p.clipRegion() );

	    QVERIFY( hasClipping == p.hasClipping() );

	    QCOMPARE( tx, p.matrix().dx() );

	    QCOMPARE( ty, p.matrix().dy() );

	}

	{

	    QPainter p( w );

	    p.setMatrix( QMatrix( 2, 1, 3, 4, 5, 6 ) );

	    QRegion clipreg = p.clipRegion();

	    bool hasClipping = p.hasClipping();

	    qreal tx = p.matrix().dx();

	    qreal ty = p.matrix().dy();

	    p.drawText( 10, 10, 100, 100, *m,

			"fooo" );

	    QVERIFY( clipreg == p.clipRegion() );

	    QVERIFY( hasClipping == p.hasClipping() );

	    QCOMPARE( tx, p.matrix().dx() );

	    QCOMPARE( ty, p.matrix().dy() );

	    p.setClipRect( QRect( 5, 5, 50, 50 ) );

	    clipreg = p.clipRegion();

	    hasClipping = p.hasClipping();

	    p.drawText( 10, 10, 100, 100, *m,

			"fooo" );

	    QVERIFY( clipreg == p.clipRegion() );

	    QVERIFY( hasClipping == p.hasClipping() );

	    QCOMPARE( tx, p.matrix().dx() );

	    QCOMPARE( ty, p.matrix().dy() );

	}

	{

	    QPainter p( w );

	    QRegion clipreg = p.clipRegion();

	    bool hasClipping = p.hasClipping();

	    qreal tx = p.matrix().dx();

	    qreal ty = p.matrix().dy();

	    p.drawText( 10, 10, 100, 100, *m,

			"fooo" );

	    QVERIFY( clipreg == p.clipRegion() );

	    QVERIFY( hasClipping == p.hasClipping() );

	    QCOMPARE( tx, p.matrix().dx() );

	    QCOMPARE( ty, p.matrix().dy() );

	    p.setClipRect( QRect( 5, 5, 50, 50 ));

	    clipreg = p.clipRegion();

	    hasClipping = p.hasClipping();

	    p.drawText( 10, 10, 100, 100, *m,

			"fooo" );

	    QVERIFY( clipreg == p.clipRegion() );

	    QVERIFY( hasClipping == p.hasClipping() );

	    QCOMPARE( tx, p.matrix().dx() );

	    QCOMPARE( ty, p.matrix().dy() );

	}

	{

	    QPainter p( w );

	    p.setMatrix( QMatrix( 2, 1, 3, 4, 5, 6 ) );

	    QRegion clipreg = p.clipRegion();

	    bool hasClipping = p.hasClipping();

	    qreal tx = p.matrix().dx();

	    qreal ty = p.matrix().dy();

	    p.drawText( 10, 10, 100, 100, *m,

			"fooo" );

	    QVERIFY( clipreg == p.clipRegion() );

	    QVERIFY( hasClipping == p.hasClipping() );

	    QCOMPARE( tx, p.matrix().dx() );

	    QCOMPARE( ty, p.matrix().dy() );

	    p.setClipRect(QRect( 5, 5, 50, 50 ));

	    clipreg = p.clipRegion();

	    hasClipping = p.hasClipping();

	    p.drawText( 10, 10, 100, 100, *m,

			"fooo" );

	    QVERIFY( clipreg == p.clipRegion() );

	    QVERIFY( hasClipping == p.hasClipping() );

	    QCOMPARE( tx, p.matrix().dx() );

	    QCOMPARE( ty, p.matrix().dy() );

	}

	++m;

    }

    delete w;

}

/* tests the bounding rect calculations in qt_format_text, making sure

   the bounding rect has a reasonable value.

*/

void tst_QPainter::qt_format_text_boundingRect()

{

    QVERIFY(1);

    QSKIP( "Needs fixing...", SkipAll);

    {

	const char * strings[] = {

	    "a\n\nb",

	    "abc",

	    "a\n \nb",

	    "this is a longer string",

	    "\327\222\327\223\327\233\327\223\327\222\327\233\327\222\327\223\327\233",

	    "aa\327\222\327\233aa",

	    "\327\222\327\223\327\233\327\223\327\222\327\233\327\222\327\223\327\233",

	    "\327\222\327\233aa",

	    "linebreakatend\n",

	    "some text longer than 30 chars with a line break at the end\n",

	    "some text\nwith line breaks\nin the middle\nand at the end\n",

	    "foo\n\n\nfoo",

	    0

	};

	int modes[] = { Qt::AlignVCenter|Qt::TextSingleLine,

			Qt::AlignVCenter|Qt::TextSingleLine|Qt::TextDontClip,

			Qt::AlignVCenter|Qt::TextWordWrap,

			Qt::AlignVCenter|Qt::TextWordWrap|Qt::TextDontClip,

			Qt::AlignLeft,

			Qt::AlignCenter,

			Qt::AlignRight,

			0

	};

	QFont f;

	for(int i = 5; i < 15; ++i) {

	    f.setPointSize(i);

	    QFontMetrics fm(f);

	    const char **str = strings;

	    while( *str ) {

		int *m = modes;

		while( *m ) {

		    QRect br = fm.boundingRect( 0, 0, 2000, 100, *m, QString::fromUtf8( *str ) );

		    QVERIFY( br.width() < 800 );

		    QRect br2 = fm.boundingRect( br.x(), br.y(), br.width(), br.height(), *m, QString::fromUtf8( *str ) );