1 /****************************************************************************

     2 **

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

     4 ** All rights reserved.

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

     6 **

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

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

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

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

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

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

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

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 

    43 #include <QtTest/QtTest>

    44 

    45 

    46 #include <qpainter.h>

    47 #include <qapplication.h>

    48 #include <qwidget.h>

    49 #include <qfontmetrics.h>

    50 #include <qbitmap.h>

    51 #include <qimage.h>

    52 #include <limits.h>

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

    54 #include <qprinter.h>

    55 #include <math.h>

    56 #ifdef QT3_SUPPORT

    57 #include <q3painter.h>

    58 #endif

    59 #endif

    60 #include <qpaintengine.h>

    61 #include <qdesktopwidget.h>

    62 #include <qpixmap.h>

    63 

    64 #include <qpainter.h>

    65 

    66 #include <qlabel.h>

    67 

    68 #include <qqueue.h>

    69 

    70 #if defined(Q_OS_SYMBIAN)

    71 # define SRCDIR "."

    72 #endif

    73 

    74 Q_DECLARE_METATYPE(QLine)

    75 Q_DECLARE_METATYPE(QRect)

    76 Q_DECLARE_METATYPE(QSize)

    77 Q_DECLARE_METATYPE(QPoint)

    78 Q_DECLARE_METATYPE(QPainterPath)

    79 

    80 //TESTED_CLASS=

    81 //TESTED_FILES=

    82 

    83 class tst_QPainter : public QObject

    84 {

    85 Q_OBJECT

    86 

    87 public:

    88     tst_QPainter();

    89     virtual ~tst_QPainter();

    90 

    91 

    92 public slots:

    93     void init();

    94     void cleanup();

    95 private slots:

    96     void getSetCheck();

    97     void qt_format_text_clip();

    98     void qt_format_text_boundingRect();

    99     void drawPixmap_comp_data();

   100     void drawPixmap_comp();

   101     void saveAndRestore_data();

   102     void saveAndRestore();

   103 

   104     void drawLine_data();

   105     void drawLine();

   106     void drawLine_clipped();

   107     void drawLine_task121143();

   108     void drawLine_task216948();

   109 

   110     void drawLine_task190634();

   111     void drawLine_task229459();

   112     void drawLine_task234891();

   113 

   114     void drawRect_data() { fillData(); }

   115     void drawRect();

   116     void drawRect2();

   117 

   118     void fillRect();

   119     void fillRect2();

   120     void fillRect3();

   121     void fillRect4();

   122 

   123     void drawEllipse_data();

   124     void drawEllipse();

   125     void drawClippedEllipse_data();

   126     void drawClippedEllipse();

   127 

   128     void drawPath_data();

   129     void drawPath();

   130     void drawPath2();

   131     void drawPath3();

   132 

   133     void drawRoundRect_data() { fillData(); }

   134     void drawRoundRect();

   135 

   136     void qimageFormats_data();

   137     void qimageFormats();

   138     void textOnTransparentImage();

   139 

   140     void initFrom();

   141 

   142     void setWindow();

   143 

   144     void combinedMatrix();

   145     void renderHints();

   146 

   147     void disableEnableClipping();

   148     void setClipRect();

   149     void setEqualClipRegionAndPath_data();

   150     void setEqualClipRegionAndPath();

   151 

   152     void clipRectSaveRestore();

   153 

   154     void clippedFillPath_data();

   155     void clippedFillPath();

   156     void clippedLines_data();

   157     void clippedLines();

   158     void clippedPolygon_data();

   159     void clippedPolygon();

   160 

   161     void clippedText();

   162 

   163     void setOpacity_data();

   164     void setOpacity();

   165 

   166     void drawhelper_blend_untransformed_data();

   167     void drawhelper_blend_untransformed();

   168     void drawhelper_blend_tiled_untransformed_data();

   169     void drawhelper_blend_tiled_untransformed();

   170 

   171     void porterDuff_warning();

   172 

   173     void drawhelper_blend_color();

   174 

   175     void childWidgetViewport();

   176 

   177     void fillRect_objectBoundingModeGradient();

   178     void fillRect_stretchToDeviceMode();

   179     void monoImages();

   180 

   181     void linearGradientSymmetry();

   182     void gradientInterpolation();

   183 

   184     void fpe_pixmapTransform();

   185     void fpe_zeroLengthLines();

   186     void fpe_divByZero();

   187 

   188     void fpe_steepSlopes_data();

   189     void fpe_steepSlopes();

   190     void fpe_rasterizeLine_task232012();

   191 

   192     void fpe_radialGradients();

   193 

   194     void rasterizer_asserts();

   195     void rasterizer_negativeCoords();

   196 

   197     void blendOverFlow_data();

   198     void blendOverFlow();

   199 

   200     void largeImagePainting_data();

   201     void largeImagePainting();

   202 

   203     void imageScaling_task206785();

   204 

   205     void outlineFillConsistency();

   206 

   207     void drawImage_task217400_data();

   208     void drawImage_task217400();

   209     void drawImage_1x1();

   210     void drawImage_task258776();

   211     void drawRect_task215378();

   212     void drawRect_task247505();

   213 

   214     void drawImage_data();

   215     void drawImage();

   216 

   217     void clippedImage();

   218 

   219     void stateResetBetweenQPainters();

   220 

   221     void imageCoordinateLimit();

   222     void imageBlending_data();

   223     void imageBlending();

   224     void imageBlending_clipped();

   225 

   226     void paintOnNullPixmap();

   227     void checkCompositionMode();

   228 

   229     void drawPolygon();

   230 

   231     void inactivePainter();

   232 

   233     void extendedBlendModes();

   234 

   235     void zeroOpacity();

   236     void clippingBug();

   237     void emptyClip();

   238 

   239     void taskQT4444_dontOverflowDashOffset();

   240 

   241     void painterBegin();

   242 

   243 private:

   244     void fillData();

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

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

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

   248 };

   249 

   250 // Testing get/set functions

   251 void tst_QPainter::getSetCheck()

   252 {

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

   254     QPainter obj1;

   255     obj1.begin(&img);

   256     // CompositionMode QPainter::compositionMode()

   257     // void QPainter::setCompositionMode(CompositionMode)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   282 

   283     // const QPen & QPainter::pen()

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

   285     QPen var3(Qt::red);

   286     obj1.setPen(var3);

   287     QCOMPARE(var3, obj1.pen());

   288     obj1.setPen(QPen());

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

   290 

   291     // const QBrush & QPainter::brush()

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

   293     QBrush var4(Qt::red);

   294     obj1.setBrush(var4);

   295     QCOMPARE(var4, obj1.brush());

   296     obj1.setBrush(QBrush());

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

   298 

   299     // const QBrush & QPainter::background()

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

   301     QBrush var5(Qt::yellow);

   302     obj1.setBackground(var5);

   303     QCOMPARE(var5, obj1.background());

   304     obj1.setBackground(QBrush());

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

   306 

   307     // bool QPainter::matrixEnabled()

   308     // void QPainter::setMatrixEnabled(bool)

   309     obj1.setMatrixEnabled(false);

   310     QCOMPARE(false, obj1.matrixEnabled());

   311     obj1.setMatrixEnabled(true);

   312     QCOMPARE(true, obj1.matrixEnabled());

   313 

   314     // bool QPainter::viewTransformEnabled()

   315     // void QPainter::setViewTransformEnabled(bool)

   316     obj1.setViewTransformEnabled(false);

   317     QCOMPARE(false, obj1.viewTransformEnabled());

   318     obj1.setViewTransformEnabled(true);

   319     QCOMPARE(true, obj1.viewTransformEnabled());

   320 }

   321 

   322 Q_DECLARE_METATYPE(QPixmap)

   323 Q_DECLARE_METATYPE(QPolygon)

   324 Q_DECLARE_METATYPE(QBrush)

   325 Q_DECLARE_METATYPE(QPen)

   326 Q_DECLARE_METATYPE(QFont)

   327 Q_DECLARE_METATYPE(QColor)

   328 Q_DECLARE_METATYPE(QRegion)

   329 

   330 tst_QPainter::tst_QPainter()

   331 {

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

   333     QApplication::setDesktopSettingsAware(TRUE);

   334 }

   335 

   336 tst_QPainter::~tst_QPainter()

   337 {

   338 }

   339 

   340 void tst_QPainter::init()

   341 {

   342 }

   343 

   344 void tst_QPainter::cleanup()

   345 {

   346 }

   347 

   348 /* tests the clipping operations in qt_format_text, making sure

   349    the clip rectangle after the call is the same as before

   350 */

   351 void tst_QPainter::qt_format_text_clip()

   352 {

   353     QVERIFY(1);

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

   355 

   356     QWidget *w = new QWidget( 0 );

   357 

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

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

   360 		   Qt::AlignVCenter|Qt::TextWordWrap,

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

   362 		   0

   363     };

   364 

   365     int *m = modes;

   366     while( *m ) {

   367 	{

   368 	    QPainter p( w );

   369 	    QRegion clipreg = p.clipRegion();

   370 	    bool hasClipping = p.hasClipping();

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

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

   373 

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

   375 			"fooo" );

   376 

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

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

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

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

   381 

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

   383 	    clipreg = p.clipRegion();

   384 	    hasClipping = p.hasClipping();

   385 

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

   387 			"fooo" );

   388 

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

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

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

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

   393 	}

   394 	{

   395 	    QPainter p( w );

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

   397 	    QRegion clipreg = p.clipRegion();

   398 	    bool hasClipping = p.hasClipping();

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

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

   401 

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

   403 			"fooo" );

   404 

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

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

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

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

   409 

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

   411 	    clipreg = p.clipRegion();

   412 	    hasClipping = p.hasClipping();

   413 

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

   415 			"fooo" );

   416 

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

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

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

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

   421 	}

   422 	{

   423 	    QPainter p( w );

   424 	    QRegion clipreg = p.clipRegion();

   425 	    bool hasClipping = p.hasClipping();

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

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

   428 

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

   430 			"fooo" );

   431 

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

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

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

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

   436 

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

   438 	    clipreg = p.clipRegion();

   439 	    hasClipping = p.hasClipping();

   440 

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

   442 			"fooo" );

   443 

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

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

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

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

   448 	}

   449 	{

   450 	    QPainter p( w );

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

   452 	    QRegion clipreg = p.clipRegion();

   453 	    bool hasClipping = p.hasClipping();

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

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

   456 

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

   458 			"fooo" );

   459 

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

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

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

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

   464 

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

   466 	    clipreg = p.clipRegion();

   467 	    hasClipping = p.hasClipping();

   468 

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

   470 			"fooo" );

   471 

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

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

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

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

   476 	}

   477 	++m;

   478     }

   479     delete w;

   480 }

   481 

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

   483    the bounding rect has a reasonable value.

   484 */

   485 void tst_QPainter::qt_format_text_boundingRect()

   486 {

   487     QVERIFY(1);

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

   489 

   490     {

   491 	const char * strings[] = {

   492 	    "a\n\nb",

   493 	    "abc",

   494 	    "a\n \nb",

   495 	    "this is a longer string",

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

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

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

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

   500 	    "linebreakatend\n",

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

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

   503 	    "foo\n\n\nfoo",

   504 	    0

   505 	};

   506 

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

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

   509 			Qt::AlignVCenter|Qt::TextWordWrap,

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

   511 			Qt::AlignLeft,

   512 			Qt::AlignCenter,

   513 			Qt::AlignRight,

   514 			0

   515 	};

   516 

   517 	QFont f;

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

   519 	    f.setPointSize(i);

   520 	    QFontMetrics fm(f);

   521 	    const char **str = strings;

   522 	    while( *str ) {

   523 		int *m = modes;

   524 		while( *m ) {

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

   526 		    QVERIFY( br.width() < 800 );

   527 

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

   529 		    QCOMPARE( br, br2 );

   530 #if 0

   531 		    {

   532 			QPrinter printer;

   533 			printer.setOutputToFile(TRUE);

   534 			printer.setOutputFileName("tmp.prn");

   535 			QPainter p(&printer);

   536 			QRect pbr = p.fontMetrics().boundingRect( 0, 0, 2000, 100, *m, QString::fromUtf8( *str ) );

   537 			QCOMPARE(pbr, br);

   538 		    }

   539 #endif

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

   541 		    {

   542 			QPrinter printer(QPrinter::HighResolution);

   543 			if (printer.printerName().isEmpty()) {

   544 			    QSKIP( "No printers installed, skipping bounding rect test",

   545 				  SkipSingle );

   546 			    break;

   547 			}

   548 

   549 			printer.setOutputFileName("tmp.prn");

   550 			QPainter p(&printer);

   551 			QRect pbr = p.fontMetrics().boundingRect( 0, 0, 12000, 600, *m, QString::fromUtf8( *str ) );

   552 			QVERIFY(pbr.width() > 2*br.width());

   553 			QVERIFY(pbr.height() > 2*br.height());

   554 		    }

   555 #endif

   556 		    ++m;

   557 		}

   558 		++str;

   559 	    }

   560 	}

   561     }

   562 

   563     {

   564 	const char * strings[] = {

   565 	    "a",

   566 	    "a\nb",

   567 	    "a\n\nb",

   568 	    "abc",

   569 //	    "a\n \nb",

   570 	    "this is a longer string",

   571 //	    "\327\222\327\223\327\233\327\223\327\222\327\233\327\222\327\223\327\233",

   572 //	    "aa\327\222\327\233aa",

   573 //	    "\327\222\327\223\327\233\327\223\327\222\327\233\327\222\327\223\327\233",

   574 //	    "\327\222\327\233aa",

   575 //	    "linebreakatend\n",

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

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

   578 	    "foo\n\n\nfoo",

   579 	    "a\n\n\n\n\nb",

   580 	    "a\n\n\n\n\n\nb",

   581 //	    "\347\231\273\351\214\262\346\203\205\345\240\261\343\201\214\350\246\213\343\201\244\343\201\213\343\202\211\343\201\252\343\201\204\343\201\213\347\204\241\345\212\271\343\201\252\343\201\237\343\202\201\343\200\201\nPhotoshop Album \343\202\222\350\265\267\345\213\225\343\201\247\343\201\215\343\201\276\343\201\233\343\202\223\343\200\202\345\206\215\343\202\244\343\203\263\343\202\271\343\203\210\343\203\274\343\203\253\343\201\227\343\201\246\343\201\217\343\201\240\343\201\225\343\201\204\343\200\202"

   582 //	    "\347\231\273\351\214\262\346\203\205\345\240\261\343\201\214\350\246\213\343\201\244\343\201\213\343\202\211\343\201\252\343\201\204\343\201\213\347\204\241\345\212\271\343\201\252\343\201\237\343\202\201\343\200\201\n\343\202\222\350\265\267\345\213\225\343\201\247\343\201\215\343\201\276\343\201\233\343\202\223\343\200\202\345\206\215\343\202\244\343\203\263\343\202\271\343\203\210\343\203\274\343\203\253\343\201\227\343\201\246\343\201\217\343\201\240\343\201\225\343\201\204\343\200\202",

   583 	    0

   584 	};

   585 

   586 	int modes[] = { Qt::AlignVCenter,

   587 			Qt::AlignLeft,

   588 			Qt::AlignCenter,

   589 			Qt::AlignRight,

   590 			0

   591 	};

   592 

   593 

   594 	QFont f;

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

   596 	    f.setPointSize(i);

   597 	    QFontMetrics fm(f);

   598 	    const char **str = strings;

   599 	    while( *str ) {

   600 		int *m = modes;

   601 		while( *m ) {

   602 		    QString s = QString::fromUtf8(*str);

   603 		    QRect br = fm.boundingRect(0, 0, 1000, 1000, *m, s );

   604 		    int lines =

   605 		    s.count("\n");

   606 		    int expectedHeight = fm.height()+lines*fm.lineSpacing();

   607 		    QCOMPARE(br.height(), expectedHeight);

   608 		    ++m;

   609 		}

   610 		++str;

   611 	    }

   612 	    QRect br = fm.boundingRect(0, 0, 100, 0, Qt::TextWordWrap,

   613 		 "A paragraph with gggggggggggggggggggggggggggggggggggg in the middle.");

   614 	    QVERIFY(br.height() >= fm.height()+2*fm.lineSpacing());

   615 	}

   616     }

   617 }

   618 

   619 

   620 static const char* const maskSource_data[] = {

   621 "16 13 6 1",

   622 ". c None",

   623 "d c #000000",

   624 "# c #999999",

   625 "c c #cccccc",

   626 "b c #ffff00",

   627 "a c #ffffff",

   628 "...#####........",

   629 "..#aaaaa#.......",

   630 ".#abcbcba######.",

   631 ".#acbcbcaaaaaa#d",

   632 ".#abcbcbcbcbcb#d",

   633 "#############b#d",

   634 "#aaaaaaaaaa##c#d",

   635 "#abcbcbcbcbbd##d",

   636 ".#abcbcbcbcbcd#d",

   637 ".#acbcbcbcbcbd#d",

   638 "..#acbcbcbcbb#dd",

   639 "..#############d",

   640 "...ddddddddddddd"};

   641 

   642 static const char* const maskResult_data[] = {

   643 "16 13 6 1",

   644 ". c #ff0000",

   645 "d c #000000",

   646 "# c #999999",

   647 "c c #cccccc",

   648 "b c #ffff00",

   649 "a c #ffffff",

   650 "...#####........",

   651 "..#aaaaa#.......",

   652 ".#abcbcba######.",

   653 ".#acbcbcaaaaaa#d",

   654 ".#abcbcbcbcbcb#d",

   655 "#############b#d",

   656 "#aaaaaaaaaa##c#d",

   657 "#abcbcbcbcbbd##d",

   658 ".#abcbcbcbcbcd#d",

   659 ".#acbcbcbcbcbd#d",

   660 "..#acbcbcbcbb#dd",

   661 "..#############d",

   662 "...ddddddddddddd"};

   663 

   664 

   665 void tst_QPainter::drawPixmap_comp_data()

   666 {

   667     if (qApp->desktop()->depth() < 24) {

   668         QSKIP("Test only works on 32 bit displays", SkipAll);

   669         return;

   670     }

   671 

   672     QTest::addColumn<uint>("dest");

   673     QTest::addColumn<uint>("source");

   674 

   675     QTest::newRow("0% on 0%, 1")           << 0x00000000u<< 0x00000000u;

   676     QTest::newRow("0% on 0%, 2")           << 0x00007fffu << 0x00ff007fu;

   677 

   678     QTest::newRow("50% on a=0%")           << 0x00000000u << 0x7fff0000u;

   679     QTest::newRow("50% on a=50%")          << 0x7f000000u << 0x7fff0000u;

   680     QTest::newRow("50% on deadbeef")      << 0xdeafbeefu <<  0x7fff0000u;

   681     QTest::newRow("deadbeef on a=0%")      << 0x00000000u << 0xdeadbeefu;

   682     QTest::newRow("deadbeef on a=50%")     << 0x7f000000u << 0xdeadbeefu;

   683     QTest::newRow("50% blue on 50% red")   << 0x7fff0000u << 0x7f0000ffu;

   684     QTest::newRow("50% blue on 50% green") << 0x7f00ff00u << 0x7f0000ffu;

   685     QTest::newRow("50% red on 50% green")  << 0x7f00ff00u << 0x7fff0000u;

   686     QTest::newRow("0% on 50%")             << 0x7fff00ffu << 0x00ffffffu;

   687     QTest::newRow("100% on deadbeef")      << 0xdeafbeefu << 0xffabcdefu;

   688     QTest::newRow("100% on a=0%")           << 0x00000000u << 0xffabcdefu;

   689 }

   690 

   691 QRgb qt_compose_alpha(QRgb source, QRgb dest)

   692 {

   693     int r1 = qRed(dest), g1 = qGreen(dest), b1 = qBlue(dest), a1 = qAlpha(dest);

   694     int r2 = qRed(source), g2 = qGreen(source), b2 = qBlue(source), a2 = qAlpha(source);

   695 

   696     int alpha = qMin(a2 + ((255 - a2) * a1 + 127) / 255, 255);

   697     if (alpha == 0)

   698         return qRgba(0, 0, 0, 0);

   699 

   700     return qRgba(

   701         qMin((r2 * a2 + (255 - a2) * r1 * a1 / 255) / alpha, 255),

   702         qMin((g2 * a2 + (255 - a2) * g1 * a1 / 255) / alpha, 255),

   703         qMin((b2 * a2 + (255 - a2) * b1 * a1 / 255) / alpha, 255),

   704         alpha);

   705 }

   706 

   707 /* Tests that drawing masked pixmaps works

   708 */

   709 void tst_QPainter::drawPixmap_comp()

   710 {

   711 #ifdef Q_WS_MAC

   712     QSKIP("Mac has other ideas about alpha composition", SkipAll);

   713 #endif

   714 

   715     QFETCH(uint, dest);

   716     QFETCH(uint, source);

   717 

   718     QRgb expected = qt_compose_alpha(source, dest);

   719 

   720     QColor c1(qRed(dest), qGreen(dest), qBlue(dest), qAlpha(dest));

   721     QColor c2(qRed(source), qGreen(source), qBlue(source), qAlpha(source));

   722 

   723     QPixmap destPm(10, 10), srcPm(10, 10);

   724     destPm.fill(c1);

   725     srcPm.fill(c2);

   726 

   727 #if defined(Q_WS_X11)

   728     if (!destPm.x11PictureHandle())

   729         QSKIP("Requires XRender support", SkipAll);

   730 #endif

   731 

   732     QPainter p(&destPm);

   733     p.drawPixmap(0, 0, srcPm);

   734     p.end();

   735 

   736     QImage result = destPm.toImage().convertToFormat(QImage::Format_ARGB32);

   737     bool different = false;

   738     for (int y=0; y<result.height(); ++y)

   739         for (int x=0; x<result.width(); ++x) {

   740 	    bool diff;

   741             if (qAlpha(expected) == 0) {

   742                 diff = qAlpha(result.pixel(x, y)) != 0;

   743             } else {

   744                 // Compensate for possible roundoff / platform fudge

   745                 int off = 1;

   746                 QRgb pix = result.pixel(x, y);

   747                 diff = (qAbs(qRed(pix) - qRed(expected)) > off)

   748                              || (qAbs(qGreen(pix) - qGreen(expected)) > off)

   749                              || (qAbs(qBlue(pix) - qBlue(expected)) > off)

   750                              || (qAbs(qAlpha(pix) - qAlpha(expected)) > off);

   751             }

   752 	    if (diff && !different)

   753 		qDebug( "Different at %d,%d pixel [%d,%d,%d,%d] expected [%d,%d,%d,%d]", x, y,

   754                         qRed(result.pixel(x, y)), qGreen(result.pixel(x, y)),

   755                         qBlue(result.pixel(x, y)), qAlpha(result.pixel(x, y)),

   756                         qRed(expected), qGreen(expected), qBlue(expected), qAlpha(expected));

   757 	    different |= diff;

   758         }

   759 

   760     QVERIFY(!different);

   761 }

   762 

   763 void tst_QPainter::saveAndRestore_data()

   764 {

   765     QVERIFY(1);

   766 

   767     QTest::addColumn<QFont>("font");

   768     QTest::addColumn<QPen>("pen");

   769     QTest::addColumn<QBrush>("brush");

   770     QTest::addColumn<QColor>("backgroundColor");

   771     QTest::addColumn<int>("backgroundMode");

   772     QTest::addColumn<QPoint>("brushOrigin");

   773     QTest::addColumn<QRegion>("clipRegion");

   774     QTest::addColumn<QRect>("window");

   775     QTest::addColumn<QRect>("viewport");

   776 

   777     QPixmap pixmap(1, 1);

   778     QPainter p(&pixmap);

   779     QFont font = p.font();

   780     QPen pen = p.pen();

   781     QBrush brush = p.brush();

   782     QColor backgroundColor = p.background().color();

   783     Qt::BGMode backgroundMode = p.backgroundMode();

   784     QPoint brushOrigin = p.brushOrigin();

   785     QRegion clipRegion = p.clipRegion();

   786     QRect window = p.window();

   787     QRect viewport = p.viewport();

   788 

   789     QTest::newRow("Original") << font << pen << brush << backgroundColor << int(backgroundMode)

   790 	    << brushOrigin << clipRegion << window << viewport;

   791 

   792     QFont font2 = font;

   793     font2.setPointSize( 24 );

   794     QTest::newRow("Modified font.pointSize, brush, backgroundColor, backgroundMode")

   795             << font2 << pen << QBrush(Qt::red) << QColor(Qt::blue) << int(Qt::TransparentMode)

   796 	    << brushOrigin << clipRegion << window << viewport;

   797 

   798     font2 = font;

   799     font2.setPixelSize( 20 );

   800     QTest::newRow("Modified font.pixelSize, brushOrigin, pos")

   801             << font2 << pen << brush << backgroundColor << int(backgroundMode)

   802 	    << QPoint( 50, 32 ) << clipRegion << window << viewport;

   803 

   804     QTest::newRow("Modified clipRegion, window, viewport")

   805             << font << pen << brush << backgroundColor << int(backgroundMode)

   806 	    << brushOrigin << clipRegion.subtracted(QRect(10,10,50,30))

   807 	    << QRect(-500, -500, 500, 500 ) << QRect( 0, 0, 50, 50 );

   808 }

   809 

   810 void tst_QPainter::saveAndRestore()

   811 {

   812     QFETCH( QFont, font );

   813     QFETCH( QPen, pen );

   814     QFETCH( QBrush, brush );

   815     QFETCH( QColor, backgroundColor );

   816     QFETCH( int, backgroundMode );

   817     QFETCH( QPoint, brushOrigin );

   818     QFETCH( QRegion, clipRegion );

   819     QFETCH( QRect, window );

   820     QFETCH( QRect, viewport );

   821 

   822     QPixmap pixmap(1, 1);

   823     QPainter painter(&pixmap);

   824 

   825     QFont font_org = painter.font();

   826     QPen pen_org = painter.pen();

   827     QBrush brush_org = painter.brush();

   828     QColor backgroundColor_org = painter.background().color();

   829     Qt::BGMode backgroundMode_org = painter.backgroundMode();

   830     QPoint brushOrigin_org = painter.brushOrigin();

   831     QRegion clipRegion_org = painter.clipRegion();

   832     QRect window_org = painter.window();

   833     QRect viewport_org = painter.viewport();

   834 

   835     painter.save();

   836     painter.setFont( font );

   837     painter.setPen( QPen(pen) );

   838     painter.setBrush( brush );

   839     painter.setBackground( backgroundColor );

   840     painter.setBackgroundMode( (Qt::BGMode)backgroundMode );

   841     painter.setBrushOrigin( brushOrigin );

   842     painter.setClipRegion( clipRegion );

   843     painter.setWindow( window );

   844     painter.setViewport( viewport );

   845     painter.restore();

   846 

   847     QCOMPARE( painter.font(), font_org );

   848     QCOMPARE( painter.font().pointSize(), font_org.pointSize() );

   849     QCOMPARE( painter.font().pixelSize(), font_org.pixelSize() );

   850     QCOMPARE( painter.pen(), pen_org );

   851     QCOMPARE( painter.brush(), brush_org );

   852     QCOMPARE( painter.background().color(), backgroundColor_org );

   853     QCOMPARE( painter.backgroundMode(), backgroundMode_org );

   854     QCOMPARE( painter.brushOrigin(), brushOrigin_org );

   855     QCOMPARE( painter.clipRegion(), clipRegion_org );

   856     QCOMPARE( painter.window(), window_org );

   857     QCOMPARE( painter.viewport(), viewport_org );

   858 }

   859 

   860 /*

   861    Helper functions

   862 */

   863 

   864 QColor tst_QPainter::baseColor( int k, int intensity )

   865 {

   866     int r = ( k & 1 ) * intensity;

   867     int g = ( (k>>1) & 1 ) * intensity;

   868     int b = ( (k>>2) & 1 ) * intensity;

   869     return QColor( r, g, b );

   870 }

   871 

   872 QImage tst_QPainter::getResImage( const QString &dir, const QString &addition, const QString &extension )

   873 {

   874     QImage res;

   875     QString resFilename  = dir + QString( "/res_%1." ).arg( addition ) + extension;

   876     if ( !res.load( resFilename ) ) {

   877         QWARN(QString("Could not load result data %s %1").arg(resFilename).toLatin1());

   878         return QImage();

   879     }

   880     return res;

   881 }

   882 

   883 QBitmap tst_QPainter::getBitmap( const QString &dir, const QString &filename, bool mask )

   884 {

   885     QBitmap bm;

   886     QString bmFilename = dir + QString( "/%1.xbm" ).arg( filename );

   887     if ( !bm.load( bmFilename ) ) {

   888         QWARN(QString("Could not load bitmap '%1'").arg(bmFilename).toLatin1());

   889         return QBitmap();

   890     }

   891     if ( mask ) {

   892 	QBitmap mask;

   893 	QString maskFilename = dir + QString( "/%1-mask.xbm" ).arg( filename );

   894 	if ( !mask.load( maskFilename ) ) {

   895         QWARN(QString("Could not load mask '%1'").arg(maskFilename).toLatin1());

   896         return QBitmap();

   897 	}

   898 	bm.setMask( mask );

   899     }

   900     return bm;

   901 }

   902 

   903 static int getPaintedPixels(const QImage &image, const QColor &background)

   904 {

   905     uint color = background.rgba();

   906 

   907     int pixels = 0;

   908 

   909     for (int y = 0; y < image.height(); ++y)

   910         for (int x = 0; x < image.width(); ++x)

   911             if (image.pixel(x, y) != color)

   912                 ++pixels;

   913 

   914     return pixels;

   915 }

   916 

   917 static QRect getPaintedSize(const QImage &image, const QColor &background)

   918 {

   919     // not the fastest but at least it works..

   920     int xmin = image.width() + 1;

   921     int xmax = -1;

   922     int ymin = image.height() +1;

   923     int ymax = -1;

   924 

   925     uint color = background.rgba();

   926 

   927     for ( int y = 0; y < image.height(); ++y ) {

   928 	for ( int x = 0; x < image.width(); ++x ) {

   929             QRgb pixel = image.pixel( x, y );

   930 	    if ( pixel != color && x < xmin )

   931 		xmin = x;

   932 	    if ( pixel != color && x > xmax )

   933 		xmax = x;

   934 	    if ( pixel != color && y < ymin )

   935 		ymin = y;

   936 	    if ( pixel != color && y > ymax )

   937 		ymax = y;

   938 	}

   939     }

   940 

   941     return QRect(xmin, ymin, xmax - xmin + 1, ymax - ymin + 1);

   942 }

   943 

   944 static QRect getPaintedSize(const QPixmap &pm, const QColor &background)

   945 {

   946     return getPaintedSize(pm.toImage(), background);

   947 }

   948 

   949 void tst_QPainter::initFrom()

   950 {

   951     QWidget *widget = new QWidget();

   952     QPalette pal = widget->palette();

   953     pal.setColor(QPalette::Foreground, QColor(255, 0, 0));

   954     pal.setBrush(QPalette::Background, QColor(0, 255, 0));

   955     widget->setPalette(pal);

   956 

   957     QFont font = widget->font();

   958     font.setPointSize(26);

   959     font.setItalic(true);

   960     widget->setFont(font);

   961 

   962     QPixmap pm(100, 100);

   963     QPainter p(&pm);

   964     p.initFrom(widget);

   965 

   966     QCOMPARE(p.font(), font);

   967     QCOMPARE(p.pen().color(), pal.color(QPalette::Foreground));

   968     QCOMPARE(p.background(), pal.background());

   969 

   970     delete widget;

   971 }

   972 

   973 void tst_QPainter::drawLine_data()

   974 {

   975     QTest::addColumn<QLine>("line");

   976 

   977     QTest::newRow("0-45") << QLine(0, 20, 100, 0);

   978     QTest::newRow("45-90") << QLine(0, 100, 20, 0);

   979     QTest::newRow("90-135") << QLine(20, 100, 0, 0);

   980     QTest::newRow("135-180") << QLine(100, 20, 0, 0);

   981     QTest::newRow("180-225") << QLine(100, 0, 0, 20);

   982     QTest::newRow("225-270") << QLine(20, 0, 0, 100);

   983     QTest::newRow("270-315") << QLine(0, 0, 20, 100);

   984     QTest::newRow("315-360") << QLine(0, 0, 100, 20);

   985 }

   986 

   987 void tst_QPainter::drawLine()

   988 {

   989     const int offset = 5;

   990     const int epsilon = 1; // allow for one pixel difference

   991 

   992     QFETCH(QLine, line);

   993 

   994     QPixmap pixmapUnclipped(qMin(line.x1(), line.x2())

   995                             + 2*offset + qAbs(line.dx()),

   996                             qMin(line.y1(), line.y2())

   997                             + 2*offset + qAbs(line.dy()));

   998 

   999     { // unclipped

  1000         pixmapUnclipped.fill(Qt::white);

  1001         QPainter p(&pixmapUnclipped);

  1002         p.translate(offset, offset);

  1003         p.setPen(QPen(Qt::black));

  1004         p.drawLine(line);

  1005         p.end();

  1006 

  1007         const QRect painted = getPaintedSize(pixmapUnclipped, Qt::white);

  1008 

  1009         QLine l = line;

  1010         l.translate(offset, offset);

  1011         QVERIFY(qAbs(painted.width() - qAbs(l.dx())) <= epsilon);

  1012         QVERIFY(qAbs(painted.height() - qAbs(l.dy())) <= epsilon);

  1013         QVERIFY(qAbs(painted.top() - qMin(l.y1(), l.y2())) <= epsilon);

  1014         QVERIFY(qAbs(painted.left() - qMin(l.x1(), l.x2())) <= epsilon);

  1015         QVERIFY(qAbs(painted.bottom() - qMax(l.y1(), l.y2())) <= epsilon);

  1016         QVERIFY(qAbs(painted.right() - qMax(l.x1(), l.x2())) <= epsilon);

  1017     }

  1018 

  1019     QPixmap pixmapClipped(qMin(line.x1(), line.x2())

  1020                           + 2*offset + qAbs(line.dx()),

  1021                           qMin(line.y1(), line.y2())

  1022                           + 2*offset + qAbs(line.dy()));

  1023     { // clipped

  1024         const QRect clip = QRect(line.p1(), line.p2()).normalized();

  1025 

  1026         pixmapClipped.fill(Qt::white);

  1027         QPainter p(&pixmapClipped);

  1028         p.translate(offset, offset);

  1029         p.setClipRect(clip);

  1030         p.setPen(QPen(Qt::black));

  1031         p.drawLine(line);

  1032         p.end();

  1033     }

  1034 

  1035     const QImage unclipped = pixmapUnclipped.toImage();

  1036     const QImage clipped = pixmapClipped.toImage();

  1037     QCOMPARE(unclipped, clipped);

  1038 }

  1039 

  1040 void tst_QPainter::drawLine_clipped()

  1041 {

  1042     QImage image(16, 1, QImage::Format_ARGB32_Premultiplied);

  1043     image.fill(0x0);

  1044 

  1045     QPainter p(&image);

  1046     p.setPen(QPen(Qt::black, 10));

  1047 

  1048     // this should fill the whole image

  1049     p.drawLine(-1, -1, 17, 1);

  1050     p.end();

  1051 

  1052     for (int x = 0; x < 16; ++x)

  1053         QCOMPARE(image.pixel(x, 0), 0xff000000);

  1054 }

  1055 

  1056 void tst_QPainter::drawLine_task121143()

  1057 {

  1058     QPen pen(Qt::black);

  1059 

  1060     QImage image(5, 5, QImage::Format_ARGB32_Premultiplied);

  1061     image.fill(0xffffffff);

  1062     QPainter p(&image);

  1063     p.setPen(pen);

  1064     p.drawLine(QLine(0, 0+4, 0+4, 0));

  1065     p.end();

  1066 

  1067     QImage expected(5, 5, QImage::Format_ARGB32_Premultiplied);

  1068     expected.fill(0xffffffff);

  1069     for (int x = 0; x < 5; ++x)

  1070         expected.setPixel(x, 5-x-1, pen.color().rgb());

  1071 

  1072     QCOMPARE(image, expected);

  1073 }

  1074 

  1075 void tst_QPainter::drawLine_task190634()

  1076 {

  1077     QPen pen(Qt::black, 3);

  1078 

  1079     QImage image(32, 32, QImage::Format_ARGB32_Premultiplied);

  1080     QPainter p(&image);

  1081     p.fillRect(0, 0, image.width(), image.height(), Qt::white);

  1082 

  1083     p.setPen(pen);

  1084     p.drawLine(QLineF(2, -1.6, 10, -1.6));

  1085     p.end();

  1086 

  1087     const uint *data = reinterpret_cast<uint *>(image.bits());

  1088 

  1089     for (int i = 0; i < image.width() * image.height(); ++i)

  1090         QCOMPARE(data[i], 0xffffffff);

  1091 

  1092     p.begin(&image);

  1093     p.fillRect(0, 0, image.width(), image.height(), Qt::white);

  1094 

  1095     p.setPen(pen);

  1096     p.drawLine(QLineF(-1.6, 2, -1.6, 10));

  1097     p.end();

  1098 

  1099     data = reinterpret_cast<uint *>(image.bits());

  1100 

  1101     for (int i = 0; i < image.width() * image.height(); ++i)

  1102         QCOMPARE(data[i], 0xffffffff);

  1103 

  1104     p.begin(&image);

  1105     p.fillRect(0, 0, image.width(), image.height(), Qt::white);

  1106 

  1107     p.setPen(pen);

  1108     p.drawLine( QPoint(2,-2), QPoint(3,-5) );

  1109     p.end();

  1110 

  1111     data = reinterpret_cast<uint *>(image.bits());

  1112 

  1113     for (int i = 0; i < image.width() * image.height(); ++i)

  1114         QCOMPARE(data[i], 0xffffffff);

  1115 }

  1116 

  1117 void tst_QPainter::drawLine_task229459()

  1118 {

  1119     QImage image(32, 32, QImage::Format_ARGB32_Premultiplied);

  1120     image.fill(0x0);

  1121     QPen pen(Qt::black, 64);

  1122 

  1123     QPainter p(&image);

  1124     p.setPen(pen);

  1125     p.drawLine(-8, -8, 10000000, 10000000);

  1126     p.end();

  1127 

  1128     QImage expected = image;

  1129     expected.fill(0xff000000);

  1130 

  1131     QCOMPARE(image, expected);

  1132 }

  1133 

  1134 void tst_QPainter::drawLine_task234891()