AuroraMiddleware/qt5base-lts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ea168ead1a
qt5base-lts/tests/auto/gui/painting/qpainter/tst_qpainter.cpp

5305 lines
167 KiB
C++
Raw Normal View History

Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
/****************************************************************************
**
Updated license headers From Qt 5.7 -> tools & applications are lisenced under GPL v3 with some exceptions, see http://blog.qt.io/blog/2016/01/13/new-agreement-with-the-kde-free-qt-foundation/ Updated license headers to use new GPL-EXCEPT header instead of LGPL21 one (in those files which will be under GPL 3 with exceptions) Change-Id: I42a473ddc97101492a60b9287d90979d9eb35ae1 Reviewed-by: Thiago Macieira <thiago.macieira@intel.com> Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
2016-01-15 12:36:27 +00:00
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
**
** This file is part of the test suite of the Qt Toolkit.
**
Updated license headers From Qt 5.7 -> tools & applications are lisenced under GPL v3 with some exceptions, see http://blog.qt.io/blog/2016/01/13/new-agreement-with-the-kde-free-qt-foundation/ Updated license headers to use new GPL-EXCEPT header instead of LGPL21 one (in those files which will be under GPL 3 with exceptions) Change-Id: I42a473ddc97101492a60b9287d90979d9eb35ae1 Reviewed-by: Thiago Macieira <thiago.macieira@intel.com> Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
2016-01-15 12:36:27 +00:00
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
Change copyrights from Nokia to Digia Change copyrights and license headers from Nokia to Digia Change-Id: If1cc974286d29fd01ec6c19dd4719a67f4c3f00e Reviewed-by: Lars Knoll <lars.knoll@digia.com> Reviewed-by: Sergio Ahumada <sergio.ahumada@digia.com>
2012-09-19 12:28:29 +00:00
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
Update copyright headers Qt copyrights are now in The Qt Company, so we could update the source code headers accordingly. In the same go we should also fix the links to point to qt.io. Outdated header.LGPL removed (use header.LGPL21 instead) Old header.LGPL3 renamed to header.LGPL3-COMM to match actual licensing combination. New header.LGPL-COMM taken in the use file which were using old header.LGPL3 (src/plugins/platforms/android/extract.cpp) Added new header.LGPL3 containing Commercial + LGPLv3 + GPLv2 license combination Change-Id: I6f49b819a8a20cc4f88b794a8f6726d975e8ffbe Reviewed-by: Matti Paaso <matti.paaso@theqtcompany.com>
2015-01-28 08:44:43 +00:00
** a written agreement between you and The Qt Company. For licensing terms
Updated license headers From Qt 5.7 -> tools & applications are lisenced under GPL v3 with some exceptions, see http://blog.qt.io/blog/2016/01/13/new-agreement-with-the-kde-free-qt-foundation/ Updated license headers to use new GPL-EXCEPT header instead of LGPL21 one (in those files which will be under GPL 3 with exceptions) Change-Id: I42a473ddc97101492a60b9287d90979d9eb35ae1 Reviewed-by: Thiago Macieira <thiago.macieira@intel.com> Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
2016-01-15 12:36:27 +00:00
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
Change copyrights from Nokia to Digia Change copyrights and license headers from Nokia to Digia Change-Id: If1cc974286d29fd01ec6c19dd4719a67f4c3f00e Reviewed-by: Lars Knoll <lars.knoll@digia.com> Reviewed-by: Sergio Ahumada <sergio.ahumada@digia.com>
2012-09-19 12:28:29 +00:00
**
Updated license headers From Qt 5.7 -> tools & applications are lisenced under GPL v3 with some exceptions, see http://blog.qt.io/blog/2016/01/13/new-agreement-with-the-kde-free-qt-foundation/ Updated license headers to use new GPL-EXCEPT header instead of LGPL21 one (in those files which will be under GPL 3 with exceptions) Change-Id: I42a473ddc97101492a60b9287d90979d9eb35ae1 Reviewed-by: Thiago Macieira <thiago.macieira@intel.com> Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
2016-01-15 12:36:27 +00:00
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <QtTest/QtTest>
#include <qpainter.h>
Make qpainter autotest build without widgets Change-Id: I4e05871e44f7a69aaa9cd5d876c249c7dd9d86e8 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-06-05 11:58:15 +00:00
#ifndef QT_NO_WIDGETS
Fix autotest gui/widgets dependencies This is in preparation of removing testlib's dependency on QtGui and QtWidgets. Autotests that need QtWidgets api must explicitly include it (since the types are no longer provided by the QtGui master header). Autotests that don't need QtGui or QtWidgets api shouldn't link against those libraries. Change-Id: I2808289068514fcac582808828ad4634e2631733 Reviewed-on: http://codereview.qt-project.org/5093 Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com> Reviewed-by: Lars Knoll <lars.knoll@nokia.com>
2011-09-16 12:07:05 +00:00
#include <qdrawutil.h>
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
#include <qapplication.h>
#include <qwidget.h>
Make qpainter autotest build without widgets Change-Id: I4e05871e44f7a69aaa9cd5d876c249c7dd9d86e8 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-06-05 11:58:15 +00:00
#endif
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
#include <qfontmetrics.h>
#include <qbitmap.h>
#include <qimage.h>
#include <qthread.h>
#include <limits.h>
#include <math.h>
#include <qpaintengine.h>
Make qpainter autotest build without widgets Change-Id: I4e05871e44f7a69aaa9cd5d876c249c7dd9d86e8 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-06-05 11:58:15 +00:00
#ifndef QT_NO_WIDGETS
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
#include <qdesktopwidget.h>
Make qpainter autotest build without widgets Change-Id: I4e05871e44f7a69aaa9cd5d876c249c7dd9d86e8 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-06-05 11:58:15 +00:00
#endif
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
#include <qpixmap.h>
Solid and gradients in high color accuracy This patch updates the internal color precisions of solids and gradients to 16bit per color. This makes it possible to render at higher precision on non-premultiplied ARGB32, the RGB30 formats and any other hi-color formats if more are added. [ChangeLog][QtGui][Painting] Internal precision of solids and gradients is now up to 16bit per color. Change-Id: Ieae5468bd6de1f56adfa4cb9fa966faf2ed824fd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-11 10:13:03 +00:00
#include <private/qdrawhelper_p.h>
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
#include <qpainter.h>
Make qpainter autotest build without widgets Change-Id: I4e05871e44f7a69aaa9cd5d876c249c7dd9d86e8 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-06-05 11:58:15 +00:00
#ifndef QT_NO_WIDGETS
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
#include <qlabel.h>
Make qpainter autotest build without widgets Change-Id: I4e05871e44f7a69aaa9cd5d876c249c7dd9d86e8 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-06-05 11:58:15 +00:00
#endif
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
#include <qqueue.h>
Make qpainter autotest build without widgets Change-Id: I4e05871e44f7a69aaa9cd5d876c249c7dd9d86e8 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-06-05 11:58:15 +00:00
#ifndef QT_NO_WIDGETS
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
#include <qgraphicsview.h>
#include <qgraphicsscene.h>
#include <qgraphicsproxywidget.h>
#include <qlayout.h>
Make qpainter autotest build without widgets Change-Id: I4e05871e44f7a69aaa9cd5d876c249c7dd9d86e8 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-06-05 11:58:15 +00:00
#endif
Added autotest for threaded text rendering. Task-number: QTBUG-18516 Reviewed-by: TRUSTME (cherry picked from commit 903d4dc2196df2775255c24c707bfeb571992bb7)
2011-04-26 14:01:08 +00:00
#include <qfontdatabase.h>
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
Improved gradient table generation performance for two-stop gradients. Two stops is a fairly common case so we gain quite a bit by special casing it. Improves performance by 10 % in parcycle benchmark, and by 90 % in a synthetic benchmark. Reviewed-by: Andreas Kling (cherry picked from commit 5b74a70ac630073582be56f8a0539624a1080185)
2011-04-13 08:15:06 +00:00
Q_DECLARE_METATYPE(QGradientStops)
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
Q_DECLARE_METATYPE(QPainterPath)
tst_QPainter: fix a Q_DECLARE_METATYPE coming too late The compiler complained that the specialization was required before it was issued. Fixed by moving it up to the others near the top of the file. Change-Id: I0ae162a5db5ef29f24cd1d32285a1870fdd24b9b Reviewed-by: Thiago Macieira <thiago.macieira@intel.com> Reviewed-by: Olivier Goffart <ogoffart@woboq.com> Reviewed-by: Stephen Kelly <stephen.kelly@kdab.com> Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-09-18 17:26:48 +00:00
Q_DECLARE_METATYPE(QImage::Format)
Tests for semi transparent blend on opaque formats This patch adds tests for the consistent handling of transparent drawing results on opaque formats that was introduced with commit 6f7d370adec3054656f36b0d2a0777a8a1df3602 Change-Id: If5d11d0f2e111ef88490a4dc20a64b0858ad5426 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-01-23 09:44:08 +00:00
Q_DECLARE_METATYPE(QPainter::CompositionMode)
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
class tst_QPainter : public QObject
{
Q_OBJECT
public:
tst_QPainter();
private slots:
Tests: Remove empty init/cleanup slots, constructors and destructors. Move some code (like registrations of meta types) from init() to initTestCase() in the process. Change-Id: I57db5156647cfadab554fbed853b2e68b2815f3b Reviewed-by: Frederik Gladhorn <frederik.gladhorn@theqtcompany.com>
2015-12-03 15:59:30 +00:00
void cleanupTestCase();
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void getSetCheck();
Make qpainter autotest build without widgets Change-Id: I4e05871e44f7a69aaa9cd5d876c249c7dd9d86e8 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-06-05 11:58:15 +00:00
#ifndef QT_NO_WIDGETS
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void drawPixmap_comp_data();
void drawPixmap_comp();
Make qpainter autotest build without widgets Change-Id: I4e05871e44f7a69aaa9cd5d876c249c7dd9d86e8 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-06-05 11:58:15 +00:00
#endif
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void saveAndRestore_data();
void saveAndRestore();
Make qpainter autotest build without widgets Change-Id: I4e05871e44f7a69aaa9cd5d876c249c7dd9d86e8 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-06-05 11:58:15 +00:00
#ifndef QT_NO_WIDGETS
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void drawBorderPixmap();
Make qpainter autotest build without widgets Change-Id: I4e05871e44f7a69aaa9cd5d876c249c7dd9d86e8 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-06-05 11:58:15 +00:00
#endif
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void drawPixmapFragments();
qpa: Fix rendering issue in blitter engine (negative scaling factors) A 180° rotation results in a TxScale QTransform with negative scaling factors (x=-1.0 y=-1.0). This is not properly handled by blitter paint engine yet, so use software rendering fallback in this case. This rendering issue can be seen when using "-webkit-transform" CSS property in WebKit with DirectFB QPA platform. Change-Id: Iee496b6bf0c90ffe36c4235ceaa2c80f296b2ca4 Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-11-07 10:01:08 +00:00
void drawPixmapNegativeScale();
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void drawLine_data();
void drawLine();
void drawLine_clipped();
void drawLine_task121143();
void drawLine_task216948();
void drawLine_task190634();
void drawLine_task229459();
void drawLine_task234891();
Improve rounding in QCosmeticStroker Fixes the drawn position of end points in drawLine. Based on a patch by Jørgen Lind, and modified so that it caused no test regressions. Task-number: QTBUG-38144 Change-Id: I24aa28480cc6ae09abf91d80378970565a29b254 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-03-11 16:14:50 +00:00
void drawLineEndPoints();
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void drawRect_data() { fillData(); }
void drawRect();
void drawRect2();
Fix fillRect on RGBA8888 images The fill color was not correctly converted before being filled into RGBA8888 images. This patch adds a function with convertion and adds tests for it to tst_qpainter. Change-Id: If8b0e6db38b2794a60301842e25f377eb7216796 Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-07-24 12:51:47 +00:00
void fillRect_data();
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void fillRect();
Fix fillRect on RGBA8888 images The fill color was not correctly converted before being filled into RGBA8888 images. This patch adds a function with convertion and adds tests for it to tst_qpainter. Change-Id: If8b0e6db38b2794a60301842e25f377eb7216796 Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-07-24 12:51:47 +00:00
void fillRect2_data();
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void fillRect2();
Fix fillRect on RGBA8888 images The fill color was not correctly converted before being filled into RGBA8888 images. This patch adds a function with convertion and adds tests for it to tst_qpainter. Change-Id: If8b0e6db38b2794a60301842e25f377eb7216796 Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-07-24 12:51:47 +00:00
void fillRect3_data() { fillRect2_data(); }
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void fillRect3();
Fix fillRect on RGBA8888 images The fill color was not correctly converted before being filled into RGBA8888 images. This patch adds a function with convertion and adds tests for it to tst_qpainter. Change-Id: If8b0e6db38b2794a60301842e25f377eb7216796 Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-07-24 12:51:47 +00:00
void fillRect4_data() { fillRect2_data(); }
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void fillRect4();
Solid and gradients in high color accuracy This patch updates the internal color precisions of solids and gradients to 16bit per color. This makes it possible to render at higher precision on non-premultiplied ARGB32, the RGB30 formats and any other hi-color formats if more are added. [ChangeLog][QtGui][Painting] Internal precision of solids and gradients is now up to 16bit per color. Change-Id: Ieae5468bd6de1f56adfa4cb9fa966faf2ed824fd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-11 10:13:03 +00:00
void fillRectNonPremul_data();
Fix fillRect on RGBA8888 images The fill color was not correctly converted before being filled into RGBA8888 images. This patch adds a function with convertion and adds tests for it to tst_qpainter. Change-Id: If8b0e6db38b2794a60301842e25f377eb7216796 Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-07-24 12:51:47 +00:00
void fillRectNonPremul();
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
Solid and gradients in high color accuracy This patch updates the internal color precisions of solids and gradients to 16bit per color. This makes it possible to render at higher precision on non-premultiplied ARGB32, the RGB30 formats and any other hi-color formats if more are added. [ChangeLog][QtGui][Painting] Internal precision of solids and gradients is now up to 16bit per color. Change-Id: Ieae5468bd6de1f56adfa4cb9fa966faf2ed824fd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-11 10:13:03 +00:00
void fillRectRGB30_data();
void fillRectRGB30();
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
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();
Make qpainter autotest build without widgets Change-Id: I4e05871e44f7a69aaa9cd5d876c249c7dd9d86e8 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-06-05 11:58:15 +00:00
#ifndef QT_NO_WIDGETS
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void initFrom();
Make qpainter autotest build without widgets Change-Id: I4e05871e44f7a69aaa9cd5d876c249c7dd9d86e8 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-06-05 11:58:15 +00:00
#endif
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
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 clipBoundingRect();
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();
Make qpainter autotest build without widgets Change-Id: I4e05871e44f7a69aaa9cd5d876c249c7dd9d86e8 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-06-05 11:58:15 +00:00
#ifndef QT_NO_WIDGETS
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void childWidgetViewport();
Make qpainter autotest build without widgets Change-Id: I4e05871e44f7a69aaa9cd5d876c249c7dd9d86e8 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-06-05 11:58:15 +00:00
#endif
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void fillRect_objectBoundingModeGradient();
void fillRect_stretchToDeviceMode();
void monoImages();
Improved gradient table generation performance for two-stop gradients. Two stops is a fairly common case so we gain quite a bit by special casing it. Improves performance by 10 % in parcycle benchmark, and by 90 % in a synthetic benchmark. Reviewed-by: Andreas Kling (cherry picked from commit 5b74a70ac630073582be56f8a0539624a1080185)
2011-04-13 08:15:06 +00:00
void linearGradientSymmetry_data();
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void linearGradientSymmetry();
void gradientInterpolation();
Fix drawing vertical gradients in RGBA8888 formats The RGBA8888 formats was incorrectly using the qt_gradient_quint32 which is argb specific. This caused vertical gradients but only vertical gradients to be drawn incorrectly. This changes the RGBA8888 formats formats to use the generic gradient method and renames qt_gradient_quint32 to qt_gradient_argb32 to indicate its limitation. Change-Id: Ia1cd48ca7f4f78b64f31d6263e81cd8ac3b0954e Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-02-07 13:38:47 +00:00
void gradientPixelFormat_data();
void gradientPixelFormat();
Implement radial and conical gradients for rgb64 rendering Adds the last two missing source types to rgb64 rendering. Conical and radial gradients. At the same time linear gradients are moved to a template form to increase code sharing. Change-Id: I30fdd0837b0da03e3447683856ebbe4d7f48df6c Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 16:27:49 +00:00
void linearGradientRgb30_data();
void linearGradientRgb30();
void radialGradientRgb30_data();
void radialGradientRgb30();
Fix RGB30 painting tests Some tests were failing because the color was not read correctly from a QImage. To make it possibly to read more accurate colors a pixel accessor returing QColor has been added. Some tests also had the wrong order of arguments, confusing dest and src formats. This has been corrected, so they test what they claim to test. A test for RGB30 linear gradients is also added. Change-Id: Ic623ae1b8e0bf7383056b641c6e8230a1d7dd0dd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 09:28:33 +00:00
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
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();
Fixed invalid memory read in SSSE3 image blending code. We need to do bounds comparison on the actual offset we're going to use with _mm_load_si128 to read 16 bytes from memory (even though we won't use the trailing bytes in the end). Task-number: QTBUG-28324 Change-Id: Id0d6094da796ca67338d8ad225fa6b2f309bbe6e Reviewed-by: Olivier Goffart <ogoffart@woboq.com>
2012-12-14 09:52:47 +00:00
void drawImage_QTBUG28324();
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void drawRect_task215378();
void drawRect_task247505();
test: Remove QSKIP from tst_QPainter::drawText_subPixelPositionsInRaster_qtbug5053() Change-Id: I1aa329323767a3e849beca8fe41e39dbe98de4ee Reviewed-by: Caroline Chao <caroline.chao@digia.com>
2012-10-29 22:21:35 +00:00
#if defined(Q_OS_MAC)
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void drawText_subPixelPositionsInRaster_qtbug5053();
test: Remove QSKIP from tst_QPainter::drawText_subPixelPositionsInRaster_qtbug5053() Change-Id: I1aa329323767a3e849beca8fe41e39dbe98de4ee Reviewed-by: Caroline Chao <caroline.chao@digia.com>
2012-10-29 22:21:35 +00:00
#endif
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
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();
void setPenColorOnImage();
void setPenColorOnPixmap();
Make qpainter autotest build without widgets Change-Id: I4e05871e44f7a69aaa9cd5d876c249c7dd9d86e8 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-06-05 11:58:15 +00:00
#ifndef QT_NO_WIDGETS
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void QTBUG5939_attachPainterPrivate();
Make qpainter autotest build without widgets Change-Id: I4e05871e44f7a69aaa9cd5d876c249c7dd9d86e8 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-06-05 11:58:15 +00:00
#endif
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void drawPointScaled();
void QTBUG14614_gradientCacheRaceCondition();
void drawTextOpacity();
void QTBUG17053_zeroDashPattern();
QPainter on QBitmap: make setBrush(NoBrush) work as expected. It had no effect because of an explicit check for NoBrush. However the default in QBitmap is (unfortunately) QBrush(color0), rather than NoBrush, so the brush must be updated when calling setBrush(NoBrush). I suppose the real issue is that lastBrush is default-constructed in QRasterPaintEngine, rather than starting with the brush from QPainter, which is QBrush(color0) for the case of the bitmap. But no reason to special case NoBrush here anyway. Task-Number: QTBUG-38781 Change-Id: I9996ac12bf628920cfaf0de9c886f637a336028b Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-05-05 17:02:46 +00:00
void QTBUG38781_NoBrushAndQBitmap();
Added autotest for threaded text rendering. Task-number: QTBUG-18516 Reviewed-by: TRUSTME (cherry picked from commit 903d4dc2196df2775255c24c707bfeb571992bb7)
2011-04-26 14:01:08 +00:00
void drawTextOutsideGuiThread();
Fix QPainter::drawText with complex brushes Commit d52fd497f60a3c4456994f4f10e9451d611c9ea4 introduced a call path to QPaintEngineEx::drawStaticTextItem, which has a bug in using the pen's color instead of the entire brush. This patch replaces the use of the color with the pen's brush(). Task-number: QTBUG-23450 Change-Id: Ieb3bf352c840ff0d3fb4ac678caf7b13f4f9a8f1 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@nokia.com>
2012-01-04 15:32:55 +00:00
void drawTextWithComplexBrush();
Fixed inconsistent rounding of square cap pens. A horizontal line should round up at the same time as a vertical line with square cap, when rendering at subpixel coordinates. Thus, the special casing in the cosmetic stroker of offsetting by half a pixel should be for flat caps instead of for square caps. Task-number: QTBUG-26013 Change-Id: Ic09249337f814c7de95a17976ec9e651561a744b Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-09-20 13:30:24 +00:00
void QTBUG26013_squareCapStroke();
Fixed cosmetic line drawing where begin and end points are equal. This case has typically required specific work-arounds in other rendering paths as well. Task-number: QTBUG-25153 Change-Id: I217e710a30222792ebca3bf297e438d944c32992 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-10-10 14:14:32 +00:00
void QTBUG25153_drawLine();
Fixed artifacts when drawing same line with different clips. Expanding on the change fixing QTBUG-24762 with the realization that any line needs to be drawn in a consistent way regardless of system or painter clip, not just dashed lines. Task-number: QTBUG-25036 Change-Id: Ief7ef19cc92c52e7d792500a581a072ba032767e Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-03-14 07:51:07 +00:00
void cosmeticStrokerClipping_data();
void cosmeticStrokerClipping();
Fix QPainter::drawText with complex brushes Commit d52fd497f60a3c4456994f4f10e9451d611c9ea4 introduced a call path to QPaintEngineEx::drawStaticTextItem, which has a bug in using the pen's color instead of the entire brush. This patch replaces the use of the color with the pen's brush(). Task-number: QTBUG-23450 Change-Id: Ieb3bf352c840ff0d3fb4ac678caf7b13f4f9a8f1 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@nokia.com>
2012-01-04 15:32:55 +00:00
Tests for semi transparent blend on opaque formats This patch adds tests for the consistent handling of transparent drawing results on opaque formats that was introduced with commit 6f7d370adec3054656f36b0d2a0777a8a1df3602 Change-Id: If5d11d0f2e111ef88490a4dc20a64b0858ad5426 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-01-23 09:44:08 +00:00
void blendARGBonRGB_data();
void blendARGBonRGB();
Fix default implementations of raster ops In the list of default implementations, the raster ops added in ae0ddb8c729c105a5b4f32a4f6765af8fe546333 were all offset by one composition mode because of a duplicate entry in the array. The effect would be, e.g. that using the NotDestination operator would resolve to the Set operator instead. Most users will probably not have experienced this since any of the asm-based functions will be preferred. [ChangeLog][Painting] Fixed some very rare cases of mismatched raster modes in QPainter. Change-Id: Ia242b54c78acbe1c89d9b4ecd10936564ec134b2 Task-number: QTBUG-41413 Reviewed-by: Andy Shaw <andy.shaw@digia.com>
2014-09-19 08:25:05 +00:00
void RasterOp_NotDestination();
Prevent buffer overrun when getting the glyph images The change 35bc3dc45aacaf36a8bdfccc7627136cc2e5b185 moved some padding out of QTextureGlyphCache into the font engines directly, however this was not done for the DirectWrite font engine so it caused a buffer overrun. Task-number: QTBUG-41782 Change-Id: I4e643159036f06c5edd8a742dc6694d517a47826 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@theqtcompany.com>
2015-01-05 13:26:03 +00:00
void drawTextNoHinting();
Fix rasterization errors in aliased cosmetic drawPolyLine If a cosmetic polyline contained a 1-pixel segment, the next segment would be drawn with wrong starting point. The original fix for QTBUG-26156 had some unwanted side effects (QTBUG-31579 and now QTBUG-42398). It tried to skip start-point update if stroke() did not actually draw anything (because the segment was too small). However, to determine that, it tested for a change in lastPixel. But that was not failsafe; in some cases (1-pixel segment), lastPixel could be unchanged even though the segment had been drawn. With this change, we instead test directly whether stroke() skipped the segment or not. Task-number: QTBUG-42398 Change-Id: Id751db69a18cd1af4f45070db9d5698aa532d22a Reviewed-by: Allan Sandfeld Jensen <allan.jensen@theqtcompany.com>
2015-03-19 07:46:56 +00:00
void drawPolyline_data();
void drawPolyline();
Fix rounding error in fetchTransformedBilinear To calculate the real count we need to use the actual fixed point increment and can not use the floating point value increment wass based on since it might round differently. Includes auto-test by Gabriel de Dietrich. Task-number: QTBUG-50153 Change-Id: Ia973088f361c90370fa20bac14a4b8f373b5d234 Reviewed-by: Gabriel de Dietrich <gabriel.dedietrich@theqtcompany.com> Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
2016-02-02 13:55:17 +00:00
void QTBUG50153_drawImage_assert();
Fix regression in rotated bilinear sampling Fix a mistake introduced recently and revealed by lancelot. Adds an auto-test for rotations to catch similar errors faster in the future. Change-Id: I028a160107d98899e723481b6201ef776f20c721 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2016-07-26 08:09:55 +00:00
void rotateImage_data();
void rotateImage();
Fix illegal memory access on simple image rotates Clip the transformed and rounded sourceClip to the source rectangle, so we don't try to rotate pixels outside the source. Task-number: QTBUG-56252 Change-Id: Ib9cb80f9856724118867aea37ead0b02a6c71495 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io> Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2016-10-05 13:45:55 +00:00
void QTBUG56252();
Fix blending of RGB32 on RGB32 with partial opacity The alpha channel of an RGB32 image was not properly ignored when doing blending with partial opacity. Now the alpha value is properly ignored, which is both more correct and faster. This also makes SSE2 and AVX2 implementations match NEON which was already doing the right thing (though had dead code for doing it wrong). Change-Id: I4613b8d70ed8c2e36ced10baaa7a4a55bd36a940 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2016-11-18 15:33:12 +00:00
void blendNullRGB32();
Fix qdrawhelper function toRGB64 The function was incorrectly handling green and blue color channels causing them to be dropped. This affects drawing non 32-bit images onto 10-bit per color channels formats such as RGB30. Change-Id: I9211e253b1a9da0dada5c418d592a8f531265989 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2016-12-07 12:03:44 +00:00
void toRGB64();
Fix blending of RGB32 on RGB32 with partial opacity The alpha channel of an RGB32 image was not properly ignored when doing blending with partial opacity. Now the alpha value is properly ignored, which is both more correct and faster. This also makes SSE2 and AVX2 implementations match NEON which was already doing the right thing (though had dead code for doing it wrong). Change-Id: I4613b8d70ed8c2e36ced10baaa7a4a55bd36a940 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2016-11-18 15:33:12 +00:00
Fix polygon stroking with cosmetic pen Fix a number of issues that caused polygons to not always be drawn fully connected. Ensures the original lastPixel is set when drawing closed polygons, ensure we don't round away from the original starting point, and add handling of edges that need to be rounded half a pixel sideways to line up with endpoints. Task-number: QTBUG-27053 Change-Id: Ib51ee5623a629996af51a0967096383f04e91e2f Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2017-07-04 15:24:04 +00:00
void fillPolygon();
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
private:
void fillData();
void setPenColor(QPainter& p);
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());
}
tst_QPainter::tst_QPainter()
{
// QtTestCase sets this to false, but this turns off alpha pixmaps on Unix.
Make qpainter autotest build without widgets Change-Id: I4e05871e44f7a69aaa9cd5d876c249c7dd9d86e8 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-06-05 11:58:15 +00:00
QGuiApplication::setDesktopSettingsAware(true);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
}
Changed painting unittests to remove created files after run. - qpainter cleans up temp files dest.png, expected.png and foo.png - qpainterpath clean up temp file data - qprinter cleans up silly, out1.ps, out2.ps, test.pdf and file.pdf Change-Id: Id434bea0bae5b970355206a250456e4beeca8060 Reviewed-by: Kurt Korbatits <kurt.korbatits@nokia.com> Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com> Reviewed-by: Jason McDonald <jason.mcdonald@nokia.com>
2012-01-23 00:53:15 +00:00
void tst_QPainter::cleanupTestCase()
{
QFile::remove(QLatin1String("dest.png"));
QFile::remove(QLatin1String("expected.png"));
QFile::remove(QLatin1String("foo.png"));
}
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
static const char* const maskSource_data[] = {
"16 13 6 1",
". c None",
"d c #000000",
"# c #999999",
"c c #cccccc",
"b c #ffff00",
"a c #ffffff",
"...#####........",
"..#aaaaa#.......",
".#abcbcba######.",
".#acbcbcaaaaaa#d",
".#abcbcbcbcbcb#d",
"#############b#d",
"#aaaaaaaaaa##c#d",
"#abcbcbcbcbbd##d",
".#abcbcbcbcbcd#d",
".#acbcbcbcbcbd#d",
"..#acbcbcbcbb#dd",
"..#############d",
"...ddddddddddddd"};
static const char* const maskResult_data[] = {
"16 13 6 1",
". c #ff0000",
"d c #000000",
"# c #999999",
"c c #cccccc",
"b c #ffff00",
"a c #ffffff",
"...#####........",
"..#aaaaa#.......",
".#abcbcba######.",
".#acbcbcaaaaaa#d",
".#abcbcbcbcbcb#d",
"#############b#d",
"#aaaaaaaaaa##c#d",
"#abcbcbcbcbbd##d",
".#abcbcbcbcbcd#d",
".#acbcbcbcbcbd#d",
"..#acbcbcbcbb#dd",
"..#############d",
"...ddddddddddddd"};
Make qpainter autotest build without widgets Change-Id: I4e05871e44f7a69aaa9cd5d876c249c7dd9d86e8 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-06-05 11:58:15 +00:00
#ifndef QT_NO_WIDGETS
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void tst_QPainter::drawPixmap_comp_data()
{
Remove SkipMode parameter from QSKIP calls. The previous commit removed SkipMode from the testlib APi. This commit removes the parameter from all calls to QSKIP. Task-number: QTBUG-21851, QTBUG-21652 Change-Id: I21c0ee6731c1bc6ac6d962590d9b31d7459dfbc5 Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com>
2011-10-19 02:53:13 +00:00
if (qApp->desktop()->depth() < 24)
QSKIP("Test only works on 32 bit displays");
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
QTest::addColumn<uint>("dest");
QTest::addColumn<uint>("source");
QTest::newRow("0% on 0%, 1") << 0x00000000u<< 0x00000000u;
QTest::newRow("0% on 0%, 2") << 0x00007fffu << 0x00ff007fu;
QTest::newRow("50% on a=0%") << 0x00000000u << 0x7fff0000u;
QTest::newRow("50% on a=50%") << 0x7f000000u << 0x7fff0000u;
QTest::newRow("50% on deadbeef") << 0xdeafbeefu << 0x7fff0000u;
QTest::newRow("deadbeef on a=0%") << 0x00000000u << 0xdeadbeefu;
QTest::newRow("deadbeef on a=50%") << 0x7f000000u << 0xdeadbeefu;
QTest::newRow("50% blue on 50% red") << 0x7fff0000u << 0x7f0000ffu;
QTest::newRow("50% blue on 50% green") << 0x7f00ff00u << 0x7f0000ffu;
QTest::newRow("50% red on 50% green") << 0x7f00ff00u << 0x7fff0000u;
QTest::newRow("0% on 50%") << 0x7fff00ffu << 0x00ffffffu;
QTest::newRow("100% on deadbeef") << 0xdeafbeefu << 0xffabcdefu;
QTest::newRow("100% on a=0%") << 0x00000000u << 0xffabcdefu;
}
QRgb qt_compose_alpha(QRgb source, QRgb dest)
{
int r1 = qRed(dest), g1 = qGreen(dest), b1 = qBlue(dest), a1 = qAlpha(dest);
int r2 = qRed(source), g2 = qGreen(source), b2 = qBlue(source), a2 = qAlpha(source);
int alpha = qMin(a2 + ((255 - a2) * a1 + 127) / 255, 255);
if (alpha == 0)
return qRgba(0, 0, 0, 0);
return qRgba(
qMin((r2 * a2 + (255 - a2) * r1 * a1 / 255) / alpha, 255),
qMin((g2 * a2 + (255 - a2) * g1 * a1 / 255) / alpha, 255),
qMin((b2 * a2 + (255 - a2) * b1 * a1 / 255) / alpha, 255),
alpha);
}
/* Tests that drawing masked pixmaps works
*/
void tst_QPainter::drawPixmap_comp()
{
Replace Q_WS_MAC with Q_OS_MAC in tests/auto/gui Change-Id: I6d69ac96597f27575dd40e4c80c982f06fa88f51 Reviewed-by: Robin Burchell <robin+qt@viroteck.net> Reviewed-by: João Abecasis <joao.abecasis@nokia.com>
2012-01-16 11:02:14 +00:00
#ifdef Q_OS_MAC
Don't depend on moc to disable test functions. The moc tool is not aware of all defines (particularly those that are compiler builtins) and does not correctly evaluate others that depend on compiler builtins, such as Q_OS_FOO. This commit reverts parts of the following commits, but is not a complete fix as there were many instances of this problem in the tests prior to those commits: 924d810dbdcd5b5b0fa860922b2487ea9062d002 8aaff6751038b88d17e23be6fcee945771297c5b 338d3f11973412047c2c9cd41cbd0c961d738ef3 a55034062ba2bf73a9f1ed3d9cf31745b38149e3 253497b7446c7d723aa3bdd7152e25d6852f2604 7cfad460c56319ba89c4a3a0bbcb2e54ab1cdbc6 9d2ff58f3642828e494e7e9b2df7dbb8e2cd408f 0cf6baa2d61ebaad2a2a0530c37f27e719b68f4b Change-Id: I947d797fe3ec76139ba1b55561cea569895662c5 Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com>
2011-11-15 01:36:18 +00:00
QSKIP("Mac has other ideas about alpha composition");
#endif
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
QFETCH(uint, dest);
QFETCH(uint, source);
QRgb expected = qt_compose_alpha(source, dest);
QColor c1(qRed(dest), qGreen(dest), qBlue(dest), qAlpha(dest));
QColor c2(qRed(source), qGreen(source), qBlue(source), qAlpha(source));
QPixmap destPm(10, 10), srcPm(10, 10);
destPm.fill(c1);
srcPm.fill(c2);
Change confusing Q_DEAD_CODE_FROM_QT4_FOO define Commit c5db8fc74 changed all instances of Q_WS_FOO to have the prefix Q_DEAD_CODE_FROM_QT4 instead, to make it clearer when reading the code that the code in question was a left-over from Qt4, when we used Q_WS_ defines instead of Q_OS_ defines. This worked well for cases of #ifdef Q_DEAD_CODE_FROM_QT4, but less so for cases of #ifndef Q_DEAD_CODE_FROM_QT4, where the code was actually unconditionally included. To make this even clearer, the defines have been replaced by checks for 1 or 0, with a comment describing how the code used to look in Qt4. The use of constants in the check also makes it easier for editors to parse the condition and show visually that the code is defined out. Change-Id: I152070d87334df7259b417cd5e17d7b7950379b7 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2016-10-13 13:54:23 +00:00
#if 0 // Used to be included in Qt4 for Q_WS_X11
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
if (!destPm.x11PictureHandle())
Remove SkipMode parameter from QSKIP calls. The previous commit removed SkipMode from the testlib APi. This commit removes the parameter from all calls to QSKIP. Task-number: QTBUG-21851, QTBUG-21652 Change-Id: I21c0ee6731c1bc6ac6d962590d9b31d7459dfbc5 Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com>
2011-10-19 02:53:13 +00:00
QSKIP("Requires XRender support");
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
#endif
QPainter p(&destPm);
p.drawPixmap(0, 0, srcPm);
p.end();
QImage result = destPm.toImage().convertToFormat(QImage::Format_ARGB32);
bool different = false;
for (int y=0; y<result.height(); ++y)
for (int x=0; x<result.width(); ++x) {
expand tabs and related whitespace fixes in *.{cpp,h,qdoc} the diff -w for this commit is empty. Started-by: Thiago Macieira <thiago.macieira@intel.com> Change-Id: I77bb84e71c63ce75e0709e5b94bee18e3ce6ab9e Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
2014-01-13 14:48:44 +00:00
bool diff;
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
if (qAlpha(expected) == 0) {
diff = qAlpha(result.pixel(x, y)) != 0;
} else {
// Compensate for possible roundoff / platform fudge
int off = 1;
QRgb pix = result.pixel(x, y);
diff = (qAbs(qRed(pix) - qRed(expected)) > off)
|| (qAbs(qGreen(pix) - qGreen(expected)) > off)
|| (qAbs(qBlue(pix) - qBlue(expected)) > off)
|| (qAbs(qAlpha(pix) - qAlpha(expected)) > off);
}
expand tabs and related whitespace fixes in *.{cpp,h,qdoc} the diff -w for this commit is empty. Started-by: Thiago Macieira <thiago.macieira@intel.com> Change-Id: I77bb84e71c63ce75e0709e5b94bee18e3ce6ab9e Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
2014-01-13 14:48:44 +00:00
if (diff && !different)
qDebug( "Different at %d,%d pixel [%d,%d,%d,%d] expected [%d,%d,%d,%d]", x, y,
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
qRed(result.pixel(x, y)), qGreen(result.pixel(x, y)),
qBlue(result.pixel(x, y)), qAlpha(result.pixel(x, y)),
qRed(expected), qGreen(expected), qBlue(expected), qAlpha(expected));
expand tabs and related whitespace fixes in *.{cpp,h,qdoc} the diff -w for this commit is empty. Started-by: Thiago Macieira <thiago.macieira@intel.com> Change-Id: I77bb84e71c63ce75e0709e5b94bee18e3ce6ab9e Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
2014-01-13 14:48:44 +00:00
different |= diff;
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
}
QVERIFY(!different);
}
Make qpainter autotest build without widgets Change-Id: I4e05871e44f7a69aaa9cd5d876c249c7dd9d86e8 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-06-05 11:58:15 +00:00
#endif
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void tst_QPainter::saveAndRestore_data()
{
QTest::addColumn<QFont>("font");
QTest::addColumn<QPen>("pen");
QTest::addColumn<QBrush>("brush");
QTest::addColumn<QColor>("backgroundColor");
QTest::addColumn<int>("backgroundMode");
QTest::addColumn<QPoint>("brushOrigin");
QTest::addColumn<QRegion>("clipRegion");
QTest::addColumn<QRect>("window");
QTest::addColumn<QRect>("viewport");
QPixmap pixmap(1, 1);
QPainter p(&pixmap);
QFont font = p.font();
QPen pen = p.pen();
QBrush brush = p.brush();
QColor backgroundColor = p.background().color();
Qt::BGMode backgroundMode = p.backgroundMode();
QPoint brushOrigin = p.brushOrigin();
QRegion clipRegion = p.clipRegion();
QRect window = p.window();
QRect viewport = p.viewport();
QTest::newRow("Original") << font << pen << brush << backgroundColor << int(backgroundMode)
expand tabs and related whitespace fixes in *.{cpp,h,qdoc} the diff -w for this commit is empty. Started-by: Thiago Macieira <thiago.macieira@intel.com> Change-Id: I77bb84e71c63ce75e0709e5b94bee18e3ce6ab9e Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
2014-01-13 14:48:44 +00:00
<< brushOrigin << clipRegion << window << viewport;
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
QFont font2 = font;
font2.setPointSize( 24 );
QTest::newRow("Modified font.pointSize, brush, backgroundColor, backgroundMode")
<< font2 << pen << QBrush(Qt::red) << QColor(Qt::blue) << int(Qt::TransparentMode)
expand tabs and related whitespace fixes in *.{cpp,h,qdoc} the diff -w for this commit is empty. Started-by: Thiago Macieira <thiago.macieira@intel.com> Change-Id: I77bb84e71c63ce75e0709e5b94bee18e3ce6ab9e Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
2014-01-13 14:48:44 +00:00
<< brushOrigin << clipRegion << window << viewport;
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
font2 = font;
font2.setPixelSize( 20 );
QTest::newRow("Modified font.pixelSize, brushOrigin, pos")
<< font2 << pen << brush << backgroundColor << int(backgroundMode)
expand tabs and related whitespace fixes in *.{cpp,h,qdoc} the diff -w for this commit is empty. Started-by: Thiago Macieira <thiago.macieira@intel.com> Change-Id: I77bb84e71c63ce75e0709e5b94bee18e3ce6ab9e Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
2014-01-13 14:48:44 +00:00
<< QPoint( 50, 32 ) << clipRegion << window << viewport;
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
QTest::newRow("Modified clipRegion, window, viewport")
<< font << pen << brush << backgroundColor << int(backgroundMode)
expand tabs and related whitespace fixes in *.{cpp,h,qdoc} the diff -w for this commit is empty. Started-by: Thiago Macieira <thiago.macieira@intel.com> Change-Id: I77bb84e71c63ce75e0709e5b94bee18e3ce6ab9e Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
2014-01-13 14:48:44 +00:00
<< brushOrigin << clipRegion.subtracted(QRect(10,10,50,30))
<< QRect(-500, -500, 500, 500 ) << QRect( 0, 0, 50, 50 );
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
}
void tst_QPainter::saveAndRestore()
{
QFETCH( QFont, font );
QFETCH( QPen, pen );
QFETCH( QBrush, brush );
QFETCH( QColor, backgroundColor );
QFETCH( int, backgroundMode );
QFETCH( QPoint, brushOrigin );
QFETCH( QRegion, clipRegion );
QFETCH( QRect, window );
QFETCH( QRect, viewport );
QPixmap pixmap(1, 1);
QPainter painter(&pixmap);
QFont font_org = painter.font();
QPen pen_org = painter.pen();
QBrush brush_org = painter.brush();
QColor backgroundColor_org = painter.background().color();
Qt::BGMode backgroundMode_org = painter.backgroundMode();
QPoint brushOrigin_org = painter.brushOrigin();
QRegion clipRegion_org = painter.clipRegion();
QRect window_org = painter.window();
QRect viewport_org = painter.viewport();
painter.save();
painter.setFont( font );
painter.setPen( QPen(pen) );
painter.setBrush( brush );
painter.setBackground( backgroundColor );
painter.setBackgroundMode( (Qt::BGMode)backgroundMode );
painter.setBrushOrigin( brushOrigin );
painter.setClipRegion( clipRegion );
painter.setWindow( window );
painter.setViewport( viewport );
painter.restore();
QCOMPARE( painter.font(), font_org );
QCOMPARE( painter.font().pointSize(), font_org.pointSize() );
QCOMPARE( painter.font().pixelSize(), font_org.pixelSize() );
QCOMPARE( painter.pen(), pen_org );
QCOMPARE( painter.brush(), brush_org );
QCOMPARE( painter.background().color(), backgroundColor_org );
QCOMPARE( painter.backgroundMode(), backgroundMode_org );
QCOMPARE( painter.brushOrigin(), brushOrigin_org );
QCOMPARE( painter.clipRegion(), clipRegion_org );
QCOMPARE( painter.window(), window_org );
QCOMPARE( painter.viewport(), viewport_org );
}
/*
Helper functions
*/
QColor tst_QPainter::baseColor( int k, int intensity )
{
int r = ( k & 1 ) * intensity;
int g = ( (k>>1) & 1 ) * intensity;
int b = ( (k>>2) & 1 ) * intensity;
return QColor( r, g, b );
}
QImage tst_QPainter::getResImage( const QString &dir, const QString &addition, const QString &extension )
{
QImage res;
tests/auto/gui: Remove some placeholder formatting. Use QByteArray/QString addition instead in loops and for test row names. Change-Id: I31adb60bdaf7ea243143a9244b6c4f66f38b189d Reviewed-by: Jędrzej Nowacki <jedrzej.nowacki@theqtcompany.com>
2015-10-15 11:10:20 +00:00
QString resFilename = dir + QLatin1String("/res_") + addition + QLatin1Char('.') + extension;
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
if ( !res.load( resFilename ) ) {
QWARN(QString("Could not load result data %s %1").arg(resFilename).toLatin1());
return QImage();
}
return res;
}
QBitmap tst_QPainter::getBitmap( const QString &dir, const QString &filename, bool mask )
{
QBitmap bm;
tests/auto/gui: Remove some placeholder formatting. Use QByteArray/QString addition instead in loops and for test row names. Change-Id: I31adb60bdaf7ea243143a9244b6c4f66f38b189d Reviewed-by: Jędrzej Nowacki <jedrzej.nowacki@theqtcompany.com>
2015-10-15 11:10:20 +00:00
QString bmFilename = dir + QLatin1Char('/') + filename + QLatin1String(".xbm");
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
if ( !bm.load( bmFilename ) ) {
QWARN(QString("Could not load bitmap '%1'").arg(bmFilename).toLatin1());
return QBitmap();
}
if ( mask ) {
expand tabs and related whitespace fixes in *.{cpp,h,qdoc} the diff -w for this commit is empty. Started-by: Thiago Macieira <thiago.macieira@intel.com> Change-Id: I77bb84e71c63ce75e0709e5b94bee18e3ce6ab9e Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
2014-01-13 14:48:44 +00:00
QBitmap mask;
tests/auto/gui: Remove some placeholder formatting. Use QByteArray/QString addition instead in loops and for test row names. Change-Id: I31adb60bdaf7ea243143a9244b6c4f66f38b189d Reviewed-by: Jędrzej Nowacki <jedrzej.nowacki@theqtcompany.com>
2015-10-15 11:10:20 +00:00
QString maskFilename = dir + QLatin1Char('/') + filename + QLatin1String("-mask.xbm");
expand tabs and related whitespace fixes in *.{cpp,h,qdoc} the diff -w for this commit is empty. Started-by: Thiago Macieira <thiago.macieira@intel.com> Change-Id: I77bb84e71c63ce75e0709e5b94bee18e3ce6ab9e Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
2014-01-13 14:48:44 +00:00
if (!mask.load(maskFilename)) {
QWARN(QString("Could not load mask '%1'").arg(maskFilename).toLatin1());
return QBitmap();
}
bm.setMask( mask );
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
}
return bm;
}
static int getPaintedPixels(const QImage &image, const QColor &background)
{
uint color = background.rgba();
int pixels = 0;
for (int y = 0; y < image.height(); ++y)
for (int x = 0; x < image.width(); ++x)
if (image.pixel(x, y) != color)
++pixels;
return pixels;
}
static QRect getPaintedSize(const QImage &image, const QColor &background)
{
// not the fastest but at least it works..
int xmin = image.width() + 1;
int xmax = -1;
int ymin = image.height() +1;
int ymax = -1;
uint color = background.rgba();
for ( int y = 0; y < image.height(); ++y ) {
expand tabs and related whitespace fixes in *.{cpp,h,qdoc} the diff -w for this commit is empty. Started-by: Thiago Macieira <thiago.macieira@intel.com> Change-Id: I77bb84e71c63ce75e0709e5b94bee18e3ce6ab9e Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
2014-01-13 14:48:44 +00:00
for (int x = 0; x < image.width(); ++x) {
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
QRgb pixel = image.pixel( x, y );
expand tabs and related whitespace fixes in *.{cpp,h,qdoc} the diff -w for this commit is empty. Started-by: Thiago Macieira <thiago.macieira@intel.com> Change-Id: I77bb84e71c63ce75e0709e5b94bee18e3ce6ab9e Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
2014-01-13 14:48:44 +00:00
if (pixel != color && x < xmin)
xmin = x;
if (pixel != color && x > xmax)
xmax = x;
if (pixel != color && y < ymin)
ymin = y;
if (pixel != color && y > ymax)
ymax = y;
}
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
}
return QRect(xmin, ymin, xmax - xmin + 1, ymax - ymin + 1);
}
static QRect getPaintedSize(const QPixmap &pm, const QColor &background)
{
return getPaintedSize(pm.toImage(), background);
}
Make qpainter autotest build without widgets Change-Id: I4e05871e44f7a69aaa9cd5d876c249c7dd9d86e8 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-06-05 11:58:15 +00:00
#ifndef QT_NO_WIDGETS
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void tst_QPainter::initFrom()
{
QWidget *widget = new QWidget();
QPalette pal = widget->palette();
pal.setColor(QPalette::Foreground, QColor(255, 0, 0));
pal.setBrush(QPalette::Background, QColor(0, 255, 0));
widget->setPalette(pal);
Make sure widget is polished before checking its font QWidget is polished when show() is called, so unless you do this first, QWidget::font() will return a default constructed QFont, and not necessarily the default specified in the platform theme. Comparing this to QPainter::font() later, which has been resolved against the platform theme font, and not the default constructed font, you can get a mismatch and a false test failure. This happened on Android. Change-Id: I41ef5b10879bbd4bb8ef8d52ecaccf5e8e894075 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-01-06 14:41:05 +00:00
widget->show();
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
QFont font = widget->font();
font.setPointSize(26);
font.setItalic(true);
widget->setFont(font);
QPixmap pm(100, 100);
QPainter p(&pm);
p.initFrom(widget);
QCOMPARE(p.font(), font);
QCOMPARE(p.pen().color(), pal.color(QPalette::Foreground));
QCOMPARE(p.background(), pal.background());
delete widget;
}
void tst_QPainter::drawBorderPixmap()
{
QPixmap src(79,79);
src.fill(Qt::transparent);
QImage pm(200,200,QImage::Format_RGB32);
QPainter p(&pm);
p.setTransform(QTransform(-1,0,0,-1,173.5,153.5));
qDrawBorderPixmap(&p, QRect(0,0,75,105), QMargins(39,39,39,39), src, QRect(0,0,79,79), QMargins(39,39,39,39),
QTileRules(Qt::StretchTile,Qt::StretchTile), 0);
}
Make qpainter autotest build without widgets Change-Id: I4e05871e44f7a69aaa9cd5d876c249c7dd9d86e8 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-06-05 11:58:15 +00:00
#endif
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void tst_QPainter::drawPixmapFragments()
{
QPixmap origPixmap(20, 20);
QPixmap resPixmap(20, 20);
QPainter::PixmapFragment fragments[4] = { {15, 15, 0, 0, 10, 10, 1, 1, 0, 1},
{ 5, 15, 10, 0, 10, 10, 1, 1, 0, 1},
{15, 5, 0, 10, 10, 10, 1, 1, 0, 1},
{ 5, 5, 10, 10, 10, 10, 1, 1, 0, 1} };
{
QPainter p(&origPixmap);
p.fillRect(0, 0, 10, 10, Qt::red);
p.fillRect(10, 0, 10, 10, Qt::green);
p.fillRect(0, 10, 10, 10, Qt::blue);
p.fillRect(10, 10, 10, 10, Qt::yellow);
}
{
QPainter p(&resPixmap);
p.drawPixmapFragments(fragments, 4, origPixmap);
}
QImage origImage = origPixmap.toImage().convertToFormat(QImage::Format_ARGB32);
QImage resImage = resPixmap.toImage().convertToFormat(QImage::Format_ARGB32);
tests/auto/gui: Replace Q[TRY]_VERIFY(a == b) by Q[TRY]_COMPARE(a, b). - Replace Q[TRY]_VERIFY(pointer == 0) by Q[TRY]_VERIFY(!pointer). - Replace Q[TRY]_VERIFY(smartPointer == 0) by Q[TRY]_VERIFY(smartPointer.isNull()). - Replace Q[TRY]_VERIFY(a == b) by Q[TRY]_COMPARE(a, b) and add casts where necessary. The values will then be logged should a test fail. Change-Id: I624deb320c378c18a29b3707f48583d53bfd5186 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@theqtcompany.com>
2015-07-30 13:15:12 +00:00
QCOMPARE(resImage.size(), resPixmap.size());
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
QVERIFY(resImage.pixel(5, 5) == origImage.pixel(15, 15));
QVERIFY(resImage.pixel(5, 15) == origImage.pixel(15, 5));
QVERIFY(resImage.pixel(15, 5) == origImage.pixel(5, 15));
QVERIFY(resImage.pixel(15, 15) == origImage.pixel(5, 5));
QPainter::PixmapFragment fragment = QPainter::PixmapFragment::create(QPointF(20, 20), QRectF(30, 30, 2, 2));
tests/auto/gui: Replace Q[TRY]_VERIFY(a == b) by Q[TRY]_COMPARE(a, b). - Replace Q[TRY]_VERIFY(pointer == 0) by Q[TRY]_VERIFY(!pointer). - Replace Q[TRY]_VERIFY(smartPointer == 0) by Q[TRY]_VERIFY(smartPointer.isNull()). - Replace Q[TRY]_VERIFY(a == b) by Q[TRY]_COMPARE(a, b) and add casts where necessary. The values will then be logged should a test fail. Change-Id: I624deb320c378c18a29b3707f48583d53bfd5186 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@theqtcompany.com>
2015-07-30 13:15:12 +00:00
QCOMPARE(fragment.x, qreal(20));
QCOMPARE(fragment.y, qreal(20));
QCOMPARE(fragment.sourceLeft, qreal(30));
QCOMPARE(fragment.sourceTop, qreal(30));
QCOMPARE(fragment.width, qreal(2));
QCOMPARE(fragment.height, qreal(2));
QCOMPARE(fragment.scaleX, qreal(1));
QCOMPARE(fragment.scaleY, qreal(1));
QCOMPARE(fragment.rotation, qreal(0));
QCOMPARE(fragment.opacity, qreal(1));
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
}
qpa: Fix rendering issue in blitter engine (negative scaling factors) A 180° rotation results in a TxScale QTransform with negative scaling factors (x=-1.0 y=-1.0). This is not properly handled by blitter paint engine yet, so use software rendering fallback in this case. This rendering issue can be seen when using "-webkit-transform" CSS property in WebKit with DirectFB QPA platform. Change-Id: Iee496b6bf0c90ffe36c4235ceaa2c80f296b2ca4 Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>
2012-11-07 10:01:08 +00:00
void tst_QPainter::drawPixmapNegativeScale()
{
// basePixmap is a 16x16 opaque white square ...
QPixmap basePixmap(16, 16);
basePixmap.fill(QColor(255, 255, 255, 255));
// ... with an opaque black 8x16 left strip
QPainter p(&basePixmap);
p.setCompositionMode(QPainter::CompositionMode_Source);
p.fillRect(QRect(0, 0, 8, 16), QColor(0, 0, 0, 255));
p.end();
// verify one pixel value for each strip
QImage baseImage = basePixmap.toImage().convertToFormat(QImage::Format_ARGB32);
QVERIFY(baseImage.pixel(4, 8) == qRgba(0, 0, 0, 255));
QVERIFY(baseImage.pixel(12, 8) == qRgba(255, 255, 255, 255));
// resultPixmap is a 16x16 square
QPixmap resultPixmap(16, 16);
// draw basePixmap over resultPixmap using x=-1.0 y=-1.0
// scaling factors (i.e. 180° rotation)
QPainter p2(&resultPixmap);
p2.setCompositionMode(QPainter::CompositionMode_Source);
p2.scale(qreal(-1.0), qreal(-1.0));
p2.translate(-resultPixmap.width(), -resultPixmap.height());
p2.drawPixmap(resultPixmap.rect(), basePixmap);
p2.end();
// check result
QImage resultImage = resultPixmap.toImage().convertToFormat(QImage::Format_ARGB32);
QVERIFY(resultImage.pixel(4, 8) == qRgba(255, 255, 255, 255)); // left strip is now white
QVERIFY(resultImage.pixel(12, 8) == qRgba(0, 0, 0, 255)); // and right strip is now black
}
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void tst_QPainter::drawLine_data()
{
QTest::addColumn<QLine>("line");
QTest::newRow("0-45") << QLine(0, 20, 100, 0);
QTest::newRow("45-90") << QLine(0, 100, 20, 0);
QTest::newRow("90-135") << QLine(20, 100, 0, 0);
QTest::newRow("135-180") << QLine(100, 20, 0, 0);
QTest::newRow("180-225") << QLine(100, 0, 0, 20);
QTest::newRow("225-270") << QLine(20, 0, 0, 100);
QTest::newRow("270-315") << QLine(0, 0, 20, 100);
QTest::newRow("315-360") << QLine(0, 0, 100, 20);
}
void tst_QPainter::drawLine()
{
const int offset = 5;
const int epsilon = 1; // allow for one pixel difference
QFETCH(QLine, line);
QPixmap pixmapUnclipped(qMin(line.x1(), line.x2())
+ 2*offset + qAbs(line.dx()),
qMin(line.y1(), line.y2())
+ 2*offset + qAbs(line.dy()));
{ // unclipped
pixmapUnclipped.fill(Qt::white);
QPainter p(&pixmapUnclipped);
Fixed inconsistent QPainter fill rules for aliased painting. Qt 5 is the time to get rid of all the old inconsistencies in the raster paint engine caused by trying to preserve the old X11 based coordinate system where (0, 0) is in the center of the top-left pixel instead of the upper left corner of said pixel. However, this was only adhered for line drawing and path / rect filling, and not for image or pixmap drawing and not at all when doing antialiased painting. By defining the antialiased coordinate system as being the right one and letting the aliased fill rules follow from that we finally end up with some consistent behavior that doesn't lead to surprises and workarounds in application code. It is still possible for applications to get the old behavior by setting the QPainter::Qt4CompatiblePainting render hint. This should make porting easier for the few cases where an application relies on the aliased fill rules we used to have in Qt 4. Task-number: QTBUG-27500 Change-Id: If86b95e77d838ec83033d64af86632b9a73c74a9 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-10-10 10:38:07 +00:00
p.setRenderHint(QPainter::Qt4CompatiblePainting);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
p.translate(offset, offset);
p.setPen(QPen(Qt::black));
p.drawLine(line);
p.end();
const QRect painted = getPaintedSize(pixmapUnclipped, Qt::white);
QLine l = line;
l.translate(offset, offset);
QVERIFY(qAbs(painted.width() - qAbs(l.dx())) <= epsilon);
QVERIFY(qAbs(painted.height() - qAbs(l.dy())) <= epsilon);
QVERIFY(qAbs(painted.top() - qMin(l.y1(), l.y2())) <= epsilon);
QVERIFY(qAbs(painted.left() - qMin(l.x1(), l.x2())) <= epsilon);
QVERIFY(qAbs(painted.bottom() - qMax(l.y1(), l.y2())) <= epsilon);
QVERIFY(qAbs(painted.right() - qMax(l.x1(), l.x2())) <= epsilon);
}
QPixmap pixmapClipped(qMin(line.x1(), line.x2())
+ 2*offset + qAbs(line.dx()),
qMin(line.y1(), line.y2())
+ 2*offset + qAbs(line.dy()));
{ // clipped
const QRect clip = QRect(line.p1(), line.p2()).normalized();
pixmapClipped.fill(Qt::white);
QPainter p(&pixmapClipped);
Fixed inconsistent QPainter fill rules for aliased painting. Qt 5 is the time to get rid of all the old inconsistencies in the raster paint engine caused by trying to preserve the old X11 based coordinate system where (0, 0) is in the center of the top-left pixel instead of the upper left corner of said pixel. However, this was only adhered for line drawing and path / rect filling, and not for image or pixmap drawing and not at all when doing antialiased painting. By defining the antialiased coordinate system as being the right one and letting the aliased fill rules follow from that we finally end up with some consistent behavior that doesn't lead to surprises and workarounds in application code. It is still possible for applications to get the old behavior by setting the QPainter::Qt4CompatiblePainting render hint. This should make porting easier for the few cases where an application relies on the aliased fill rules we used to have in Qt 4. Task-number: QTBUG-27500 Change-Id: If86b95e77d838ec83033d64af86632b9a73c74a9 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-10-10 10:38:07 +00:00
p.setRenderHint(QPainter::Qt4CompatiblePainting);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
p.translate(offset, offset);
p.setClipRect(clip);
p.setPen(QPen(Qt::black));
p.drawLine(line);
p.end();
}
const QImage unclipped = pixmapUnclipped.toImage();
const QImage clipped = pixmapClipped.toImage();
QCOMPARE(unclipped, clipped);
}
void tst_QPainter::drawLine_clipped()
{
QImage image(16, 1, QImage::Format_ARGB32_Premultiplied);
image.fill(0x0);
QPainter p(&image);
p.setPen(QPen(Qt::black, 10));
// this should fill the whole image
p.drawLine(-1, -1, 17, 1);
p.end();
for (int x = 0; x < 16; ++x)
QCOMPARE(image.pixel(x, 0), 0xff000000);
}
void tst_QPainter::drawLine_task121143()
{
QPen pen(Qt::black);
QImage image(5, 5, QImage::Format_ARGB32_Premultiplied);
image.fill(0xffffffff);
QPainter p(&image);
p.setPen(pen);
Fixed inconsistent QPainter fill rules for aliased painting. Qt 5 is the time to get rid of all the old inconsistencies in the raster paint engine caused by trying to preserve the old X11 based coordinate system where (0, 0) is in the center of the top-left pixel instead of the upper left corner of said pixel. However, this was only adhered for line drawing and path / rect filling, and not for image or pixmap drawing and not at all when doing antialiased painting. By defining the antialiased coordinate system as being the right one and letting the aliased fill rules follow from that we finally end up with some consistent behavior that doesn't lead to surprises and workarounds in application code. It is still possible for applications to get the old behavior by setting the QPainter::Qt4CompatiblePainting render hint. This should make porting easier for the few cases where an application relies on the aliased fill rules we used to have in Qt 4. Task-number: QTBUG-27500 Change-Id: If86b95e77d838ec83033d64af86632b9a73c74a9 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-10-10 10:38:07 +00:00
p.setRenderHint(QPainter::Qt4CompatiblePainting);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
p.drawLine(QLine(0, 0+4, 0+4, 0));
p.end();
QImage expected(5, 5, QImage::Format_ARGB32_Premultiplied);
expected.fill(0xffffffff);
for (int x = 0; x < 5; ++x)
expected.setPixel(x, 5-x-1, pen.color().rgb());
QCOMPARE(image, expected);
}
void tst_QPainter::drawLine_task190634()
{
QPen pen(Qt::black, 3);
QImage image(32, 32, QImage::Format_ARGB32_Premultiplied);
QPainter p(&image);
p.fillRect(0, 0, image.width(), image.height(), Qt::white);
p.setPen(pen);
p.drawLine(QLineF(2, -1.6, 10, -1.6));
p.end();
const uint *data = reinterpret_cast<uint *>(image.bits());
for (int i = 0; i < image.width() * image.height(); ++i)
QCOMPARE(data[i], 0xffffffff);
p.begin(&image);
p.fillRect(0, 0, image.width(), image.height(), Qt::white);
p.setPen(pen);
p.drawLine(QLineF(-1.6, 2, -1.6, 10));
p.end();
data = reinterpret_cast<uint *>(image.bits());
for (int i = 0; i < image.width() * image.height(); ++i)
QCOMPARE(data[i], 0xffffffff);
p.begin(&image);
p.fillRect(0, 0, image.width(), image.height(), Qt::white);
p.setPen(pen);
p.drawLine( QPoint(2,-2), QPoint(3,-5) );
p.end();
data = reinterpret_cast<uint *>(image.bits());
for (int i = 0; i < image.width() * image.height(); ++i)
QCOMPARE(data[i], 0xffffffff);
}
void tst_QPainter::drawLine_task229459()
{
QImage image(32, 32, QImage::Format_ARGB32_Premultiplied);
image.fill(0x0);
QPen pen(Qt::black, 64);
QPainter p(&image);
p.setPen(pen);
p.drawLine(-8, -8, 10000000, 10000000);
p.end();
QImage expected = image;
expected.fill(0xff000000);
QCOMPARE(image, expected);
}
void tst_QPainter::drawLine_task234891()
{
QImage img(100, 1000, QImage::Format_ARGB32_Premultiplied);
img.fill(0x0);
QImage expected = img;
QPainter p(&img);
p.setPen(QPen(QBrush(QColor(255,0,0)), 6));
p.drawLine(QPointF(25000,100),QPointF(30000,105));
p.setPen(QPen(QBrush(QColor(0,255,0)), 6));
p.drawLine(QPointF(30000,150),QPointF(35000,155));
p.setPen(QPen(QBrush(QColor(0,0,255)), 6));
p.drawLine(QPointF(65000,200),QPointF(66000,205));
QCOMPARE(expected, img);
}
void tst_QPainter::drawLine_task216948()
{
QImage img(1, 10, QImage::Format_ARGB32_Premultiplied);
img.fill(0x0);
QPainter p(&img);
QLine line(10, 0, 10, 10);
p.translate(-10, 0);
p.drawLine(line);
p.end();
for (int i = 0; i < img.height(); ++i)
QCOMPARE(img.pixel(0, i), QColor(Qt::black).rgba());
}
Improve rounding in QCosmeticStroker Fixes the drawn position of end points in drawLine. Based on a patch by Jørgen Lind, and modified so that it caused no test regressions. Task-number: QTBUG-38144 Change-Id: I24aa28480cc6ae09abf91d80378970565a29b254 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-03-11 16:14:50 +00:00
void tst_QPainter::drawLineEndPoints()
{
QImage img(256, 256, QImage::Format_ARGB32_Premultiplied);
img.fill(0x0);
QPainter p;
for (int x = 0; x < img.width(); ++x) {
QRgb color = qRgb(x, 0, 0);
p.begin(&img);
p.setPen(QPen(color));
p.drawLine(x, 0, 255 - x, 255);
p.end();
QCOMPARE(img.pixel(x, 0), color);
QCOMPARE(img.pixel(255 - x, 255), color);
}
for (int y = 0; y < img.height(); ++y) {
QRgb color = qRgb(0, y, 0);
p.begin(&img);
p.setPen(QPen(color));
p.drawLine(0, y, 255, 255 - y);
p.end();
QCOMPARE(img.pixel(0, y), color);
QCOMPARE(img.pixel(255, 255 - y), color);
}
for (int x = 0; x < img.width(); ++x) {
QRgb color = qRgb(x, 0, x);
p.begin(&img);
p.setPen(QPen(color));
p.drawLine(x, 255, 255 - x, 0);
p.end();
QCOMPARE(img.pixel(x, 255), color);
QCOMPARE(img.pixel(255 - x, 0), color);
}
for (int y = 0; y < img.height(); ++y) {
QRgb color = qRgb(0, y, y);
p.begin(&img);
p.setPen(QPen(color));
p.drawLine(255, y, 0, 255 - y);
p.end();
QCOMPARE(img.pixel(255, y), color);
QCOMPARE(img.pixel(0, 255 - y), color);
}
}
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void tst_QPainter::drawRect()
{
QFETCH(QRect, rect);
QFETCH(bool, usePen);
QPixmap pixmap(rect.x() + rect.width() + 10,
rect.y() + rect.height() + 10);
{
pixmap.fill(Qt::white);
QPainter p(&pixmap);
p.setPen(usePen ? QPen(Qt::black) : QPen(Qt::NoPen));
p.setBrush(Qt::black);
p.drawRect(rect);
p.end();
int increment = usePen ? 1 : 0;
const QRect painted = getPaintedSize(pixmap, Qt::white);
QCOMPARE(painted.width(), rect.width() + increment);
QCOMPARE(painted.height(), rect.height() + increment);
}
}
void tst_QPainter::drawRect2()
{
QImage image(64, 64, QImage::Format_ARGB32_Premultiplied);
{
image.fill(0xffffffff);
QTransform transform(0.368567, 0, 0, 0, 0.368567, 0, 0.0289, 0.0289, 1);
QPainter p(&image);
Fixed inconsistent QPainter fill rules for aliased painting. Qt 5 is the time to get rid of all the old inconsistencies in the raster paint engine caused by trying to preserve the old X11 based coordinate system where (0, 0) is in the center of the top-left pixel instead of the upper left corner of said pixel. However, this was only adhered for line drawing and path / rect filling, and not for image or pixmap drawing and not at all when doing antialiased painting. By defining the antialiased coordinate system as being the right one and letting the aliased fill rules follow from that we finally end up with some consistent behavior that doesn't lead to surprises and workarounds in application code. It is still possible for applications to get the old behavior by setting the QPainter::Qt4CompatiblePainting render hint. This should make porting easier for the few cases where an application relies on the aliased fill rules we used to have in Qt 4. Task-number: QTBUG-27500 Change-Id: If86b95e77d838ec83033d64af86632b9a73c74a9 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-10-10 10:38:07 +00:00
p.setRenderHint(QPainter::Qt4CompatiblePainting);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
p.setTransform(transform);
p.setBrush(Qt::red);
p.setPen(Qt::NoPen);
p.drawRect(QRect(14, 14, 39, 39));
p.end();
QRect fill = getPaintedSize(image, Qt::white);
image.fill(0xffffffff);
p.begin(&image);
Fixed inconsistent QPainter fill rules for aliased painting. Qt 5 is the time to get rid of all the old inconsistencies in the raster paint engine caused by trying to preserve the old X11 based coordinate system where (0, 0) is in the center of the top-left pixel instead of the upper left corner of said pixel. However, this was only adhered for line drawing and path / rect filling, and not for image or pixmap drawing and not at all when doing antialiased painting. By defining the antialiased coordinate system as being the right one and letting the aliased fill rules follow from that we finally end up with some consistent behavior that doesn't lead to surprises and workarounds in application code. It is still possible for applications to get the old behavior by setting the QPainter::Qt4CompatiblePainting render hint. This should make porting easier for the few cases where an application relies on the aliased fill rules we used to have in Qt 4. Task-number: QTBUG-27500 Change-Id: If86b95e77d838ec83033d64af86632b9a73c74a9 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-10-10 10:38:07 +00:00
p.setRenderHint(QPainter::Qt4CompatiblePainting);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
p.setTransform(transform);
p.drawRect(QRect(14, 14, 39, 39));
p.end();
QRect stroke = getPaintedSize(image, Qt::white);
Revert "fix breakages in qpainter autotests." This reverts commit 50a53d2f7a7e12cd597dc72a08ad62b79fee4554. ...which was required because of 69fc9e594e6d5da87bff42707973683f84b67c93 "Fix how subpixel positions are intepreted in an aliased grid." which was reverted in f8e85838c5531b56c2175cbdb9c24db426f7fd89 because of 37c329a3e35fabc88fbcad824a69f37c671d2132 "New algorithm for drawing thin lines". phew! (cherry picked from commit 14bf7c3761efe208ce19047b8ddc3f811a63a437) Change-Id: I16d672685efb1901927190c58ef1477c89d946c1 Reviewed-on: http://codereview.qt.nokia.com/604 Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com> Reviewed-by: Lars Knoll <lars.knoll@nokia.com>
2011-05-19 10:48:35 +00:00
QCOMPARE(stroke.adjusted(1, 1, 0, 0), fill.adjusted(0, 0, 1, 1));
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
}
}
Fix fillRect on RGBA8888 images The fill color was not correctly converted before being filled into RGBA8888 images. This patch adds a function with convertion and adds tests for it to tst_qpainter. Change-Id: If8b0e6db38b2794a60301842e25f377eb7216796 Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-07-24 12:51:47 +00:00
void tst_QPainter::fillRect_data()
{
QTest::addColumn<QImage::Format>("format");
QTest::newRow("argb32pm") << QImage::Format_ARGB32_Premultiplied;
QTest::newRow("rgba8888pm") << QImage::Format_RGBA8888_Premultiplied;
}
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void tst_QPainter::fillRect()
{
Fix fillRect on RGBA8888 images The fill color was not correctly converted before being filled into RGBA8888 images. This patch adds a function with convertion and adds tests for it to tst_qpainter. Change-Id: If8b0e6db38b2794a60301842e25f377eb7216796 Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-07-24 12:51:47 +00:00
QFETCH(QImage::Format, format);
QImage image(100, 100, format);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
image.fill(QColor(0, 0, 0, 0).rgba());
QPainter p(&image);
p.fillRect(0, 0, 100, 100, QColor(255, 0, 0, 127));
// pixmap.save("bla1.png", "PNG");
QCOMPARE(getPaintedSize(image, QColor(0, 0, 0, 0)),
QRect(0, 0, 100, 100));
QCOMPARE(getPaintedSize(image, QColor(127, 0, 0, 127)).isValid(),
QRect().isValid());
p.setCompositionMode(QPainter::CompositionMode_SourceIn);
p.fillRect(50, 0, 50, 100, QColor(0, 0, 255, 255));
QCOMPARE(getPaintedSize(image, QColor(127, 0, 0, 127)),
QRect(50, 0, 50, 100));
QCOMPARE(getPaintedSize(image, QColor(0, 0, 127, 127)),
QRect(0, 0, 50, 100));
}
Fix fillRect on RGBA8888 images The fill color was not correctly converted before being filled into RGBA8888 images. This patch adds a function with convertion and adds tests for it to tst_qpainter. Change-Id: If8b0e6db38b2794a60301842e25f377eb7216796 Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-07-24 12:51:47 +00:00
void tst_QPainter::fillRect2_data()
{
QTest::addColumn<QImage::Format>("format");
QTest::newRow("argb32") << QImage::Format_ARGB32;
QTest::newRow("argb32pm") << QImage::Format_ARGB32_Premultiplied;
QTest::newRow("rgba8888") << QImage::Format_RGBA8888;
QTest::newRow("rgba8888pm") << QImage::Format_RGBA8888_Premultiplied;
QImage support for RGB30 formats Adds basic support for 10-bit per color channel formats to QImage and the XCB plugin. This will make it possible to paint to and from these formats, but only at 8-bit per color channel accuracy. This also fixes Qt5 applications on X11 with native 30bit depth. [ChangeLog][QtGui][QImage] Added support for 10-bit per color channel image formats. Task-number: QTBUG-25998 Change-Id: I93ccd3c74bfbb0bd94b352476e5fe58a94119e1f Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-05-26 10:07:18 +00:00
QTest::newRow("a2rgb30pm") << QImage::Format_A2RGB30_Premultiplied;
QTest::newRow("a2bgr30pm") << QImage::Format_A2BGR30_Premultiplied;
Fix fillRect on RGBA8888 images The fill color was not correctly converted before being filled into RGBA8888 images. This patch adds a function with convertion and adds tests for it to tst_qpainter. Change-Id: If8b0e6db38b2794a60301842e25f377eb7216796 Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-07-24 12:51:47 +00:00
}
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void tst_QPainter::fillRect2()
{
Fix fillRect on RGBA8888 images The fill color was not correctly converted before being filled into RGBA8888 images. This patch adds a function with convertion and adds tests for it to tst_qpainter. Change-Id: If8b0e6db38b2794a60301842e25f377eb7216796 Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-07-24 12:51:47 +00:00
QFETCH(QImage::Format, format);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
QRgb background = 0x0;
Fix fillRect on RGBA8888 images The fill color was not correctly converted before being filled into RGBA8888 images. This patch adds a function with convertion and adds tests for it to tst_qpainter. Change-Id: If8b0e6db38b2794a60301842e25f377eb7216796 Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-07-24 12:51:47 +00:00
QImage img(1, 20, format);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
img.fill(background);
QPainter p(&img);
QRectF rect(0, 1, 1.2, 18);
Fix fillRect on RGBA8888 images The fill color was not correctly converted before being filled into RGBA8888 images. This patch adds a function with convertion and adds tests for it to tst_qpainter. Change-Id: If8b0e6db38b2794a60301842e25f377eb7216796 Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-07-24 12:51:47 +00:00
p.fillRect(rect, Qt::yellow);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
p.end();
QCOMPARE(img.pixel(0, 0), background);
QCOMPARE(img.pixel(0, img.height() - 1), background);
QCOMPARE(img.pixel(0, 1), img.pixel(0, 2));
QCOMPARE(img.pixel(0, img.height() - 2), img.pixel(0, img.height() - 3));
Fix fillRect on RGBA8888 images The fill color was not correctly converted before being filled into RGBA8888 images. This patch adds a function with convertion and adds tests for it to tst_qpainter. Change-Id: If8b0e6db38b2794a60301842e25f377eb7216796 Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-07-24 12:51:47 +00:00
QCOMPARE(img.pixel(0, 1), QColor(Qt::yellow).rgba());
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
}
void tst_QPainter::fillRect3()
{
Fix fillRect on RGBA8888 images The fill color was not correctly converted before being filled into RGBA8888 images. This patch adds a function with convertion and adds tests for it to tst_qpainter. Change-Id: If8b0e6db38b2794a60301842e25f377eb7216796 Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-07-24 12:51:47 +00:00
QFETCH(QImage::Format, format);
QImage img(1, 1, format);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
img.fill(QColor(Qt::black).rgba());
QPainter p(&img);
p.setCompositionMode(QPainter::CompositionMode_Source);
p.fillRect(img.rect(), Qt::transparent);
p.end();
QCOMPARE(img.pixel(0, 0), 0U);
}
void tst_QPainter::fillRect4()
{
Fix fillRect on RGBA8888 images The fill color was not correctly converted before being filled into RGBA8888 images. This patch adds a function with convertion and adds tests for it to tst_qpainter. Change-Id: If8b0e6db38b2794a60301842e25f377eb7216796 Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-07-24 12:51:47 +00:00
QFETCH(QImage::Format, format);
QImage image(100, 1, format);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
image.fill(0x0);
QImage expected = image;
expected.fill(0xffffffff);
QPainter p(&image);
p.scale(1.1, 1);
p.setPen(Qt::NoPen);
for (int i = 0; i < 33; ++i)
p.fillRect(QRectF(3 * i, 0, 3, 1), Qt::white);
p.end();
QCOMPARE(image, expected);
}
Solid and gradients in high color accuracy This patch updates the internal color precisions of solids and gradients to 16bit per color. This makes it possible to render at higher precision on non-premultiplied ARGB32, the RGB30 formats and any other hi-color formats if more are added. [ChangeLog][QtGui][Painting] Internal precision of solids and gradients is now up to 16bit per color. Change-Id: Ieae5468bd6de1f56adfa4cb9fa966faf2ed824fd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-11 10:13:03 +00:00
void tst_QPainter::fillRectNonPremul_data()
{
QTest::addColumn<QImage::Format>("format");
QTest::addColumn<uint>("color");
QTest::newRow("argb32 7f1f3f7f") << QImage::Format_ARGB32 << qRgba(31, 63, 127, 127);
QTest::newRow("rgba8888 7f1f3f7f") << QImage::Format_RGBA8888 << qRgba(31, 63, 127, 127);
QTest::newRow("argb32 3f1f3f7f") << QImage::Format_ARGB32 << qRgba(31, 63, 127, 63);
QTest::newRow("rgba8888 3f1f3f7f") << QImage::Format_RGBA8888 << qRgba(31, 63, 127, 63);
QTest::newRow("argb32 070375f4") << QImage::Format_ARGB32 << qRgba(3, 117, 244, 7);
QTest::newRow("rgba8888 070375f4") << QImage::Format_RGBA8888 << qRgba(3, 117, 244, 7);
QTest::newRow("argb32 0301fe0c") << QImage::Format_ARGB32 << qRgba(1, 254, 12, 3);
QTest::newRow("rgba8888 0301fe0c") << QImage::Format_RGBA8888 << qRgba(1, 254, 12, 3);
QTest::newRow("argb32 01804010") << QImage::Format_ARGB32 << qRgba(128, 64, 32, 1);
QTest::newRow("rgba8888 01804010") << QImage::Format_RGBA8888 << qRgba(128, 64, 32, 1);
}
Fix fillRect on RGBA8888 images The fill color was not correctly converted before being filled into RGBA8888 images. This patch adds a function with convertion and adds tests for it to tst_qpainter. Change-Id: If8b0e6db38b2794a60301842e25f377eb7216796 Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-07-24 12:51:47 +00:00
void tst_QPainter::fillRectNonPremul()
{
Solid and gradients in high color accuracy This patch updates the internal color precisions of solids and gradients to 16bit per color. This makes it possible to render at higher precision on non-premultiplied ARGB32, the RGB30 formats and any other hi-color formats if more are added. [ChangeLog][QtGui][Painting] Internal precision of solids and gradients is now up to 16bit per color. Change-Id: Ieae5468bd6de1f56adfa4cb9fa966faf2ed824fd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-11 10:13:03 +00:00
QFETCH(QImage::Format, format);
QFETCH(uint, color);
Fix fillRect on RGBA8888 images The fill color was not correctly converted before being filled into RGBA8888 images. This patch adds a function with convertion and adds tests for it to tst_qpainter. Change-Id: If8b0e6db38b2794a60301842e25f377eb7216796 Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-07-24 12:51:47 +00:00
Solid and gradients in high color accuracy This patch updates the internal color precisions of solids and gradients to 16bit per color. This makes it possible to render at higher precision on non-premultiplied ARGB32, the RGB30 formats and any other hi-color formats if more are added. [ChangeLog][QtGui][Painting] Internal precision of solids and gradients is now up to 16bit per color. Change-Id: Ieae5468bd6de1f56adfa4cb9fa966faf2ed824fd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-11 10:13:03 +00:00
QImage image(1, 1, format);
QRectF rect(0, 0, 1, 1);
// Fill with CompositionMode_SourceOver tests blend_color
image.fill(Qt::transparent);
QPainter painter(&image);
painter.fillRect(rect, QColor::fromRgba(color));
painter.end();
// Fill with CompositionMode_Source tests rectfill.
painter.begin(&image);
painter.setCompositionMode(QPainter::CompositionMode_Source);
painter.fillRect(rect, QColor::fromRgba(color));
painter.end();
QRgb p = image.pixel(0, 0);
QCOMPARE(qAlpha(p), qAlpha(color));
QVERIFY(qAbs(qRed(p)-qRed(color)) <= 1);
QVERIFY(qAbs(qGreen(p)-qGreen(color)) <= 1);
QVERIFY(qAbs(qBlue(p)-qBlue(color)) <= 1);
}
void tst_QPainter::fillRectRGB30_data()
{
QTest::addColumn<uint>("color");
Fix fillRect on RGBA8888 images The fill color was not correctly converted before being filled into RGBA8888 images. This patch adds a function with convertion and adds tests for it to tst_qpainter. Change-Id: If8b0e6db38b2794a60301842e25f377eb7216796 Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-07-24 12:51:47 +00:00
Solid and gradients in high color accuracy This patch updates the internal color precisions of solids and gradients to 16bit per color. This makes it possible to render at higher precision on non-premultiplied ARGB32, the RGB30 formats and any other hi-color formats if more are added. [ChangeLog][QtGui][Painting] Internal precision of solids and gradients is now up to 16bit per color. Change-Id: Ieae5468bd6de1f56adfa4cb9fa966faf2ed824fd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-11 10:13:03 +00:00
QTest::newRow("17|43|259") << (0xc0000000 | (17 << 20) | (43 << 10) | 259);
QTest::newRow("2|33|444") << (0xc0000000 | (2 << 20) | (33 << 10) | 444);
QTest::newRow("1000|1000|1000") << (0xc0000000 | (1000 << 20) | (1000 << 10) | 1000);
}
void tst_QPainter::fillRectRGB30()
{
QFETCH(uint, color);
Fix fillRect on RGBA8888 images The fill color was not correctly converted before being filled into RGBA8888 images. This patch adds a function with convertion and adds tests for it to tst_qpainter. Change-Id: If8b0e6db38b2794a60301842e25f377eb7216796 Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-07-24 12:51:47 +00:00
QRectF rect(0, 0, 1, 1);
Solid and gradients in high color accuracy This patch updates the internal color precisions of solids and gradients to 16bit per color. This makes it possible to render at higher precision on non-premultiplied ARGB32, the RGB30 formats and any other hi-color formats if more are added. [ChangeLog][QtGui][Painting] Internal precision of solids and gradients is now up to 16bit per color. Change-Id: Ieae5468bd6de1f56adfa4cb9fa966faf2ed824fd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-11 10:13:03 +00:00
// Fill with CompositionMode_SourceOver tests blend_color
QImage image1(1, 1, QImage::Format_A2BGR30_Premultiplied);
image1.fill(Qt::transparent);
QPainter painter(&image1);
painter.fillRect(rect, QColor::fromRgba64(qConvertA2rgb30ToRgb64<PixelOrderBGR>(color)));
painter.end();
Fix fillRect on RGBA8888 images The fill color was not correctly converted before being filled into RGBA8888 images. This patch adds a function with convertion and adds tests for it to tst_qpainter. Change-Id: If8b0e6db38b2794a60301842e25f377eb7216796 Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-07-24 12:51:47 +00:00
Solid and gradients in high color accuracy This patch updates the internal color precisions of solids and gradients to 16bit per color. This makes it possible to render at higher precision on non-premultiplied ARGB32, the RGB30 formats and any other hi-color formats if more are added. [ChangeLog][QtGui][Painting] Internal precision of solids and gradients is now up to 16bit per color. Change-Id: Ieae5468bd6de1f56adfa4cb9fa966faf2ed824fd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-11 10:13:03 +00:00
uint pixel1 = ((const uint*)(image1.bits()))[0];
QCOMPARE(pixel1, color);
// Fill with CompositionMode_Source tests rectfill.
QImage image2(1, 1, QImage::Format_RGB30);
painter.begin(&image2);
painter.setCompositionMode(QPainter::CompositionMode_Source);
painter.fillRect(rect, QColor::fromRgba64(qConvertA2rgb30ToRgb64<PixelOrderRGB>(color)));
painter.end();
uint pixel2 = ((const uint*)(image2.bits()))[0];
QCOMPARE(pixel2, color);
Fix fillRect on RGBA8888 images The fill color was not correctly converted before being filled into RGBA8888 images. This patch adds a function with convertion and adds tests for it to tst_qpainter. Change-Id: If8b0e6db38b2794a60301842e25f377eb7216796 Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-07-24 12:51:47 +00:00
}
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void tst_QPainter::drawPath_data()
{
QTest::addColumn<QPainterPath>("path");
QTest::addColumn<QRect>("expectedBounds");
QTest::addColumn<int>("expectedPixels");
{
QPainterPath p;
p.addRect(2, 2, 10, 10);
QTest::newRow("int-aligned rect") << p << QRect(2, 2, 10, 10) << 10 * 10;
}
{
QPainterPath p;
p.addRect(2.25, 2.25, 10, 10);
Revert "fix breakages in qpainter autotests." This reverts commit 50a53d2f7a7e12cd597dc72a08ad62b79fee4554. ...which was required because of 69fc9e594e6d5da87bff42707973683f84b67c93 "Fix how subpixel positions are intepreted in an aliased grid." which was reverted in f8e85838c5531b56c2175cbdb9c24db426f7fd89 because of 37c329a3e35fabc88fbcad824a69f37c671d2132 "New algorithm for drawing thin lines". phew! (cherry picked from commit 14bf7c3761efe208ce19047b8ddc3f811a63a437) Change-Id: I16d672685efb1901927190c58ef1477c89d946c1 Reviewed-on: http://codereview.qt.nokia.com/604 Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com> Reviewed-by: Lars Knoll <lars.knoll@nokia.com>
2011-05-19 10:48:35 +00:00
QTest::newRow("non-aligned rect") << p << QRect(3, 3, 10, 10) << 10 * 10;
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
}
{
QPainterPath p;
p.addRect(2.25, 2.25, 10.5, 10.5);
Revert "fix breakages in qpainter autotests." This reverts commit 50a53d2f7a7e12cd597dc72a08ad62b79fee4554. ...which was required because of 69fc9e594e6d5da87bff42707973683f84b67c93 "Fix how subpixel positions are intepreted in an aliased grid." which was reverted in f8e85838c5531b56c2175cbdb9c24db426f7fd89 because of 37c329a3e35fabc88fbcad824a69f37c671d2132 "New algorithm for drawing thin lines". phew! (cherry picked from commit 14bf7c3761efe208ce19047b8ddc3f811a63a437) Change-Id: I16d672685efb1901927190c58ef1477c89d946c1 Reviewed-on: http://codereview.qt.nokia.com/604 Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com> Reviewed-by: Lars Knoll <lars.knoll@nokia.com>
2011-05-19 10:48:35 +00:00
QTest::newRow("non-aligned rect 2") << p << QRect(3, 3, 10, 10) << 10 * 10;
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
}
{
QPainterPath p;
p.addRect(2.5, 2.5, 10, 10);
QTest::newRow("non-aligned rect 3") << p << QRect(3, 3, 10, 10) << 10 * 10;
}
{
QPainterPath p;
p.addRect(2, 2, 10, 10);
p.addRect(4, 4, 6, 6);
QTest::newRow("rect-in-rect") << p << QRect(2, 2, 10, 10) << 10 * 10 - 6 * 6;
}
{
QPainterPath p;
p.addRect(2, 2, 10, 10);
p.addRect(4, 4, 6, 6);
p.addRect(6, 6, 2, 2);
QTest::newRow("rect-in-rect-in-rect") << p << QRect(2, 2, 10, 10) << 10 * 10 - 6 * 6 + 2 * 2;
}
}
void tst_QPainter::drawPath()
{
QFETCH(QPainterPath, path);
QFETCH(QRect, expectedBounds);
QFETCH(int, expectedPixels);
const int offset = 2;
QImage image(expectedBounds.width() + 2 * offset, expectedBounds.height() + 2 * offset,
QImage::Format_ARGB32_Premultiplied);
image.fill(QColor(Qt::white).rgb());
QPainter p(&image);
Fixed inconsistent QPainter fill rules for aliased painting. Qt 5 is the time to get rid of all the old inconsistencies in the raster paint engine caused by trying to preserve the old X11 based coordinate system where (0, 0) is in the center of the top-left pixel instead of the upper left corner of said pixel. However, this was only adhered for line drawing and path / rect filling, and not for image or pixmap drawing and not at all when doing antialiased painting. By defining the antialiased coordinate system as being the right one and letting the aliased fill rules follow from that we finally end up with some consistent behavior that doesn't lead to surprises and workarounds in application code. It is still possible for applications to get the old behavior by setting the QPainter::Qt4CompatiblePainting render hint. This should make porting easier for the few cases where an application relies on the aliased fill rules we used to have in Qt 4. Task-number: QTBUG-27500 Change-Id: If86b95e77d838ec83033d64af86632b9a73c74a9 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-10-10 10:38:07 +00:00
p.setRenderHint(QPainter::Qt4CompatiblePainting);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
p.setPen(Qt::NoPen);
p.setBrush(Qt::black);
p.translate(offset - expectedBounds.left(), offset - expectedBounds.top());
p.drawPath(path);
p.end();
const QRect paintedBounds = getPaintedSize(image, Qt::white);
QCOMPARE(paintedBounds.x(), offset);
QCOMPARE(paintedBounds.y(), offset);
QCOMPARE(paintedBounds.width(), expectedBounds.width());
QCOMPARE(paintedBounds.height(), expectedBounds.height());
if (expectedPixels != -1) {
int paintedPixels = getPaintedPixels(image, Qt::white);
QCOMPARE(paintedPixels, expectedPixels);
}
}
void tst_QPainter::drawPath2()
{
const int w = 50;
for (int h = 5; h < 200; ++h) {
QPainterPath p1, p2;
p1.lineTo(w, 0);
p1.lineTo(w, h);
p2.lineTo(w, h);
p2.lineTo(0, h);
const int offset = 2;
QImage image(w + 2 * offset, h + 2 * offset,
QImage::Format_ARGB32_Premultiplied);
image.fill(QColor(Qt::white).rgb());
QPainter p(&image);
p.setPen(Qt::NoPen);
p.setBrush(Qt::black);
p.translate(offset, offset);
p.drawPath(p1);
p.end();
const int p1Pixels = getPaintedPixels(image, Qt::white);
image.fill(QColor(Qt::white).rgb());
p.begin(&image);
p.setPen(Qt::NoPen);
p.setBrush(Qt::black);
p.translate(offset, offset);
p.drawPath(p2);
p.end();
const int p2Pixels = getPaintedPixels(image, Qt::white);
QCOMPARE(p1Pixels + p2Pixels, w * h);
}
}
void tst_QPainter::drawPath3()
{
QImage imgA(100, 100, QImage::Format_RGB32);
imgA.fill(0xffffff);
QImage imgB = imgA;
QPainterPath path;
for (int y = 0; y < imgA.height(); ++y) {
for (int x = 0; x < imgA.width(); ++x) {
if ((x + y) & 1) {
imgA.setPixel(x, y, 0);
path.addRect(x, y, 1, 1);
}
}
}
QPainter p(&imgB);
p.setPen(Qt::NoPen);
p.setBrush(Qt::black);
p.drawPath(path);
p.end();
tests/auto/gui: Replace Q[TRY]_VERIFY(a == b) by Q[TRY]_COMPARE(a, b). - Replace Q[TRY]_VERIFY(pointer == 0) by Q[TRY]_VERIFY(!pointer). - Replace Q[TRY]_VERIFY(smartPointer == 0) by Q[TRY]_VERIFY(smartPointer.isNull()). - Replace Q[TRY]_VERIFY(a == b) by Q[TRY]_COMPARE(a, b) and add casts where necessary. The values will then be logged should a test fail. Change-Id: I624deb320c378c18a29b3707f48583d53bfd5186 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@theqtcompany.com>
2015-07-30 13:15:12 +00:00
QCOMPARE(imgA, imgB);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
imgA.invertPixels();
imgB.fill(0xffffff);
p.begin(&imgB);
p.setPen(Qt::NoPen);
p.setBrush(Qt::black);
QRectF rect(0, 0, imgA.width(), imgA.height());
path.addRect(rect.adjusted(-10, -10, 10, 10));
p.drawPath(path);
p.end();
tests/auto/gui: Replace Q[TRY]_VERIFY(a == b) by Q[TRY]_COMPARE(a, b). - Replace Q[TRY]_VERIFY(pointer == 0) by Q[TRY]_VERIFY(!pointer). - Replace Q[TRY]_VERIFY(smartPointer == 0) by Q[TRY]_VERIFY(smartPointer.isNull()). - Replace Q[TRY]_VERIFY(a == b) by Q[TRY]_COMPARE(a, b) and add casts where necessary. The values will then be logged should a test fail. Change-Id: I624deb320c378c18a29b3707f48583d53bfd5186 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@theqtcompany.com>
2015-07-30 13:15:12 +00:00
QCOMPARE(imgA, imgB);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
path.setFillRule(Qt::WindingFill);
imgB.fill(0xffffff);
p.begin(&imgB);
p.setPen(Qt::NoPen);
p.setBrush(Qt::black);
QRect clip = rect.adjusted(10, 10, -10, -10).toRect();
p.setClipRect(clip);
p.drawPath(path);
p.end();
QCOMPARE(getPaintedPixels(imgB, Qt::white), clip.width() * clip.height());
}
void tst_QPainter::drawEllipse_data()
{
QTest::addColumn<QSize>("size");
QTest::addColumn<bool>("usePen");
// The current drawEllipse algorithm (drawEllipse_midpoint_i in
// qpaintengine_raster.cpp) draws ellipses that are too wide if the
// ratio between width and hight is too large/small (task 114874). Those
// ratios are therefore currently avoided.
for (int w = 10; w < 128; w += 7) {
tests/auto/gui: Remove some placeholder formatting. Use QByteArray/QString addition instead in loops and for test row names. Change-Id: I31adb60bdaf7ea243143a9244b6c4f66f38b189d Reviewed-by: Jędrzej Nowacki <jedrzej.nowacki@theqtcompany.com>
2015-10-15 11:10:20 +00:00
const QByteArray wB = QByteArray::number(w);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
for (int h = w/2; h < qMin(2*w, 128); h += 13) {
tests/auto/gui: Remove some placeholder formatting. Use QByteArray/QString addition instead in loops and for test row names. Change-Id: I31adb60bdaf7ea243143a9244b6c4f66f38b189d Reviewed-by: Jędrzej Nowacki <jedrzej.nowacki@theqtcompany.com>
2015-10-15 11:10:20 +00:00
const QByteArray sB = wB + 'x' + QByteArray::number(h);
QTest::newRow((sB + " with pen").constData()) << QSize(w, h) << true;
QTest::newRow((sB + " no pen").constData()) << QSize(w, h) << false;
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
}
}
}
void tst_QPainter::drawEllipse()
{
QFETCH(QSize, size);
QFETCH(bool, usePen);
const int offset = 10;
QRect rect(QPoint(offset, offset), size);
QImage image(size.width() + 2 * offset, size.height() + 2 * offset,
QImage::Format_ARGB32_Premultiplied);
image.fill(QColor(Qt::white).rgb());
QPainter p(&image);
p.setPen(usePen ? QPen(Qt::black) : QPen(Qt::NoPen));
p.setBrush(Qt::black);
p.drawEllipse(rect);
p.end();
QPixmap pixmap = QPixmap::fromImage(image);
const QRect painted = getPaintedSize(pixmap, Qt::white);
QCOMPARE(painted.x(), rect.x());
QCOMPARE(painted.y(), rect.y() + (usePen ? 0 : 1));
QCOMPARE(painted.width(), size.width() + (usePen ? 1 : 0));
QCOMPARE(painted.height(), size.height() + (usePen ? 1 : -1));
}
void tst_QPainter::drawClippedEllipse_data()
{
QTest::addColumn<QRect>("rect");
for (int w = 20; w < 128; w += 7) {
tests/auto/gui: Remove some placeholder formatting. Use QByteArray/QString addition instead in loops and for test row names. Change-Id: I31adb60bdaf7ea243143a9244b6c4f66f38b189d Reviewed-by: Jędrzej Nowacki <jedrzej.nowacki@theqtcompany.com>
2015-10-15 11:10:20 +00:00
const QByteArray wB = QByteArray::number(w);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
for (int h = w/2; h < qMin(2*w, 128); h += 13) {
tests/auto/gui: Remove some placeholder formatting. Use QByteArray/QString addition instead in loops and for test row names. Change-Id: I31adb60bdaf7ea243143a9244b6c4f66f38b189d Reviewed-by: Jędrzej Nowacki <jedrzej.nowacki@theqtcompany.com>
2015-10-15 11:10:20 +00:00
const QByteArray sB = wB + 'x' + QByteArray::number(h);
QTest::newRow((sB + " top").constData()) << QRect(0, -h/2, w, h);
QTest::newRow((sB + " topright").constData()) << QRect(w/2, -h/2, w, h);
QTest::newRow((sB + " right").constData()) << QRect(w/2, 0, w, h);
QTest::newRow((sB + " bottomright").constData()) << QRect(w/2, h/2, w, h);
QTest::newRow((sB + " bottom").constData()) << QRect(0, h/2, w, h);
QTest::newRow((sB + " bottomleft").constData()) << QRect(-w/2, h/2, w, h);
QTest::newRow((sB + " left").constData()) << QRect(-w/2, 0, w, h);
QTest::newRow((sB + " topleft").constData()) << QRect(-w/2, -h/2, w, h);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
}
}
}
void tst_QPainter::drawClippedEllipse()
{
QFETCH(QRect, rect);
if (sizeof(qreal) != sizeof(double))
Remove SkipMode parameter from QSKIP calls. The previous commit removed SkipMode from the testlib APi. This commit removes the parameter from all calls to QSKIP. Task-number: QTBUG-21851, QTBUG-21652 Change-Id: I21c0ee6731c1bc6ac6d962590d9b31d7459dfbc5 Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com>
2011-10-19 02:53:13 +00:00
QSKIP("Test only works for qreal==double");
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
QImage image(rect.width() + 1, rect.height() + 1,
QImage::Format_ARGB32_Premultiplied);
QRect expected = QRect(rect.x(), rect.y(), rect.width()+1, rect.height()+1)
& QRect(0, 0, image.width(), image.height());
image.fill(QColor(Qt::white).rgb());
QPainter p(&image);
p.drawEllipse(rect);
p.end();
QPixmap pixmap = QPixmap::fromImage(image);
const QRect painted = getPaintedSize(pixmap, Qt::white);
QCOMPARE(painted.x(), expected.x());
QCOMPARE(painted.y(), expected.y());
QCOMPARE(painted.width(), expected.width());
QCOMPARE(painted.height(), expected.height());
}
void tst_QPainter::drawRoundRect()
{
QFETCH(QRect, rect);
QFETCH(bool, usePen);
Replace Q_WS_MAC with Q_OS_MAC in tests/auto/gui Change-Id: I6d69ac96597f27575dd40e4c80c982f06fa88f51 Reviewed-by: Robin Burchell <robin+qt@viroteck.net> Reviewed-by: João Abecasis <joao.abecasis@nokia.com>
2012-01-16 11:02:14 +00:00
#ifdef Q_OS_MAC
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
if (QTest::currentDataTag() == QByteArray("rect(6, 12, 3, 14) with pen") ||
QTest::currentDataTag() == QByteArray("rect(6, 17, 3, 25) with pen") ||
QTest::currentDataTag() == QByteArray("rect(10, 6, 10, 3) with pen") ||
QTest::currentDataTag() == QByteArray("rect(10, 12, 10, 14) with pen") ||
QTest::currentDataTag() == QByteArray("rect(13, 45, 17, 80) with pen") ||
QTest::currentDataTag() == QByteArray("rect(13, 50, 17, 91) with pen") ||
QTest::currentDataTag() == QByteArray("rect(17, 6, 24, 3) with pen") ||
QTest::currentDataTag() == QByteArray("rect(24, 12, 38, 14) with pen"))
Remove SkipMode parameter from QSKIP calls. The previous commit removed SkipMode from the testlib APi. This commit removes the parameter from all calls to QSKIP. Task-number: QTBUG-21851, QTBUG-21652 Change-Id: I21c0ee6731c1bc6ac6d962590d9b31d7459dfbc5 Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com>
2011-10-19 02:53:13 +00:00
QSKIP("The Mac paint engine is off-by-one on certain rect sizes");
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
#endif
QPixmap pixmap(rect.x() + rect.width() + 10,
rect.y() + rect.height() + 10);
{
pixmap.fill(Qt::white);
QPainter p(&pixmap);
Fixed inconsistent QPainter fill rules for aliased painting. Qt 5 is the time to get rid of all the old inconsistencies in the raster paint engine caused by trying to preserve the old X11 based coordinate system where (0, 0) is in the center of the top-left pixel instead of the upper left corner of said pixel. However, this was only adhered for line drawing and path / rect filling, and not for image or pixmap drawing and not at all when doing antialiased painting. By defining the antialiased coordinate system as being the right one and letting the aliased fill rules follow from that we finally end up with some consistent behavior that doesn't lead to surprises and workarounds in application code. It is still possible for applications to get the old behavior by setting the QPainter::Qt4CompatiblePainting render hint. This should make porting easier for the few cases where an application relies on the aliased fill rules we used to have in Qt 4. Task-number: QTBUG-27500 Change-Id: If86b95e77d838ec83033d64af86632b9a73c74a9 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-10-10 10:38:07 +00:00
p.setRenderHint(QPainter::Qt4CompatiblePainting);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
p.setPen(usePen ? QPen(Qt::black) : QPen(Qt::NoPen));
p.setBrush(Qt::black);
p.drawRoundRect(rect);
p.end();
int increment = usePen ? 1 : 0;
const QRect painted = getPaintedSize(pixmap, Qt::white);
QCOMPARE(painted.width(), rect.width() + increment);
QCOMPARE(painted.height(), rect.height() + increment);
}
}
void tst_QPainter::qimageFormats_data()
{
QTest::addColumn<QImage::Format>("format");
QTest::newRow("QImage::Format_RGB32") << QImage::Format_RGB32;
QTest::newRow("QImage::Format_ARGB32") << QImage::Format_ARGB32;
QTest::newRow("QImage::Format_ARGB32_Premultiplied") << QImage::Format_ARGB32_Premultiplied;
QTest::newRow("QImage::Format_RGB16") << QImage::Format_RGB16;
QTest::newRow("Qimage::Format_ARGB8565_Premultiplied") << QImage::Format_ARGB8565_Premultiplied;
QTest::newRow("Qimage::Format_RGB666") << QImage::Format_RGB666;
QTest::newRow("Qimage::Format_RGB555") << QImage::Format_RGB555;
QTest::newRow("Qimage::Format_ARGB8555_Premultiplied") << QImage::Format_ARGB8555_Premultiplied;
QTest::newRow("Qimage::Format_RGB888") << QImage::Format_RGB888;
QImage support for RGB30 formats Adds basic support for 10-bit per color channel formats to QImage and the XCB plugin. This will make it possible to paint to and from these formats, but only at 8-bit per color channel accuracy. This also fixes Qt5 applications on X11 with native 30bit depth. [ChangeLog][QtGui][QImage] Added support for 10-bit per color channel image formats. Task-number: QTBUG-25998 Change-Id: I93ccd3c74bfbb0bd94b352476e5fe58a94119e1f Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-05-26 10:07:18 +00:00
QTest::newRow("Qimage::Format_A2RGB30_Premultiplied") << QImage::Format_A2RGB30_Premultiplied;
QTest::newRow("Qimage::Format_RGB30") << QImage::Format_RGB30;
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
}
/*
Tests that QPainter can paint on various QImage formats.
*/
void tst_QPainter::qimageFormats()
{
QFETCH(QImage::Format, format);
const QSize size(100, 100);
QImage image(size, format);
image.fill(0);
const QColor testColor(Qt::red);
QPainter p(&image);
QVERIFY(p.isActive());
p.setBrush(QBrush(testColor));
p.drawRect(QRect(QPoint(0,0), size));
QCOMPARE(image.pixel(50, 50), testColor.rgb());
}
void tst_QPainter::fillData()
{
QTest::addColumn<QRect>("rect");
QTest::addColumn<bool>("usePen");
for (int w = 3; w < 50; w += 7) {
tests/auto/gui: Remove some placeholder formatting. Use QByteArray/QString addition instead in loops and for test row names. Change-Id: I31adb60bdaf7ea243143a9244b6c4f66f38b189d Reviewed-by: Jędrzej Nowacki <jedrzej.nowacki@theqtcompany.com>
2015-10-15 11:10:20 +00:00
const QByteArray wB = QByteArray::number(w);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
for (int h = 3; h < 50; h += 11) {
int x = w/2 + 5;
int y = h/2 + 5;
tests/auto/gui: Remove some placeholder formatting. Use QByteArray/QString addition instead in loops and for test row names. Change-Id: I31adb60bdaf7ea243143a9244b6c4f66f38b189d Reviewed-by: Jędrzej Nowacki <jedrzej.nowacki@theqtcompany.com>
2015-10-15 11:10:20 +00:00
const QByteArray rB = "rect(" + QByteArray::number(x) + ", " + QByteArray::number(y)
+ ", " + QByteArray::number(w) + ", " + QByteArray::number(h) + ')';
QTest::newRow((rB + " with pen").constData()) << QRect(x, y, w, h) << true;
QTest::newRow((rB + " no pen").constData()) << QRect(x, y, w, h) << false;
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
}
}
}
/*
Test that drawline works properly after setWindow has been called.
*/
void tst_QPainter::setWindow()
{
QPixmap pixmap(600, 600);
pixmap.fill(QColor(Qt::white));
QPainter painter(&pixmap);
Make QPen default to 1-width non-cosmetic. Use the Qt4CompatiblePainting render hint when painting with QPainter to treat default constructed QPens as cosmetic still. The NonCosmeticDefaultPen render hint gets documented as obsolete, since it was in any case not respected by the raster nor OpenGL paint engine. Change-Id: I04d910e9700baf7f13a8aac07a3633014bb9283e Reviewed-by: Jens Bache-Wiig <jens.bache-wiig@digia.com>
2012-10-15 15:06:34 +00:00
painter.setRenderHint(QPainter::Qt4CompatiblePainting);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
painter.setWindow(0, 0, 3, 3);
painter.drawLine(1, 1, 2, 2);
const QRect painted = getPaintedSize(pixmap, Qt::white);
QVERIFY(195 < painted.y() && painted.y() < 205); // correct value is around 200
QVERIFY(195 < painted.height() && painted.height() < 205); // correct value is around 200
}
void tst_QPainter::combinedMatrix()
{
QPixmap pm(64, 64);
QPainter p(&pm);
p.setWindow(0, 0, 1, 1);
p.setViewport(32, 0, 32, 32);
p.translate(0.5, 0.5);
QMatrix cm = p.combinedMatrix();
QPointF pt = QPointF(0, 0) * cm;
QCOMPARE(pt.x(), 48.0);
QCOMPARE(pt.y(), 16.0);
}
void tst_QPainter::textOnTransparentImage()
{
bool foundPixel = false;
QImage image(10, 10, QImage::Format_ARGB32_Premultiplied);
image.fill(qRgba(0, 0, 0, 0)); // transparent
{
QPainter painter(&image);
painter.setPen(QColor(255, 255, 255));
painter.drawText(0, 10, "W");
}
for (int x = 0; x < image.width(); ++x)
for (int y = 0; y < image.height(); ++y)
if (image.pixel(x, y) != 0)
foundPixel = true;
QVERIFY(foundPixel);
}
void tst_QPainter::renderHints()
{
QImage img(1, 1, QImage::Format_RGB32);
QPainter p(&img);
// Turn off all...
p.setRenderHints(QPainter::RenderHints(0xffffffff), false);
QCOMPARE(p.renderHints(), QPainter::RenderHints(0));
// Single set/get
p.setRenderHint(QPainter::Antialiasing);
QVERIFY(p.renderHints() & QPainter::Antialiasing);
p.setRenderHint(QPainter::Antialiasing, false);
QVERIFY(!(p.renderHints() & QPainter::Antialiasing));
// Multi set/get
p.setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform);
QVERIFY(p.renderHints() & (QPainter::Antialiasing | QPainter::SmoothPixmapTransform));
p.setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform, false);
QVERIFY(!(p.renderHints() & (QPainter::Antialiasing | QPainter::SmoothPixmapTransform)));
}
int countPixels(const QImage &img, const QRgb &color)
{
int count = 0;
for (int y = 0; y < img.height(); ++y) {
for (int x = 0; x < img.width(); ++x) {
count += ((img.pixel(x, y) & 0xffffff) == color);
}
}
return count;
}
template <typename T>
void testClipping(QImage &img)
{
QPainterPath a, b;
a.addRect(QRect(2, 2, 4, 4));
b.addRect(QRect(4, 4, 4, 4));
QPainter p(&img);
p.end();
img.fill(0x0);
p.begin(&img);
p.setClipPath(a);
p.setClipPath(b, Qt::IntersectClip);
p.setClipping(false);
p.setPen(Qt::NoPen);
p.setBrush(QColor(0xff0000));
p.drawRect(T(0, 0, 10, 10));
p.setClipping(true);
p.setBrush(QColor(0x00ff00));
p.drawRect(T(0, 0, 10, 10));
QCOMPARE(countPixels(img, 0xff0000), 96);
QCOMPARE(countPixels(img, 0x00ff00), 4);
}
void tst_QPainter::disableEnableClipping()
{
QImage img(10, 10, QImage::Format_RGB32);
testClipping<QRectF>(img);
testClipping<QRect>(img);
}
void tst_QPainter::setClipRect()
{
QImage img(10, 10, QImage::Format_RGB32);
// simple test to let valgrind check for buffer overflow
{
QPainter p(&img);
p.setClipRect(-10, -10, 100, 100);
p.fillRect(-10, -10, 100, 100, QBrush(QColor(Qt::red)));
}
// rects with negative width/height
{
QPainter p(&img);
p.setClipRect(QRect(10, 10, -10, 10));
QVERIFY(p.clipRegion().isEmpty());
p.setClipRect(QRect(10, 10, 10, -10));
QVERIFY(p.clipRegion().isEmpty());
p.setClipRect(QRectF(10.5, 10.5, -10.5, 10.5));
QVERIFY(p.clipRegion().isEmpty());
p.setClipRect(QRectF(10.5, 10.5, 10.5, -10.5));
QVERIFY(p.clipRegion().isEmpty());
}
}
/*
This tests the two different clipping approaches in QRasterPaintEngine,
one when using a QRegion and one when using a QPainterPath. They should
give equal results.
*/
void tst_QPainter::setEqualClipRegionAndPath_data()
{
QTest::addColumn<QSize>("deviceSize");
QTest::addColumn<QRegion>("region");
QTest::newRow("empty") << QSize(100, 100) << QRegion();
QTest::newRow("simple rect") << QSize(100, 100)
<< QRegion(QRect(5, 5, 10, 10));
QVector<QRect> rects;
QRegion region;
rects << QRect(5, 5, 10, 10) << QRect(20, 20, 10, 10);
region.setRects(rects.constData(), rects.size());
QTest::newRow("two rects") << QSize(100, 100) << region;
rects.clear();
rects << QRect(5, 5, 10, 10) << QRect(20, 5, 10, 10);
region.setRects(rects.constData(), rects.size());
QTest::newRow("two x-adjacent rects") << QSize(100, 100) << region;
rects.clear();
rects << QRect(0, 0, 10, 100) << QRect(12, 0, 10, 100);
region.setRects(rects.constData(), rects.size());
QTest::newRow("two x-adjacent rects 2") << QSize(100, 100) << region;
rects.clear();
rects << QRect(0, 0, 10, 100) << QRect(12, 0, 10, 100);
region.setRects(rects.constData(), rects.size());
QTest::newRow("two x-adjacent rects 3") << QSize(50, 50) << region;
rects.clear();
rects << QRect(0, 0, 10, 100) << QRect(12, 0, 10, 100);
region.setRects(rects.constData(), rects.size());
QTest::newRow("two x-adjacent rects 4") << QSize(101, 101) << region;
region = QRegion(QRect(0, 0, 200, 200), QRegion::Ellipse);
QTest::newRow("ellipse") << QSize(190, 200) << region;
region ^= QRect(50, 50, 50, 50);
QTest::newRow("ellipse 2") << QSize(200, 200) << region;
}
void tst_QPainter::setEqualClipRegionAndPath()
{
QFETCH(QSize, deviceSize);
QFETCH(QRegion, region);
QPainterPath path;
path.addRegion(region);
QImage img1(deviceSize.width(), deviceSize.height(),
QImage::Format_ARGB32);
QImage img2(deviceSize.width(), deviceSize.height(),
QImage::Format_ARGB32);
img1.fill(0x12345678);
img2.fill(0x12345678);
{
QPainter p(&img1);
p.setClipRegion(region);
p.fillRect(0, 0, img1.width(), img1.height(), QColor(Qt::red));
}
{
QPainter p(&img2);
p.setClipPath(path);
p.fillRect(0, 0, img2.width(), img2.height(), QColor(Qt::red));
}
QCOMPARE(img1, img2);
// rotated
img1.fill(0x12345678);
img2.fill(0x12345678);
{
QPainter p(&img1);
p.rotate(25);
p.setClipRegion(region);
p.fillRect(0, 0, img1.width(), img1.height(), QColor(Qt::red));
}
{
QPainter p(&img2);
p.rotate(25);
p.setClipPath(path);
p.fillRect(0, 0, img2.width(), img2.height(), QColor(Qt::red));
}
QCOMPARE(img1, img2);
img1.fill(0x12345678);
img2.fill(0x12345678);
// simple intersectclip
img1.fill(0x12345678);
img2.fill(0x12345678);
{
QPainter p(&img1);
p.setClipRegion(region);
p.setClipRegion(region, Qt::IntersectClip);
p.fillRect(0, 0, img1.width(), img1.height(), QColor(Qt::red));
}
{
QPainter p(&img2);
p.setClipPath(path);
p.setClipPath(path, Qt::IntersectClip);
p.fillRect(0, 0, img2.width(), img2.height(), QColor(Qt::red));
}
QCOMPARE(img1, img2);
img1.fill(0x12345678);
img2.fill(0x12345678);
{
QPainter p(&img1);
p.setClipPath(path);
p.setClipRegion(region, Qt::IntersectClip);
p.fillRect(0, 0, img1.width(), img1.height(), QColor(Qt::red));
}
{
QPainter p(&img2);
p.setClipRegion(region);
p.setClipPath(path, Qt::IntersectClip);
p.fillRect(0, 0, img2.width(), img2.height(), QColor(Qt::red));
}
QCOMPARE(img1, img2);
}
void tst_QPainter::clippedFillPath_data()
{
QTest::addColumn<QSize>("imageSize");
QTest::addColumn<QPainterPath>("path");
QTest::addColumn<QRect>("clipRect");
QTest::addColumn<QBrush>("brush");
QTest::addColumn<QPen>("pen");
QLinearGradient gradient(QPoint(0, 0), QPoint(100, 100));
gradient.setColorAt(0, Qt::red);
gradient.setColorAt(1, Qt::blue);
QPen pen2(QColor(223, 223, 0, 223));
pen2.setWidth(2);
QPainterPath path;
path.addRect(QRect(15, 15, 50, 50));
QTest::newRow("simple rect 0") << QSize(100, 100) << path
<< QRect(15, 15, 49, 49)
<< QBrush(Qt::NoBrush)
<< QPen(Qt::black);
QTest::newRow("simple rect 1") << QSize(100, 100) << path
<< QRect(15, 15, 50, 50)
<< QBrush(Qt::NoBrush)
<< QPen(Qt::black);
QTest::newRow("simple rect 2") << QSize(100, 100) << path
<< QRect(15, 15, 51, 51)
<< QBrush(Qt::NoBrush)
<< QPen(Qt::black);
QTest::newRow("simple rect 3") << QSize(100, 100) << path
<< QRect(15, 15, 51, 51)
<< QBrush(QColor(Qt::blue))
<< QPen(Qt::NoPen);
QTest::newRow("simple rect 4") << QSize(100, 100) << path
<< QRect(15, 15, 51, 51)
<< QBrush(gradient)
<< pen2;
path = QPainterPath();
path.addEllipse(QRect(15, 15, 50, 50));
QTest::newRow("ellipse 0") << QSize(100, 100) << path
<< QRect(15, 15, 49, 49)
<< QBrush(Qt::NoBrush)
<< QPen(Qt::black);
QTest::newRow("ellipse 1") << QSize(100, 100) << path
<< QRect(15, 15, 50, 50)
<< QBrush(Qt::NoBrush)
<< QPen(Qt::black);
QTest::newRow("ellipse 2") << QSize(100, 100) << path
<< QRect(15, 15, 51, 51)
<< QBrush(Qt::NoBrush)
<< QPen(Qt::black);
QTest::newRow("ellipse 3") << QSize(100, 100) << path
<< QRect(15, 15, 51, 51)
<< QBrush(QColor(Qt::blue))
<< QPen(Qt::NoPen);
QTest::newRow("ellipse 4") << QSize(100, 100) << path
<< QRect(15, 15, 51, 51)
<< QBrush(gradient)
<< pen2;
path = QPainterPath();
path.addRoundRect(QRect(15, 15, 50, 50), 20);
QTest::newRow("round rect 0") << QSize(100, 100) << path
<< QRect(15, 15, 49, 49)
<< QBrush(Qt::NoBrush)
<< QPen(Qt::black);
QTest::newRow("round rect 1") << QSize(100, 100) << path
<< QRect(15, 15, 50, 50)
<< QBrush(Qt::NoBrush)
<< QPen(Qt::black);
QTest::newRow("round rect 2") << QSize(100, 100) << path
<< QRect(15, 15, 51, 51)
<< QBrush(Qt::NoBrush)
<< QPen(Qt::black);
QTest::newRow("round rect 3") << QSize(100, 100) << path
<< QRect(15, 15, 51, 51)
<< QBrush(QColor(Qt::blue))
<< QPen(Qt::NoPen);
QTest::newRow("round rect 4") << QSize(100, 100) << path
<< QRect(15, 15, 51, 51)
<< QBrush(gradient)
<< pen2;
path = QPainterPath();
path.moveTo(15, 50);
path.cubicTo(40, 50, 40, 15, 65, 50);
path.lineTo(15, 50);
QTest::newRow("cubic 0") << QSize(100, 100) << path
<< QRect(15, 15, 49, 49)
<< QBrush(Qt::NoBrush)
<< QPen(Qt::black);
QTest::newRow("cubic 1") << QSize(100, 100) << path
<< QRect(15, 15, 50, 50)
<< QBrush(Qt::NoBrush)
<< QPen(Qt::black);
QTest::newRow("cubic 2") << QSize(100, 100) << path
<< QRect(15, 15, 51, 51)
<< QBrush(Qt::NoBrush)
<< QPen(Qt::black);
QTest::newRow("cubic 3") << QSize(100, 100) << path
<< QRect(15, 15, 51, 51)
<< QBrush(QColor(Qt::blue))
<< QPen(Qt::NoPen);
QTest::newRow("cubic 4") << QSize(100, 100) << path
<< QRect(15, 15, 51, 51)
<< QBrush(gradient)
<< pen2;
}
void tst_QPainter::clippedFillPath()
{
QFETCH(QSize, imageSize);
QFETCH(QPainterPath, path);
QFETCH(QRect, clipRect);
QPainterPath clipPath;
clipPath.addRect(clipRect);
QFETCH(QBrush, brush);
QFETCH(QPen, pen);
const int width = imageSize.width();
const int height = imageSize.height();
QImage clippedRect(width, height, QImage::Format_ARGB32_Premultiplied);
clippedRect.fill(0x12345678);
{
QPainter painter(&clippedRect);
painter.setPen(pen);
painter.setBrush(brush);
painter.setClipRect(clipRect);
painter.drawPath(path);
}
QImage clippedPath(width, height, QImage::Format_ARGB32_Premultiplied);
clippedPath.fill(0x12345678);
{
QPainter painter(&clippedPath);
painter.setPen(pen);
painter.setBrush(brush);
painter.setClipPath(clipPath);
painter.drawPath(path);
}
QCOMPARE(clippedRect, clippedPath);
// repeat with antialiasing
clippedRect.fill(0x12345678);
{
QPainter painter(&clippedRect);
painter.setRenderHint(QPainter::Antialiasing);
painter.setPen(pen);
painter.setBrush(brush);
painter.setClipRect(clipRect);
painter.drawPath(path);
}
clippedPath.fill(0x12345678);
{
QPainter painter(&clippedPath);
painter.setRenderHint(QPainter::Antialiasing);
painter.setPen(pen);
painter.setBrush(brush);
painter.setClipPath(clipPath);
painter.drawPath(path);
}
QCOMPARE(clippedRect, clippedPath);
}
void tst_QPainter::clippedLines_data()
{
QTest::addColumn<QSize>("imageSize");
QTest::addColumn<QLineF>("line");
QTest::addColumn<QRect>("clipRect");
QTest::addColumn<QPen>("pen");
QPen pen2(QColor(223, 223, 0, 223));
pen2.setWidth(2);
QVector<QLineF> lines;
lines << QLineF(15, 15, 65, 65)
<< QLineF(14, 14, 66, 66)
<< QLineF(16, 16, 64, 64)
<< QLineF(65, 65, 15, 15)
<< QLineF(66, 66, 14, 14)
<< QLineF(64, 64, 14, 14)
<< QLineF(15, 50, 15, 64)
<< QLineF(15, 50, 15, 65)
<< QLineF(15, 50, 15, 66)
<< QLineF(15, 50, 64, 50)
<< QLineF(15, 50, 65, 50)
<< QLineF(15, 50, 66, 50);
foreach (QLineF line, lines) {
tests/auto/gui: Remove some placeholder formatting. Use QByteArray/QString addition instead in loops and for test row names. Change-Id: I31adb60bdaf7ea243143a9244b6c4f66f38b189d Reviewed-by: Jędrzej Nowacki <jedrzej.nowacki@theqtcompany.com>
2015-10-15 11:10:20 +00:00
const QByteArray desc = "line (" + QByteArray::number(line.x1())
+ ", " + QByteArray::number(line.y1()) + ", "
+ QByteArray::number(line.x2()) + ", " + QByteArray::number(line.y2())
+ ") ";
QTest::newRow((desc + '0').constData()) << QSize(100, 100) << line
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
<< QRect(15, 15, 49, 49)
<< QPen(Qt::black);
tests/auto/gui: Remove some placeholder formatting. Use QByteArray/QString addition instead in loops and for test row names. Change-Id: I31adb60bdaf7ea243143a9244b6c4f66f38b189d Reviewed-by: Jędrzej Nowacki <jedrzej.nowacki@theqtcompany.com>
2015-10-15 11:10:20 +00:00
QTest::newRow((desc + '1').constData()) << QSize(100, 100) << line
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
<< QRect(15, 15, 50, 50)
<< QPen(Qt::black);
tests/auto/gui: Remove some placeholder formatting. Use QByteArray/QString addition instead in loops and for test row names. Change-Id: I31adb60bdaf7ea243143a9244b6c4f66f38b189d Reviewed-by: Jędrzej Nowacki <jedrzej.nowacki@theqtcompany.com>
2015-10-15 11:10:20 +00:00
QTest::newRow((desc + '2').constData()) << QSize(100, 100) << line
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
<< QRect(15, 15, 51, 51)
<< QPen(Qt::black);
tests/auto/gui: Remove some placeholder formatting. Use QByteArray/QString addition instead in loops and for test row names. Change-Id: I31adb60bdaf7ea243143a9244b6c4f66f38b189d Reviewed-by: Jędrzej Nowacki <jedrzej.nowacki@theqtcompany.com>
2015-10-15 11:10:20 +00:00
QTest::newRow((desc + '3').constData()) << QSize(100, 100) << line
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
<< QRect(15, 15, 51, 51)
<< QPen(Qt::NoPen);
tests/auto/gui: Remove some placeholder formatting. Use QByteArray/QString addition instead in loops and for test row names. Change-Id: I31adb60bdaf7ea243143a9244b6c4f66f38b189d Reviewed-by: Jędrzej Nowacki <jedrzej.nowacki@theqtcompany.com>
2015-10-15 11:10:20 +00:00
QTest::newRow((desc + '4').constData()) << QSize(100, 100) << line
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
<< QRect(15, 15, 51, 51)
<< pen2;
}
}
void tst_QPainter::clippedLines()
{
QFETCH(QSize, imageSize);
QFETCH(QLineF, line);
QFETCH(QRect, clipRect);
QPainterPath clipPath;
clipPath.addRect(clipRect);
QFETCH(QPen, pen);
const int width = imageSize.width();
const int height = imageSize.height();
QImage clippedRect(width, height, QImage::Format_ARGB32_Premultiplied);
clippedRect.fill(0x12345678);
{
QPainter painter(&clippedRect);
painter.setPen(pen);
painter.setClipRect(clipRect);
painter.drawLine(line);
painter.drawLine(line.toLine());
}
QImage clippedPath(width, height, QImage::Format_ARGB32_Premultiplied);
clippedPath.fill(0x12345678);
{
QPainter painter(&clippedPath);
painter.setPen(pen);
painter.setClipPath(clipPath);
painter.drawLine(line);
painter.drawLine(line.toLine());
}
QCOMPARE(clippedRect, clippedPath);
// repeat with antialiasing
clippedRect.fill(0x12345678);
{
QPainter painter(&clippedRect);
painter.setRenderHint(QPainter::Antialiasing);
painter.setPen(pen);
painter.setClipRect(clipRect);
painter.drawLine(line);
painter.drawLine(line.toLine());
}
clippedPath.fill(0x12345678);
{
QPainter painter(&clippedPath);
painter.setRenderHint(QPainter::Antialiasing);
painter.setPen(pen);
painter.setClipPath(clipPath);
painter.drawLine(line);
painter.drawLine(line.toLine());
}
QCOMPARE(clippedRect, clippedPath);
}
void tst_QPainter::clippedPolygon_data()
{
clippedFillPath_data();
};
void tst_QPainter::clippedPolygon()
{
QFETCH(QSize, imageSize);
QFETCH(QPainterPath, path);
QPolygonF polygon = path.toFillPolygon();
QFETCH(QRect, clipRect);
QPainterPath clipPath;
clipPath.addRect(clipRect);
QFETCH(QPen, pen);
QFETCH(QBrush, brush);
const int width = imageSize.width();
const int height = imageSize.height();
QImage clippedRect(width, height, QImage::Format_ARGB32_Premultiplied);
clippedRect.fill(0x12345678);
{
QPainter painter(&clippedRect);
painter.setPen(pen);
painter.setBrush(brush);
painter.setClipRect(clipRect);
painter.drawPolygon(polygon);
painter.drawPolygon(polygon.toPolygon());
}
QImage clippedPath(width, height, QImage::Format_ARGB32_Premultiplied);
clippedPath.fill(0x12345678);
{
QPainter painter(&clippedPath);
painter.setPen(pen);
painter.setBrush(brush);
painter.setClipRect(clipRect);
painter.drawPolygon(polygon);
painter.drawPolygon(polygon.toPolygon());
}
QCOMPARE(clippedRect, clippedPath);
// repeat with antialiasing
clippedRect.fill(0x12345678);
{
QPainter painter(&clippedRect);
painter.setRenderHint(QPainter::Antialiasing);
painter.setPen(pen);
painter.setBrush(brush);
painter.setClipRect(clipRect);
painter.drawPolygon(polygon);
painter.drawPolygon(polygon.toPolygon());
}
clippedPath.fill(0x12345678);
{
QPainter painter(&clippedPath);
painter.setRenderHint(QPainter::Antialiasing);
painter.setPen(pen);
painter.setBrush(brush);
painter.setClipRect(clipRect);
painter.drawPolygon(polygon);
painter.drawPolygon(polygon.toPolygon());
}
QCOMPARE(clippedRect, clippedPath);
}
// this just draws some text that should be clipped in the raster
// paint engine.
void tst_QPainter::clippedText()
{
for (char ch = 'A'; ch < 'Z'; ++ch) {
//qDebug() << ch;
QFont f;
f.setPixelSize(24);
QFontMetrics metrics(f);
QRect textRect = metrics.boundingRect(QChar(ch));
if (textRect.width() <= 8)
continue;
if (textRect.height() <= 8)
continue;
QRect imageRect = textRect.adjusted(4, 4, -4, -4);
QImage image(imageRect.size(), QImage::Format_ARGB32_Premultiplied);
image.fill(qRgba(255, 255, 255, 255));
{
QPainter painter(&image);
painter.setFont(f);
painter.setPen(Qt::black);
painter.drawText(0, 0, QChar(ch));
}
image.fill(qRgba(255, 255, 255, 255));
{
QPainter painter(&image);
painter.setFont(f);
painter.setPen(Qt::black);
painter.drawText(-imageRect.topLeft(), QChar(ch));
}
bool foundPixel = false;
for (int x = 0; x < image.width(); ++x)
for (int y = 0; y < image.height(); ++y)
if (image.pixel(x, y) != 0)
foundPixel = true;
// can't QVERIFY(foundPixel) as sometimes all pixels are clipped
// away. For example for 'O'
// just call /some/ function to prevent the compiler from optimizing
// foundPixel away
QString::number(foundPixel);
//image.save(QString("debug") + ch + ".xpm");
}
QVERIFY(true); // reached, don't trigger any valgrind errors
}
void tst_QPainter::setOpacity_data()
{
QTest::addColumn<QImage::Format>("destFormat");
QTest::addColumn<QImage::Format>("srcFormat");
QTest::newRow("ARGB32P on ARGB32P") << QImage::Format_ARGB32_Premultiplied
<< QImage::Format_ARGB32_Premultiplied;
QTest::newRow("ARGB32 on ARGB32") << QImage::Format_ARGB32
<< QImage::Format_ARGB32;
QTest::newRow("RGB32 on RGB32") << QImage::Format_RGB32
<< QImage::Format_RGB32;
QTest::newRow("RGB16 on RGB16") << QImage::Format_RGB16
<< QImage::Format_RGB16;
QTest::newRow("ARGB8565_Premultiplied on ARGB8565_Premultiplied") << QImage::Format_ARGB8565_Premultiplied
<< QImage::Format_ARGB8565_Premultiplied;
QTest::newRow("RGB555 on RGB555") << QImage::Format_RGB555
<< QImage::Format_RGB555;
QTest::newRow("RGB666 on RGB666") << QImage::Format_RGB666
<< QImage::Format_RGB666;
QTest::newRow("ARGB8555_Premultiplied on ARGB8555_Premultiplied") << QImage::Format_ARGB8555_Premultiplied
<< QImage::Format_ARGB8555_Premultiplied;
QTest::newRow("RGB888 on RGB888") << QImage::Format_RGB888
<< QImage::Format_RGB888;
QTest::newRow("RGB32 on RGB16") << QImage::Format_RGB16
<< QImage::Format_RGB32;
QTest::newRow("RGB32 on ARGB8565_Premultiplied") << QImage::Format_ARGB8565_Premultiplied
<< QImage::Format_RGB32;
QTest::newRow("RGB32 on RGB666") << QImage::Format_RGB666
<< QImage::Format_RGB32;
QTest::newRow("RGB32 on RGB555") << QImage::Format_RGB555
<< QImage::Format_RGB32;
QTest::newRow("RGB32 on ARGB8555_Premultiplied") << QImage::Format_ARGB8555_Premultiplied
<< QImage::Format_RGB32;
QTest::newRow("RGB32 on RGB888") << QImage::Format_RGB888
<< QImage::Format_RGB32;
QTest::newRow("RGB16 on RGB32") << QImage::Format_RGB32
<< QImage::Format_RGB16;
QTest::newRow("ARGB8565_Premultiplied on RGB32") << QImage::Format_RGB32
<< QImage::Format_ARGB8565_Premultiplied;
QTest::newRow("RGB666 on RGB32") << QImage::Format_RGB32
<< QImage::Format_RGB666;
QTest::newRow("RGB555 on RGB32") << QImage::Format_RGB32
<< QImage::Format_RGB555;
QTest::newRow("ARGB8555_Premultiplied on RGB32") << QImage::Format_RGB32
<< QImage::Format_ARGB8555_Premultiplied;
QTest::newRow("RGB888 on RGB32") << QImage::Format_RGB32
<< QImage::Format_RGB888;
QTest::newRow("RGB555 on RGB888") << QImage::Format_RGB888
<< QImage::Format_RGB555;
QTest::newRow("RGB666 on RGB888") << QImage::Format_RGB888
<< QImage::Format_RGB666;
QTest::newRow("RGB444 on RGB444") << QImage::Format_RGB444
<< QImage::Format_RGB444;
Support RGBA image format Support the byte-ordered RGBA format which is used by OpenGL, and many endian neutral byte formats. Task-number: QTBUG-32201 Change-Id: I77cffb4c30c69545fa96ded2f537b2ebd9351acb Reviewed-by: Allan Sandfeld Jensen <allan.jensen@digia.com>
2013-07-03 13:13:55 +00:00
QTest::newRow("RGBA8888P on RGBA8888P") << QImage::Format_RGBA8888_Premultiplied
<< QImage::Format_RGBA8888_Premultiplied;
QTest::newRow("RGBA8888 on RGBA8888") << QImage::Format_RGBA8888
<< QImage::Format_RGBA8888;
QTest::newRow("RGBx8888 on RGBx8888") << QImage::Format_RGBX8888
<< QImage::Format_RGBX8888;
Fix RGB30 painting tests Some tests were failing because the color was not read correctly from a QImage. To make it possibly to read more accurate colors a pixel accessor returing QColor has been added. Some tests also had the wrong order of arguments, confusing dest and src formats. This has been corrected, so they test what they claim to test. A test for RGB30 linear gradients is also added. Change-Id: Ic623ae1b8e0bf7383056b641c6e8230a1d7dd0dd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 09:28:33 +00:00
QTest::newRow("RGBA8888P on ARGB32P") << QImage::Format_ARGB32_Premultiplied
<< QImage::Format_RGBA8888_Premultiplied;
QTest::newRow("RGBx8888 on ARGB32P") << QImage::Format_ARGB32_Premultiplied
<< QImage::Format_RGBX8888;
QTest::newRow("ARGB32P on RGBA8888P") << QImage::Format_RGBA8888_Premultiplied
Support RGBA image format Support the byte-ordered RGBA format which is used by OpenGL, and many endian neutral byte formats. Task-number: QTBUG-32201 Change-Id: I77cffb4c30c69545fa96ded2f537b2ebd9351acb Reviewed-by: Allan Sandfeld Jensen <allan.jensen@digia.com>
2013-07-03 13:13:55 +00:00
<< QImage::Format_ARGB32_Premultiplied;
Fix RGB30 painting tests Some tests were failing because the color was not read correctly from a QImage. To make it possibly to read more accurate colors a pixel accessor returing QColor has been added. Some tests also had the wrong order of arguments, confusing dest and src formats. This has been corrected, so they test what they claim to test. A test for RGB30 linear gradients is also added. Change-Id: Ic623ae1b8e0bf7383056b641c6e8230a1d7dd0dd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 09:28:33 +00:00
QTest::newRow("RGB32 on RGBx8888") << QImage::Format_RGBX8888
<< QImage::Format_RGB32;
Support RGBA image format Support the byte-ordered RGBA format which is used by OpenGL, and many endian neutral byte formats. Task-number: QTBUG-32201 Change-Id: I77cffb4c30c69545fa96ded2f537b2ebd9351acb Reviewed-by: Allan Sandfeld Jensen <allan.jensen@digia.com>
2013-07-03 13:13:55 +00:00
Fix RGB30 painting tests Some tests were failing because the color was not read correctly from a QImage. To make it possibly to read more accurate colors a pixel accessor returing QColor has been added. Some tests also had the wrong order of arguments, confusing dest and src formats. This has been corrected, so they test what they claim to test. A test for RGB30 linear gradients is also added. Change-Id: Ic623ae1b8e0bf7383056b641c6e8230a1d7dd0dd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 09:28:33 +00:00
QTest::newRow("RGB30 on RGB32") << QImage::Format_RGB32
<< QImage::Format_BGR30;
QTest::newRow("BGR30 on ARGB32P") << QImage::Format_ARGB32_Premultiplied
<< QImage::Format_BGR30;
Support RGBA image format Support the byte-ordered RGBA format which is used by OpenGL, and many endian neutral byte formats. Task-number: QTBUG-32201 Change-Id: I77cffb4c30c69545fa96ded2f537b2ebd9351acb Reviewed-by: Allan Sandfeld Jensen <allan.jensen@digia.com>
2013-07-03 13:13:55 +00:00
Fix RGB30 painting tests Some tests were failing because the color was not read correctly from a QImage. To make it possibly to read more accurate colors a pixel accessor returing QColor has been added. Some tests also had the wrong order of arguments, confusing dest and src formats. This has been corrected, so they test what they claim to test. A test for RGB30 linear gradients is also added. Change-Id: Ic623ae1b8e0bf7383056b641c6e8230a1d7dd0dd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 09:28:33 +00:00
QTest::newRow("A2RGB30P on ARGB32P") << QImage::Format_ARGB32_Premultiplied
<< QImage::Format_A2BGR30_Premultiplied;
QImage support for RGB30 formats Adds basic support for 10-bit per color channel formats to QImage and the XCB plugin. This will make it possible to paint to and from these formats, but only at 8-bit per color channel accuracy. This also fixes Qt5 applications on X11 with native 30bit depth. [ChangeLog][QtGui][QImage] Added support for 10-bit per color channel image formats. Task-number: QTBUG-25998 Change-Id: I93ccd3c74bfbb0bd94b352476e5fe58a94119e1f Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-05-26 10:07:18 +00:00
QTest::newRow("A2RGB30P on A2RGB30P") << QImage::Format_A2RGB30_Premultiplied
<< QImage::Format_A2RGB30_Premultiplied;
Fix RGB30 painting tests Some tests were failing because the color was not read correctly from a QImage. To make it possibly to read more accurate colors a pixel accessor returing QColor has been added. Some tests also had the wrong order of arguments, confusing dest and src formats. This has been corrected, so they test what they claim to test. A test for RGB30 linear gradients is also added. Change-Id: Ic623ae1b8e0bf7383056b641c6e8230a1d7dd0dd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 09:28:33 +00:00
QTest::newRow("ARGB32P on A2RGB30P") << QImage::Format_A2RGB30_Premultiplied
<< QImage::Format_ARGB32_Premultiplied;
QImage support for RGB30 formats Adds basic support for 10-bit per color channel formats to QImage and the XCB plugin. This will make it possible to paint to and from these formats, but only at 8-bit per color channel accuracy. This also fixes Qt5 applications on X11 with native 30bit depth. [ChangeLog][QtGui][QImage] Added support for 10-bit per color channel image formats. Task-number: QTBUG-25998 Change-Id: I93ccd3c74bfbb0bd94b352476e5fe58a94119e1f Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-05-26 10:07:18 +00:00
Fix RGB30 painting tests Some tests were failing because the color was not read correctly from a QImage. To make it possibly to read more accurate colors a pixel accessor returing QColor has been added. Some tests also had the wrong order of arguments, confusing dest and src formats. This has been corrected, so they test what they claim to test. A test for RGB30 linear gradients is also added. Change-Id: Ic623ae1b8e0bf7383056b641c6e8230a1d7dd0dd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 09:28:33 +00:00
QTest::newRow("RGB32 on A2BGR30P") << QImage::Format_A2BGR30_Premultiplied
<< QImage::Format_RGB32;
QImage support for RGB30 formats Adds basic support for 10-bit per color channel formats to QImage and the XCB plugin. This will make it possible to paint to and from these formats, but only at 8-bit per color channel accuracy. This also fixes Qt5 applications on X11 with native 30bit depth. [ChangeLog][QtGui][QImage] Added support for 10-bit per color channel image formats. Task-number: QTBUG-25998 Change-Id: I93ccd3c74bfbb0bd94b352476e5fe58a94119e1f Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-05-26 10:07:18 +00:00
Fix RGB30 painting tests Some tests were failing because the color was not read correctly from a QImage. To make it possibly to read more accurate colors a pixel accessor returing QColor has been added. Some tests also had the wrong order of arguments, confusing dest and src formats. This has been corrected, so they test what they claim to test. A test for RGB30 linear gradients is also added. Change-Id: Ic623ae1b8e0bf7383056b641c6e8230a1d7dd0dd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 09:28:33 +00:00
QTest::newRow("RGB30 on A2BGR30P") << QImage::Format_A2BGR30_Premultiplied
<< QImage::Format_RGB30;
QImage support for RGB30 formats Adds basic support for 10-bit per color channel formats to QImage and the XCB plugin. This will make it possible to paint to and from these formats, but only at 8-bit per color channel accuracy. This also fixes Qt5 applications on X11 with native 30bit depth. [ChangeLog][QtGui][QImage] Added support for 10-bit per color channel image formats. Task-number: QTBUG-25998 Change-Id: I93ccd3c74bfbb0bd94b352476e5fe58a94119e1f Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-05-26 10:07:18 +00:00
Fix RGB30 painting tests Some tests were failing because the color was not read correctly from a QImage. To make it possibly to read more accurate colors a pixel accessor returing QColor has been added. Some tests also had the wrong order of arguments, confusing dest and src formats. This has been corrected, so they test what they claim to test. A test for RGB30 linear gradients is also added. Change-Id: Ic623ae1b8e0bf7383056b641c6e8230a1d7dd0dd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 09:28:33 +00:00
QTest::newRow("A2RGB30P on A2BGR30P") << QImage::Format_A2BGR30_Premultiplied
<< QImage::Format_A2RGB30_Premultiplied;
QImage support for RGB30 formats Adds basic support for 10-bit per color channel formats to QImage and the XCB plugin. This will make it possible to paint to and from these formats, but only at 8-bit per color channel accuracy. This also fixes Qt5 applications on X11 with native 30bit depth. [ChangeLog][QtGui][QImage] Added support for 10-bit per color channel image formats. Task-number: QTBUG-25998 Change-Id: I93ccd3c74bfbb0bd94b352476e5fe58a94119e1f Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-05-26 10:07:18 +00:00
Fix RGB30 painting tests Some tests were failing because the color was not read correctly from a QImage. To make it possibly to read more accurate colors a pixel accessor returing QColor has been added. Some tests also had the wrong order of arguments, confusing dest and src formats. This has been corrected, so they test what they claim to test. A test for RGB30 linear gradients is also added. Change-Id: Ic623ae1b8e0bf7383056b641c6e8230a1d7dd0dd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 09:28:33 +00:00
QTest::newRow("ARGB32P on BGR30") << QImage::Format_BGR30
<< QImage::Format_ARGB32_Premultiplied;
QImage support for RGB30 formats Adds basic support for 10-bit per color channel formats to QImage and the XCB plugin. This will make it possible to paint to and from these formats, but only at 8-bit per color channel accuracy. This also fixes Qt5 applications on X11 with native 30bit depth. [ChangeLog][QtGui][QImage] Added support for 10-bit per color channel image formats. Task-number: QTBUG-25998 Change-Id: I93ccd3c74bfbb0bd94b352476e5fe58a94119e1f Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-05-26 10:07:18 +00:00
Fix RGB30 painting tests Some tests were failing because the color was not read correctly from a QImage. To make it possibly to read more accurate colors a pixel accessor returing QColor has been added. Some tests also had the wrong order of arguments, confusing dest and src formats. This has been corrected, so they test what they claim to test. A test for RGB30 linear gradients is also added. Change-Id: Ic623ae1b8e0bf7383056b641c6e8230a1d7dd0dd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 09:28:33 +00:00
QTest::newRow("ARGB32P on RGB30") << QImage::Format_RGB30
<< QImage::Format_ARGB32_Premultiplied;
QTest::newRow("A2RGB30P on RGB30") << QImage::Format_RGB30
<< QImage::Format_A2RGB30_Premultiplied;
QImage support for RGB30 formats Adds basic support for 10-bit per color channel formats to QImage and the XCB plugin. This will make it possible to paint to and from these formats, but only at 8-bit per color channel accuracy. This also fixes Qt5 applications on X11 with native 30bit depth. [ChangeLog][QtGui][QImage] Added support for 10-bit per color channel image formats. Task-number: QTBUG-25998 Change-Id: I93ccd3c74bfbb0bd94b352476e5fe58a94119e1f Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-05-26 10:07:18 +00:00
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
}
void tst_QPainter::setOpacity()
{
QFETCH(QImage::Format, destFormat);
QFETCH(QImage::Format, srcFormat);
const QSize imageSize(12, 12);
const QRect imageRect(QPoint(0, 0), imageSize);
QColor destColor = Qt::black;
QColor srcColor = Qt::white;
QImage dest(imageSize, destFormat);
QImage src(imageSize, srcFormat);
QPainter p;
p.begin(&dest);
p.fillRect(imageRect, destColor);
p.end();
p.begin(&src);
p.fillRect(imageRect, srcColor);
p.end();
p.begin(&dest);
p.setOpacity(0.5);
p.drawImage(imageRect, src, imageRect);
p.end();
QImage actual = dest.convertToFormat(QImage::Format_RGB32);
for (int y = 0; y < actual.height(); ++y) {
QRgb *p = (QRgb *)actual.scanLine(y);
for (int x = 0; x < actual.width(); ++x) {
QVERIFY(qAbs(qRed(p[x]) - 127) <= 0xf);
QVERIFY(qAbs(qGreen(p[x]) - 127) <= 0xf);
QVERIFY(qAbs(qBlue(p[x]) - 127) <= 0xf);
}
}
}
void tst_QPainter::drawhelper_blend_untransformed_data()
{
setOpacity_data();
}
void tst_QPainter::drawhelper_blend_untransformed()
{
QFETCH(QImage::Format, destFormat);
QFETCH(QImage::Format, srcFormat);
const int size = 128;
const QSize imageSize(size, size);
const QRect paintRect(1, 0, size - 2, size); // needs alignment and tailing
QColor destColor(127, 127, 127);
QColor srcColor(Qt::white);
QImage dest(imageSize, destFormat);
QImage src(imageSize, srcFormat);
QPainter p;
p.begin(&src);
p.fillRect(paintRect, srcColor);
p.end();
QList<qreal> opacities = (QList<qreal>() << 0.0 << 0.1 << 0.01 << 0.4
<< 0.5 << 0.6 << 0.9 << 1.0);
foreach (qreal opacity, opacities) {
p.begin(&dest);
p.fillRect(paintRect, destColor);
p.setOpacity(opacity);
p.drawImage(paintRect, src, paintRect);
p.end();
// sanity check: make sure all pixels are equal
QImage expected(size - 2, size, destFormat);
p.begin(&expected);
p.fillRect(0, 0, expected.width(), expected.height(),
Fix RGB30 painting tests Some tests were failing because the color was not read correctly from a QImage. To make it possibly to read more accurate colors a pixel accessor returing QColor has been added. Some tests also had the wrong order of arguments, confusing dest and src formats. This has been corrected, so they test what they claim to test. A test for RGB30 linear gradients is also added. Change-Id: Ic623ae1b8e0bf7383056b641c6e8230a1d7dd0dd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 09:28:33 +00:00
dest.pixelColor(1, 0));
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
p.end();
const QImage subDest(dest.bits() + dest.depth() / 8,
dest.width() - 2, dest.height(),
dest.bytesPerLine(), dest.format());
if (dest.format() == QImage::Format_ARGB8565_Premultiplied ||
Fix RGB30 painting tests Some tests were failing because the color was not read correctly from a QImage. To make it possibly to read more accurate colors a pixel accessor returing QColor has been added. Some tests also had the wrong order of arguments, confusing dest and src formats. This has been corrected, so they test what they claim to test. A test for RGB30 linear gradients is also added. Change-Id: Ic623ae1b8e0bf7383056b641c6e8230a1d7dd0dd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 09:28:33 +00:00
dest.format() == QImage::Format_ARGB8555_Premultiplied) {
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
// Test skipped due to rounding errors...
continue;
}
QCOMPARE(subDest, expected);
}
}
void tst_QPainter::drawhelper_blend_tiled_untransformed_data()
{
setOpacity_data();
}
void tst_QPainter::drawhelper_blend_tiled_untransformed()
{
QFETCH(QImage::Format, destFormat);
QFETCH(QImage::Format, srcFormat);
const int size = 128;
const QSize imageSize(size, size);
const QRect paintRect(1, 0, size - 2, size); // needs alignment and tailing
QColor destColor(127, 127, 127);
QColor srcColor(Qt::white);
QImage dest(imageSize, destFormat);
QImage src(imageSize / 2, srcFormat);
QPainter p;
p.begin(&src);
p.fillRect(QRect(QPoint(0, 0), imageSize/ 2), srcColor);
p.end();
const QBrush brush(src);
QList<qreal> opacities = (QList<qreal>() << 0.0 << 0.1 << 0.01 << 0.4
<< 0.5 << 0.6 << 0.9 << 1.0);
foreach (qreal opacity, opacities) {
p.begin(&dest);
p.fillRect(paintRect, destColor);
p.setOpacity(opacity);
p.fillRect(paintRect, brush);
p.end();
// sanity check: make sure all pixels are equal
QImage expected(size - 2, size, destFormat);
p.begin(&expected);
p.fillRect(0, 0, expected.width(), expected.height(),
Fix RGB30 painting tests Some tests were failing because the color was not read correctly from a QImage. To make it possibly to read more accurate colors a pixel accessor returing QColor has been added. Some tests also had the wrong order of arguments, confusing dest and src formats. This has been corrected, so they test what they claim to test. A test for RGB30 linear gradients is also added. Change-Id: Ic623ae1b8e0bf7383056b641c6e8230a1d7dd0dd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 09:28:33 +00:00
dest.pixelColor(1, 0));
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
p.end();
const QImage subDest(dest.bits() + dest.depth() / 8,
dest.width() - 2, dest.height(),
dest.bytesPerLine(), dest.format());
if (dest.format() == QImage::Format_ARGB8565_Premultiplied ||
dest.format() == QImage::Format_ARGB8555_Premultiplied) {
// Skipping test due to rounding errors. Test needs rewrite
continue;
}
QCOMPARE(subDest, expected);
}
}
static QPaintEngine::PaintEngineFeatures no_porter_duff()
{
QPaintEngine::PaintEngineFeatures features = QPaintEngine::AllFeatures;
return features & ~QPaintEngine::PorterDuff;
}
class DummyPaintEngine : public QPaintEngine, public QPaintDevice
{
public:
DummyPaintEngine() : QPaintEngine(no_porter_duff()) {}
virtual bool begin(QPaintDevice *) { return true; }
virtual bool end() { return true; }
virtual void updateState(const QPaintEngineState &) {}
virtual void drawPixmap(const QRectF &, const QPixmap &, const QRectF &) {}
virtual Type type() const { return User; }
virtual QPaintEngine *paintEngine() const { return (QPaintEngine *)this; }
virtual int metric(PaintDeviceMetric metric) const { Q_UNUSED(metric); return 0; };
};
static bool success;
Autotests: Use qInstallMessageHandler qInstallMsgHandler got deprecated in Qt 5. Change-Id: Ib36983e66b3a8090b99f14e3fd4e210602a3f018 Reviewed-by: Qt Doc Bot <qt_docbot@qt-project.org> Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
2012-09-12 08:42:25 +00:00
void porterDuff_warningChecker(QtMsgType type, const QMessageLogContext &, const QString &msg)
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
{
if (type == QtWarningMsg && msg == QLatin1String("QPainter::setCompositionMode: PorterDuff modes not supported on device"))
success = false;
}
void tst_QPainter::porterDuff_warning()
{
Autotests: Use qInstallMessageHandler qInstallMsgHandler got deprecated in Qt 5. Change-Id: Ib36983e66b3a8090b99f14e3fd4e210602a3f018 Reviewed-by: Qt Doc Bot <qt_docbot@qt-project.org> Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
2012-09-12 08:42:25 +00:00
QtMessageHandler old = qInstallMessageHandler(porterDuff_warningChecker);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
DummyPaintEngine dummy;
QPainter p(&dummy);
success = true;
p.setCompositionMode(QPainter::CompositionMode_Source);
QVERIFY(success);
success = true;
p.setCompositionMode(QPainter::CompositionMode_SourceOver);
QVERIFY(success);
success = true;
p.setCompositionMode(QPainter::CompositionMode_DestinationOver);
QVERIFY(!success);
Autotests: Use qInstallMessageHandler qInstallMsgHandler got deprecated in Qt 5. Change-Id: Ib36983e66b3a8090b99f14e3fd4e210602a3f018 Reviewed-by: Qt Doc Bot <qt_docbot@qt-project.org> Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
2012-09-12 08:42:25 +00:00
QVERIFY(qInstallMessageHandler(old) == porterDuff_warningChecker);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
}
void tst_QPainter::drawhelper_blend_color()
{
QImage dest(32, 32, QImage::Format_ARGB8555_Premultiplied);
dest.fill(0xff000000);
{
QPainter p(&dest);
p.fillRect(0, 0, dest.width(), dest.height(), QColor(255, 0, 0, 127));
}
QImage expected(32, 32, QImage::Format_ARGB8555_Premultiplied);
expected.fill(0xff3c007f);
QCOMPARE(dest.pixel(1, 1), expected.pixel(1, 1));
QCOMPARE(dest, expected);
}
Make qpainter autotest build without widgets Change-Id: I4e05871e44f7a69aaa9cd5d876c249c7dd9d86e8 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-06-05 11:58:15 +00:00
#ifndef QT_NO_WIDGETS
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
class ViewportTestWidget : public QWidget
{
public:
ViewportTestWidget(QWidget *parent = 0) : QWidget(parent), hasPainted(false) {}
QSize sizeHint() const {
return QSize(100, 100);
}
QRect viewport;
bool hasPainted;
protected:
void paintEvent(QPaintEvent *) {
hasPainted = true;
QPainter p(this);
viewport = p.viewport();
}
};
void tst_QPainter::childWidgetViewport()
{
QWidget parent;
parent.setAutoFillBackground(true);
parent.resize(200, 200);
ViewportTestWidget child(&parent);
child.setAutoFillBackground(true);
parent.show();
parent.update();
qApp->processEvents();
if (child.hasPainted) {
QCOMPARE(child.viewport, QRect(QPoint(0, 0), child.sizeHint()));
} else {
qWarning("Failed to ensure that paintEvent has been run. Could not run test.");
}
}
Make qpainter autotest build without widgets Change-Id: I4e05871e44f7a69aaa9cd5d876c249c7dd9d86e8 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-06-05 11:58:15 +00:00
#endif
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void tst_QPainter::fillRect_objectBoundingModeGradient()
{
QImage a(10, 10, QImage::Format_ARGB32_Premultiplied);
a.fill(0x0);
QImage b = a;
QLinearGradient g(QPoint(0, 0), QPoint(0, 1));
g.setColorAt(0, Qt::red);
g.setColorAt(1, Qt::blue);
g.setCoordinateMode(QGradient::ObjectBoundingMode);
QPainter p(&a);
p.fillRect(QRect(0, 0, a.width(), a.height()), g);
p.end();
QPainterPath path;
path.addRect(0, 0, a.width(), a.height());
p.begin(&b);
p.fillPath(path, g);
p.end();
QCOMPARE(a, b);
}
void tst_QPainter::fillRect_stretchToDeviceMode()
{
QImage img(64, 64, QImage::Format_ARGB32_Premultiplied);
QLinearGradient g(QPoint(0, 0), QPoint(0, 1));
g.setCoordinateMode(QGradient::StretchToDeviceMode);
QPainter p(&img);
p.fillRect(img.rect(), g);
p.end();
for (int i = 1; i < img.height(); ++i)
QVERIFY(img.pixel(0, i) != img.pixel(0, i-1));
}
void tst_QPainter::monoImages()
{
Qt::GlobalColor colorPairs[][2] = {
{ Qt::white, Qt::black },
{ Qt::color0, Qt::color1 },
{ Qt::red, Qt::blue }
};
const int numColorPairs = sizeof(colorPairs) / sizeof(QRgb[2]);
QImage transparent(2, 2, QImage::Format_ARGB32_Premultiplied);
transparent.fill(0x0);
for (int i = 1; i < QImage::NImageFormats; ++i) {
for (int j = 0; j < numColorPairs; ++j) {
const QImage::Format format = QImage::Format(i);
if (format == QImage::Format_Indexed8)
continue;
QImage img(2, 2, format);
if (img.colorCount() > 0) {
img.setColor(0, QColor(colorPairs[j][0]).rgba());
img.setColor(1, QColor(colorPairs[j][1]).rgba());
}
img.fill(0x0);
QPainter p(&img);
p.fillRect(0, 0, 2, 2, colorPairs[j][0]);
p.fillRect(0, 0, 1, 1, colorPairs[j][1]);
p.fillRect(1, 1, 1, 1, colorPairs[j][1]);
p.end();
QImage original = img;
p.begin(&img);
p.drawImage(0, 0, transparent);
p.end();
// drawing a transparent image on top of another image
// should not change the image
QCOMPARE(original, img);
if (img.colorCount() == 0)
continue;
for (int k = 0; k < 2; ++k) {
QPainter p(&img);
p.fillRect(0, 0, 2, 2, colorPairs[j][k]);
p.end();
QImage argb32p(2, 2, QImage::Format_ARGB32_Premultiplied);
p.begin(&argb32p);
p.fillRect(0, 0, 2, 2, colorPairs[j][k]);
p.end();
QCOMPARE(argb32p, img.convertToFormat(argb32p.format()));
// drawing argb32p image on mono image
p.begin(&img);
p.drawImage(0, 0, argb32p);
p.end();
QCOMPARE(argb32p, img.convertToFormat(argb32p.format()));
// drawing mono image on argb32p image
p.begin(&argb32p);
p.drawImage(0, 0, img);
p.end();
QCOMPARE(argb32p, img.convertToFormat(argb32p.format()));
}
}
}
}
uclibc: fenv.h does not define the necessary things. libstdc++ provides the fenv.h found and for uclibc default toolchains the bits/c++config.h has _GLIBCXX_HAVE_FENV_H undefined leading to no import of the uclibc fenv.h Change-Id: I53173b099f3d8791f527f1ccb60991de57cd19db Filed: https://bugs.busybox.net/show_bug.cgi?id=4484 Reviewed-by: Harald Fernengel <harald.fernengel@nokia.com>
2011-11-15 20:43:52 +00:00
#if !defined(Q_OS_IRIX) && !defined(Q_OS_AIX) && !defined(Q_CC_MSVC) && !defined(Q_OS_SOLARIS) && !defined(__UCLIBC__)
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
#include <fenv.h>
static const QString fpeExceptionString(int exception)
{
#ifdef FE_INEXACT
if (exception & FE_INEXACT)
return QLatin1String("Inexact result");
#endif
if (exception & FE_UNDERFLOW)
return QLatin1String("Underflow");
if (exception & FE_OVERFLOW)
return QLatin1String("Overflow");
if (exception & FE_DIVBYZERO)
return QLatin1String("Divide by zero");
if (exception & FE_INVALID)
return QLatin1String("Invalid operation");
return QLatin1String("No exception");
}
class FpExceptionChecker
{
public:
FpExceptionChecker(int exceptionMask)
: m_exceptionMask(exceptionMask)
{
feclearexcept(m_exceptionMask);
}
~FpExceptionChecker()
{
const int exceptions = fetestexcept(m_exceptionMask);
QVERIFY2(!exceptions, qPrintable(QLatin1String("Floating point exception: ") + fpeExceptionString(exceptions)));
}
private:
int m_exceptionMask;
};
void fpe_rasterizeLine_task232012()
{
FpExceptionChecker checker(FE_UNDERFLOW | FE_OVERFLOW | FE_INVALID | FE_DIVBYZERO);
QImage img(128, 128, QImage::Format_ARGB32_Premultiplied);
img.fill(0x0);
QPainter p(&img);
p.setBrush(Qt::black);
p.drawRect(QRectF(0, 0, 5, 0));
p.drawRect(QRectF(0, 0, 0, 5));
}
void fpe_pixmapTransform()
{
FpExceptionChecker checker(FE_UNDERFLOW | FE_OVERFLOW | FE_INVALID | FE_DIVBYZERO);
QImage img(128, 128, QImage::Format_ARGB32_Premultiplied);
QPainter p(&img);
const qreal scaleFactor = 0.001;
const int translateDistance = 1000000;
p.setPen(Qt::red);
p.setBrush(QBrush(Qt::red,Qt::Dense6Pattern));
for (int i = 0; i < 2; ++i) {
p.setRenderHint(QPainter::SmoothPixmapTransform, i);
p.resetTransform();
p.scale(1.1, 1.1);
p.translate(translateDistance, 0);
p.drawRect(-translateDistance, 0, 100, 100);
p.resetTransform();
p.scale(scaleFactor, scaleFactor);
p.drawRect(QRectF(0, 0, 1 / scaleFactor, 1 / scaleFactor));
}
}
void fpe_zeroLengthLines()
{
FpExceptionChecker checker(FE_UNDERFLOW | FE_OVERFLOW | FE_INVALID | FE_DIVBYZERO);
QImage img(128, 128, QImage::Format_ARGB32_Premultiplied);
QPainter p(&img);
p.setPen(QPen(Qt::black, 3));
p.drawLine(64, 64, 64, 64);
}
void fpe_divByZero()
{
FpExceptionChecker checker(FE_UNDERFLOW | FE_OVERFLOW | FE_INVALID | FE_DIVBYZERO);
QImage img(128, 128, QImage::Format_ARGB32_Premultiplied);
QPainter p(&img);
p.setRenderHint(QPainter::Antialiasing);
p.drawRect(QRectF(10, 10, 100, 0));
p.drawRect(QRectF(10, 10, 0, 100));
p.drawRect(QRect(10, 10, 100, 0));
p.drawRect(QRect(10, 10, 0, 100));
p.fillRect(QRectF(10, 10, 100, 0), Qt::black);
p.fillRect(QRectF(10, 10, 0, 100), Qt::black);
p.fillRect(QRect(10, 10, 100, 0), Qt::black);
p.fillRect(QRect(10, 10, 0, 100), Qt::black);
}
void fpe_steepSlopes()
{
FpExceptionChecker checker(FE_UNDERFLOW | FE_OVERFLOW | FE_INVALID | FE_DIVBYZERO);
QImage img(1024, 1024, QImage::Format_ARGB32_Premultiplied);
QFETCH(QTransform, transform);
QFETCH(QLineF, line);
QFETCH(bool, antialiased);
QPainter p(&img);
p.setPen(QPen(Qt::black, 1));
p.setRenderHint(QPainter::Antialiasing, antialiased);
p.setTransform(transform);
p.drawLine(line);
}
void fpe_radialGradients()
{
Skip failing autotests with b2qt toolchain Task-number: QTBUG-59966 Change-Id: I36d114107187db22841ebfeff8fa8175daff6d03 Reviewed-by: Thiago Macieira <thiago.macieira@intel.com> Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2017-01-20 11:28:42 +00:00
#if defined(Q_PROCESSOR_ARM)
QEXPECT_FAIL("", "Test fails for ARM (QTBUG-59961)", Continue);
#endif
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
FpExceptionChecker checker(FE_UNDERFLOW | FE_OVERFLOW | FE_INVALID | FE_DIVBYZERO);
QImage img(21, 21, QImage::Format_ARGB32_Premultiplied);
img.fill(0);
double m = img.width() * 0.5;
QPainter p(&img);
p.setRenderHints(QPainter::Antialiasing);
p.setPen(Qt::NoPen);
p.setBrush(QRadialGradient(m, m, m));
p.drawEllipse(img.rect());
}
#define FPE_TEST(x) \
void tst_QPainter::x() \
{ \
::x(); \
}
#else
#define FPE_TEST(x) \
void tst_QPainter::x() \
{ \
Remove SkipMode parameter from QSKIP calls. The previous commit removed SkipMode from the testlib APi. This commit removes the parameter from all calls to QSKIP. Task-number: QTBUG-21851, QTBUG-21652 Change-Id: I21c0ee6731c1bc6ac6d962590d9b31d7459dfbc5 Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com>
2011-10-19 02:53:13 +00:00
QSKIP("Floating point exception checking (fenv.h) not available"); \
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
}
#endif
FPE_TEST(fpe_rasterizeLine_task232012)
FPE_TEST(fpe_pixmapTransform)
FPE_TEST(fpe_zeroLengthLines)
FPE_TEST(fpe_divByZero)
FPE_TEST(fpe_steepSlopes)
FPE_TEST(fpe_radialGradients)
void tst_QPainter::fpe_steepSlopes_data()
{
QTest::addColumn<QTransform>("transform");
QTest::addColumn<QLineF>("line");
QTest::addColumn<bool>("antialiased");
{
const qreal dsin = 0.000014946676875461832484392500630665523431162000633776187896728515625;
const qreal dcos = 0.9999999998882984630910186751862056553363800048828125;
const QTransform transform = QTransform(QMatrix(dcos, dsin, -dsin, dcos, 64, 64));
const QLineF line(2, 2, 2, 6);
QTest::newRow("task 207147 aa") << transform << line << true;
QTest::newRow("task 207147 no aa") << transform << line << false;
}
{
QTransform transform;
transform.rotate(0.0000001);
const QLineF line(5, 5, 10, 5);
QTest::newRow("task 166702 aa") << transform << line << true;
QTest::newRow("task 166702 no aa") << transform << line << false;
}
{
const QTransform transform;
const QLineF line(2.5, 2.5, 2.5 + 1/256., 60000.5);
QTest::newRow("steep line aa") << transform << line << true;
QTest::newRow("steep line no aa") << transform << line << false;
}
{
const QTransform transform;
const QLineF line(2.5, 2.5, 2.5 + 1/256., 1024);
QTest::newRow("steep line 2 aa") << transform << line << true;
QTest::newRow("steep line 2 no aa") << transform << line << false;
}
{
const QTransform transform;
const QLineF line(2.5, 2.5, 2.5 + 1/64., 1024);
QTest::newRow("steep line 3 aa") << transform << line << true;
QTest::newRow("steep line 3 no aa") << transform << line << false;
}
}
qreal randf()
{
return rand() / (RAND_MAX + 1.0);
}
QPointF randInRect(const QRectF &rect)
{
const qreal x = rect.left() + rect.width() * randf();
const qreal y = rect.top() + rect.height() * randf();
return QPointF(x, y);
}
void tst_QPainter::rasterizer_asserts()
{
QImage img(64, 64, QImage::Format_ARGB32_Premultiplied);
QRectF middle(QPointF(0, 0), img.size());
QRectF left = middle.translated(-middle.width(), 0);
QRectF right = middle.translated(middle.width(), 0);
QPainter p(&img);
img.fill(Qt::white);
p.setCompositionMode(QPainter::CompositionMode_Destination);
for (int i = 0; i < 100000; ++i) {
QPainterPath path;
path.moveTo(randInRect(middle));
path.lineTo(randInRect(left));
path.lineTo(randInRect(right));
p.fillPath(path, Qt::black);
}
}
void tst_QPainter::rasterizer_negativeCoords()
{
QImage img(64, 64, QImage::Format_ARGB32_Premultiplied);
img.fill(0x0);
QImage original = img;
QPainter p(&img);
p.rotate(90);
p.fillRect(0, 0, 70, 50, Qt::black);
// image should not have changed
QCOMPARE(img.pixel(0, 0), 0x0U);
QCOMPARE(img, original);
}
void tst_QPainter::blendOverFlow_data()
{
QTest::addColumn<QImage::Format>("format");
QTest::addColumn<int>("width");
QTest::addColumn<int>("height");
QImage::Format format = QImage::Format_ARGB8555_Premultiplied;
QTest::newRow("555,1,1") << format << 1 << 1;
QTest::newRow("555,2,2") << format << 2 << 2;
QTest::newRow("555,10,10") << format << 10 << 10;
format = QImage::Format_ARGB8565_Premultiplied;
QTest::newRow("565,1,1") << format << 1 << 1;
QTest::newRow("565,2,2") << format << 2 << 2;
QTest::newRow("565,10,10") << format << 10 << 10;
}
void tst_QPainter::blendOverFlow()
{
QFETCH(QImage::Format, format);
QFETCH(int, width);
QFETCH(int, height);
QImage dest(width, height, format);
QImage src(width, height, format);
{
QPainter p(&dest);
p.fillRect(0, 0, width, height, Qt::green);
}
QImage expected = dest;
{
QPainter p(&src);
p.setCompositionMode(QPainter::CompositionMode_Source);
p.fillRect(0, 0, width, height, QColor(0, 255, 0, 6));
}
{
QPainter p(&dest);
p.drawImage(0, 0, src);
}
QCOMPARE(dest.pixel(0, 0), expected.pixel(0, 0));
QCOMPARE(dest, expected);
}
void tst_QPainter::largeImagePainting_data()
{
QTest::addColumn<int>("width");
QTest::addColumn<int>("height");
QTest::addColumn<bool>("antialiased");
QTest::newRow("tall") << 1 << 32767 << false;
QTest::newRow("tall aa") << 1 << 32767 << true;
QTest::newRow("wide") << 32767 << 1 << false;
QTest::newRow("wide aa") << 32767 << 1 << true;
}
void tst_QPainter::largeImagePainting()
{
QPainterPath path;
path.addRect(0, 0, 1, 1);
path.addRect(2, 0, 1, 1);
path.addRect(0, 2, 1, 1);
QFETCH(int, width);
QFETCH(int, height);
QFETCH(bool, antialiased);
QImage img(width, height, QImage::Format_ARGB32_Premultiplied);
img.fill(0x0);
QPainter p(&img);
p.setPen(Qt::NoPen);
p.setBrush(Qt::white);
p.setRenderHint(QPainter::Antialiasing, antialiased);
for (int i = 0; i < img.width(); i += 4) {
p.drawPath(path);
p.translate(4, 0);
}
p.resetMatrix();
for (int i = 4; i < img.height(); i += 4) {
p.translate(0, 4);
p.drawPath(path);
}
for (int i = 0; i < img.width(); ++i) {
if (i % 2)
QCOMPARE(img.pixel(i, 0), 0x0U);
else
QCOMPARE(img.pixel(i, 0), 0xffffffffU);
}
for (int i = 1; i < img.height(); ++i) {
if (i % 2)
QCOMPARE(img.pixel(0, i), 0x0U);
else
QCOMPARE(img.pixel(0, i), 0xffffffffU);
}
}
void tst_QPainter::imageScaling_task206785()
{
QImage src(32, 2, QImage::Format_ARGB32_Premultiplied);
src.fill(0xffffffff);
QImage dst(128, 128, QImage::Format_ARGB32_Premultiplied);
QImage expected(128, 128, QImage::Format_ARGB32_Premultiplied);
expected.fill(0xffffffff);
for (int i = 1; i < 5; ++i) {
qreal scale = i / qreal(5);
dst.fill(0xff000000);
QPainter p(&dst);
p.scale(dst.width() / qreal(src.width()), scale);
for (int y = 0; y * scale < dst.height(); ++y)
p.drawImage(0, y, src);
p.end();
QCOMPARE(dst, expected);
}
}
#define FOR_EACH_NEIGHBOR_8 for (int dx = -1; dx <= 1; ++dx) for (int dy = -1; dy <= 1; ++dy) if (dx != 0 || dy != 0)
#define FOR_EACH_NEIGHBOR_4 for (int dx = -1; dx <= 1; ++dx) for (int dy = -1; dy <= 1; ++dy) if ((dx == 0) != (dy == 0))
uint qHash(const QPoint &point)
{
return qHash(qMakePair(point.x(), point.y()));
}
bool verifyOutlineFillConsistency(const QImage &img, QRgb outside, QRgb inside, QRgb outline)
{
if (img.pixel(img.width() / 2, img.height() / 2) != inside)
return false;
int x = img.width() / 2;
int y = img.height() / 2;
while (img.pixel(++x, y) == inside)
;
if (img.pixel(x, y) != outline)
return false;
QQueue<QPoint> discovered;
discovered.enqueue(QPoint(x, y));
QVector<bool> visited(img.width() * img.height());
visited.fill(false);
while (!discovered.isEmpty()) {
QPoint p = discovered.dequeue();
QRgb pixel = img.pixel(p.x(), p.y());
bool &v = visited[p.y() * img.width() + p.x()];
if (v)
continue;
v = true;
if (pixel == outline) {
FOR_EACH_NEIGHBOR_8 {
QPoint x(p.x() + dx, p.y() + dy);
discovered.enqueue(x);
}
} else {
FOR_EACH_NEIGHBOR_4 {
if ((dx == 0) == (dy == 0))
continue;
QRgb neighbor = img.pixel(p.x() + dx, p.y() + dy);
if ((pixel == inside && neighbor == outside) ||
(pixel == outside && neighbor == inside))
return false;
}
}
}
return true;
}
#undef FOR_EACH_NEIGHBOR_8
#undef FOR_EACH_NEIGHBOR_4
void tst_QPainter::outlineFillConsistency()
{
QImage dst(256, 256, QImage::Format_ARGB32_Premultiplied);
QPolygonF poly;
poly << QPointF(5, -100) << QPointF(-70, 20) << QPointF(95, 25);
QPen pen(Qt::red);
QBrush brush(Qt::black);
QRgb background = 0xffffffff;
for (int i = 0; i < 360; ++i) {
dst.fill(background);
QPainter p(&dst);
p.translate(dst.width() / 2, dst.height() / 2);
QPolygonF copy = poly;
for (int j = 0; j < copy.size(); ++j)
copy[j] = QTransform().rotate(i).map(copy[j]);
p.setPen(pen);
p.setBrush(brush);
p.drawPolygon(copy);
p.end();
QVERIFY(verifyOutlineFillConsistency(dst, background, brush.color().rgba(), pen.color().rgba()));
}
}
void tst_QPainter::drawImage_task217400_data()
{
QTest::addColumn<QImage::Format>("format");
QTest::newRow("444") << QImage::Format_ARGB4444_Premultiplied;
QTest::newRow("555") << QImage::Format_ARGB8555_Premultiplied;
QTest::newRow("565") << QImage::Format_ARGB8565_Premultiplied;
// QTest::newRow("666") << QImage::Format_ARGB6666_Premultiplied;
QTest::newRow("888p") << QImage::Format_ARGB32_Premultiplied;
QTest::newRow("888") << QImage::Format_ARGB32;
}
void tst_QPainter::drawImage_task217400()
{
QFETCH(QImage::Format, format);
Changed qpainter unittest to work from installation directory - Changed to use QFINDTESTDATA and TESTDATA Change-Id: If75ae2b8e39f6388f4e84ed4aa2681b5a5917e81 Reviewed-by: Kurt Korbatits <kurt.korbatits@nokia.com> Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com> Reviewed-by: Jason McDonald <jason.mcdonald@nokia.com>
2012-01-16 23:41:17 +00:00
const QImage src = QImage(QFINDTESTDATA("task217400.png"))
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
.convertToFormat(format);
QVERIFY(!src.isNull());
QImage expected(src.size(), format);
{
QPainter p(&expected);
p.fillRect(0, 0, expected.width(), expected.height(), Qt::white);
p.drawImage(0, 0, src);
}
for (int i = 1; i <= 4; ++i) {
QImage dest(src.width() + i, src.height(), format);
{
QPainter p(&dest);
p.fillRect(0, 0, dest.width(), dest.height(), Qt::white);
p.drawImage(i, 0, src);
}
const QImage result = dest.copy(i, 0, src.width(), src.height());
QCOMPARE(result, expected);
}
}
void tst_QPainter::drawImage_task258776()
{
QImage src(16, 16, QImage::Format_RGB888);
QImage dest(33, 33, QImage::Format_RGB888);
src.fill(0x00ff00);
Made QImage::fill(uint pixel) for RGB888 accept QRgb values. Previously QImage::fill() for Format_RGB888 expected a BGR value instead of the RGB order defined by QRgb, making it counter intuitive to use related to the 32-bit formats. Fixed the QPixelLayout data for RGB888 and changed the byte order of quint24 based on what the optimized image conversion routines expect. Change-Id: I72926debbc6f5b5cb10b8aa0b2a2a916a04db946 Reviewed-by: Kim M. Kalland <kim.kalland@nokia.com>
2012-07-24 13:23:49 +00:00
dest.fill(0xff0000);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
QPainter painter(&dest);
painter.drawImage(QRectF(0.499, 0.499, 32, 32), src, QRectF(0, 0, 16, 16));
painter.end();
QImage expected(33, 33, QImage::Format_RGB32);
expected.fill(0xff0000);
painter.begin(&expected);
painter.drawImage(QRectF(0, 0, 32, 32), src);
painter.end();
dest = dest.convertToFormat(QImage::Format_RGB32);
dest.save("dest.png");
expected.save("expected.png");
QCOMPARE(dest, expected);
}
Fixed invalid memory read in SSSE3 image blending code. We need to do bounds comparison on the actual offset we're going to use with _mm_load_si128 to read 16 bytes from memory (even though we won't use the trailing bytes in the end). Task-number: QTBUG-28324 Change-Id: Id0d6094da796ca67338d8ad225fa6b2f309bbe6e Reviewed-by: Olivier Goffart <ogoffart@woboq.com>
2012-12-14 09:52:47 +00:00
void tst_QPainter::drawImage_QTBUG28324()
{
QImage dest(512, 512, QImage::Format_ARGB32_Premultiplied);
dest.fill(0x0);
int x = 263; int y = 89; int w = 61; int h = 39;
QImage source(w, h, QImage::Format_ARGB32_Premultiplied);
quint32 *b = (quint32 *)source.bits();
for (int j = 0; j < w * h; ++j)
b[j] = 0x7f7f7f7f;
// nothing to test here since the bug is about
// an invalid memory read, which valgrind
// would complain about
QPainter p(&dest);
p.drawImage(x, y, source);
}
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void tst_QPainter::clipRectSaveRestore()
{
QImage img(64, 64, QImage::Format_ARGB32_Premultiplied);
img.fill(0x0);
QPainter p(&img);
p.setClipRect(QRect(0, 0, 10, 10));
p.save();
p.setClipRect(QRect(5, 5, 5, 5), Qt::IntersectClip);
p.restore();
p.fillRect(0, 0, 64, 64, Qt::black);
p.end();
QCOMPARE(img.pixel(0, 0), QColor(Qt::black).rgba());
}
void tst_QPainter::clippedImage()
{
QImage img(16, 16, QImage::Format_ARGB32_Premultiplied);
img.fill(0x0);
QImage src(16, 16, QImage::Format_RGB32);
src.fill(QColor(Qt::red).rgba());
QPainter p(&img);
p.setClipRect(QRect(1, 1, 14, 14));
p.drawImage(0, 0, src);
p.end();
QCOMPARE(img.pixel(0, 0), 0x0U);
QCOMPARE(img.pixel(1, 1), src.pixel(1, 1));
}
void tst_QPainter::stateResetBetweenQPainters()
{
QImage img(16, 16, QImage::Format_ARGB32);
{
QPainter p(&img);
p.setCompositionMode(QPainter::CompositionMode_Source);
p.fillRect(0, 0, 16, 16, Qt::red);
}
{
QPainter p2(&img);
p2.fillRect(0, 0, 16, 16, QColor(0, 0, 255, 63));
}
img.save("foo.png");
QVERIFY(img.pixel(0, 0) != qRgba(0, 0, 255, 63));
QVERIFY(qRed(img.pixel(0, 0)) > 0); // We didn't erase the red channel...
QVERIFY(qBlue(img.pixel(0, 0)) < 255); // We blended the blue channel
}
void tst_QPainter::drawRect_task215378()
{
QImage img(11, 11, QImage::Format_ARGB32_Premultiplied);
img.fill(QColor(Qt::white).rgba());
QPainter p(&img);
p.setPen(QColor(127, 127, 127, 127));
p.drawRect(0, 0, 10, 10);
p.end();
QCOMPARE(img.pixel(0, 0), img.pixel(1, 0));
QCOMPARE(img.pixel(0, 0), img.pixel(0, 1));
QVERIFY(img.pixel(0, 0) != img.pixel(1, 1));
}
void tst_QPainter::drawRect_task247505()
{
QImage a(10, 10, QImage::Format_ARGB32_Premultiplied);
a.fill(0);
QImage b = a;
QPainter p(&a);
p.setPen(Qt::NoPen);
p.setBrush(Qt::black);
p.drawRect(QRectF(10, 0, -10, 10));
p.end();
p.begin(&b);
p.setPen(Qt::NoPen);
p.setBrush(Qt::black);
p.drawRect(QRectF(0, 0, 10, 10));
p.end();
QCOMPARE(a, b);
}
void tst_QPainter::drawImage_data()
{
QTest::addColumn<int>("x");
QTest::addColumn<int>("y");
QTest::addColumn<int>("w");
QTest::addColumn<int>("h");
QTest::addColumn<QImage::Format>("srcFormat");
QTest::addColumn<QImage::Format>("dstFormat");
for (int srcFormat = QImage::Format_Mono; srcFormat < QImage::NImageFormats; ++srcFormat) {
for (int dstFormat = QImage::Format_Mono; dstFormat < QImage::NImageFormats; ++dstFormat) {
Add Grayscale8 and Alpha8 formats to QImage and drawing Extend the QImage format with two 8-bit grayscale and alpha formats. These formats have the advantage over Indexed8 that they have simpler conversion and can be rendered to by the raster engine. [ChangeLog][QtGui][QImage] Added support grayscale and alpha 8-bit formats which can also be rendered to. Change-Id: I4343c80a92a3dda196aa38d0c3ea251b094fc274 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2014-02-14 09:39:30 +00:00
// Indexed8 can't be painted to, and Alpha8 can't hold a color.
if (dstFormat == QImage::Format_Indexed8 || dstFormat == QImage::Format_Alpha8)
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
continue;
for (int odd_x = 0; odd_x <= 1; ++odd_x) {
for (int odd_width = 0; odd_width <= 1; ++odd_width) {
QString description =
QString("srcFormat %1, dstFormat %2, odd x: %3, odd width: %4")
.arg(srcFormat).arg(dstFormat).arg(odd_x).arg(odd_width);
QTest::newRow(qPrintable(description)) << (10 + odd_x) << 10 << (20 + odd_width) << 20
<< QImage::Format(srcFormat)
<< QImage::Format(dstFormat);
}
}
}
}
}
bool verifyImage(const QImage &img, int x, int y, int w, int h, uint background)
{
int imgWidth = img.width();
int imgHeight = img.height();
for (int i = 0; i < imgHeight; ++i) {
for (int j = 0; j < imgWidth; ++j) {
uint pixel = img.pixel(j, i);
bool outside = j < x || j >= (x + w) || i < y || i >= (y + h);
if (outside != (pixel == background)) {
//printf("%d %d, expected %x, got %x, outside: %d\n", x, y, background, pixel, outside);
return false;
}
}
}
return true;
}
void tst_QPainter::drawImage()
{
QFETCH(int, x);
QFETCH(int, y);
QFETCH(int, w);
QFETCH(int, h);
QFETCH(QImage::Format, srcFormat);
QFETCH(QImage::Format, dstFormat);
QImage dst(40, 40, QImage::Format_RGB32);
dst.fill(0xffffffff);
dst = dst.convertToFormat(dstFormat);
uint background = dst.pixel(0, 0);
QImage src(w, h, QImage::Format_RGB32);
src.fill(0xff000000);
src = src.convertToFormat(srcFormat);
QPainter p(&dst);
p.drawImage(x, y, src);
p.end();
QVERIFY(verifyImage(dst, x, y, w, h, background));
}
void tst_QPainter::imageCoordinateLimit()
{
QImage img(64, 40000, QImage::Format_MonoLSB);
QPainter p(&img);
p.drawText(10, 36000, QLatin1String("foo"));
p.setPen(QPen(Qt::black, 2));
p.drawLine(10, 0, 60, 40000);
p.setRenderHint(QPainter::Antialiasing);
p.drawLine(10, 0, 60, 40000);
}
void tst_QPainter::imageBlending_data()
{
QTest::addColumn<QImage::Format>("sourceFormat");
QTest::addColumn<QImage::Format>("destFormat");
QTest::addColumn<int>("error");
int error_rgb565 = ((1<<3) + (1<<2) + (1<<3));
QTest::newRow("rgb565_on_rgb565") << QImage::Format_RGB16
<< QImage::Format_RGB16
<< 0;
QTest::newRow("argb8565_on_rgb565") << QImage::Format_ARGB8565_Premultiplied
<< QImage::Format_RGB16
<< error_rgb565;
QTest::newRow("rgb32_on_rgb565") << QImage::Format_RGB32
<< QImage::Format_RGB16
<< error_rgb565;
QTest::newRow("argb32pm_on_rgb565") << QImage::Format_ARGB32_Premultiplied
<< QImage::Format_RGB16
<< error_rgb565;
}
int diffColor(quint32 ap, quint32 bp)
{
int a = qAlpha(ap) - qAlpha(bp);
int r = qRed(ap) - qRed(bp);
int b = qBlue(ap) - qBlue(bp);
int g = qBlue(ap) - qBlue(bp);
return qAbs(a) + qAbs(r) + qAbs(g) + qAbs(b);
}
// this test assumes premultiplied pixels...
void tst_QPainter::imageBlending()
{
QFETCH(QImage::Format, sourceFormat);
QFETCH(QImage::Format, destFormat);
QFETCH(int, error);
QImage dest;
{
QImage orig_dest(6, 6, QImage::Format_ARGB32_Premultiplied);
orig_dest.fill(0);
QPainter p(&orig_dest);
p.fillRect(0, 0, 6, 3, QColor::fromRgbF(1, 0, 0));
p.fillRect(3, 0, 3, 6, QColor::fromRgbF(0, 0, 1, 0.5));
p.end();
dest = orig_dest.convertToFormat(destFormat);
// An image like this: (r = red, m = magenta, b = light alpha blue, 0 = transparent)
// r r r m m m
// r r r m m m
// r r r m m m
// 0 0 0 b b b
// 0 0 0 b b b
// 0 0 0 b b b
}
QImage source;
{
QImage orig_source(6, 6, QImage::Format_ARGB32_Premultiplied);
orig_source.fill(0);
QPainter p(&orig_source);
p.fillRect(1, 1, 4, 4, QColor::fromRgbF(0, 1, 0, 0.5));
p.fillRect(2, 2, 2, 2, QColor::fromRgbF(0, 1, 0));
p.end();
source = orig_source.convertToFormat(sourceFormat);
// An image like this: (0 = transparent, . = green at 0.5 alpha, g = opaque green.
// 0 0 0 0 0 0
// 0 . . . . 0
// 0 . g g . 0
// 0 . g g . 0
// 0 . . . . 0
// 0 0 0 0 0 0
}
QPainter p(&dest);
p.drawImage(0, 0, source);
p.end();
// resulting image:
// r r r m m m
// r r. r. m. m. m
// r r. g g m. m
// 0 . g g b. b
// 0 . . b. b. b
// 0 0 0 b b b
// the g pixels, always green..
QVERIFY(diffColor(dest.pixel(2, 2), 0xff00ff00) <= error); // g
if (source.hasAlphaChannel()) {
QVERIFY(diffColor(dest.pixel(0, 0), 0xffff0000) <= error); // r
QVERIFY(diffColor(dest.pixel(5, 0), 0xff7f007f) <= error); // m
QVERIFY(diffColor(dest.pixel(1, 1), 0xff7f7f00) <= error); // r.
QVERIFY(diffColor(dest.pixel(4, 1), 0xff3f7f3f) <= error); // m.
if (dest.hasAlphaChannel()) {
QVERIFY(diffColor(dest.pixel(1, 3), 0x7f007f00) <= error); // .
QVERIFY(diffColor(dest.pixel(4, 3), 0x7f007f3f) <= error); // b.
QVERIFY(diffColor(dest.pixel(4, 3), 0x7f007f3f) <= error); // b.
QVERIFY(diffColor(dest.pixel(4, 4), 0x7f00007f) <= error); // b
QVERIFY(diffColor(dest.pixel(4, 0), 0) <= 0); // 0
}
} else {
QVERIFY(diffColor(dest.pixel(0, 0), 0xff000000) <= 0);
QVERIFY(diffColor(dest.pixel(1, 1), 0xff007f00) <= error);
}
}
void tst_QPainter::imageBlending_clipped()
{
QImage src(20, 20, QImage::Format_RGB16);
QPainter p(&src);
p.fillRect(src.rect(), Qt::red);
p.end();
QImage dst(40, 20, QImage::Format_RGB16);
p.begin(&dst);
p.fillRect(dst.rect(), Qt::white);
p.end();
QImage expected = dst;
p.begin(&dst);
p.setClipRect(QRect(23, 0, 20, 20));
// should be completely clipped
p.drawImage(QRectF(3, 0, 20, 20), src);
p.end();
// dst should be left unchanged
QCOMPARE(dst, expected);
}
void tst_QPainter::paintOnNullPixmap()
{
QPixmap pix(16, 16);
QPixmap textPixmap;
QPainter p(&textPixmap);
p.drawPixmap(10, 10, pix);
p.end();
QPixmap textPixmap2(16,16);
p.begin(&textPixmap2);
p.end();
}
void tst_QPainter::checkCompositionMode()
{
QImage refImage(50,50,QImage::Format_ARGB32);
QPainter painter(&refImage);
painter.fillRect(QRect(0,0,50,50),Qt::blue);
QImage testImage(50,50,QImage::Format_ARGB32);
QPainter p(&testImage);
p.fillRect(QRect(0,0,50,50),Qt::red);
p.save();
p.setCompositionMode(QPainter::CompositionMode_SourceOut);
p.restore();
p.fillRect(QRect(0,0,50,50),Qt::blue);
QCOMPARE(refImage.pixel(20,20),testImage.pixel(20,20));
}
static QLinearGradient inverseGradient(QLinearGradient g)
{
QLinearGradient g2 = g;
QGradientStops stops = g.stops();
QGradientStops inverse;
foreach (QGradientStop stop, stops)
inverse << QGradientStop(1 - stop.first, stop.second);
g2.setStops(inverse);
return g2;
}
Improved gradient table generation performance for two-stop gradients. Two stops is a fairly common case so we gain quite a bit by special casing it. Improves performance by 10 % in parcycle benchmark, and by 90 % in a synthetic benchmark. Reviewed-by: Andreas Kling (cherry picked from commit 5b74a70ac630073582be56f8a0539624a1080185)
2011-04-13 08:15:06 +00:00
void tst_QPainter::linearGradientSymmetry_data()
{
QTest::addColumn<QGradientStops>("stops");
Made linearGradientSymmetry test pass on qreal=float platforms. We need to loosen the requirements a bit when qreal is float... Just skip the two failing test cases for now. Reviewed-by: Eskil Abrahamsen Blomfeldt (cherry picked from commit 3c659eb590aecbcdb40cb498901e757e780fa892)
2011-04-18 08:31:05 +00:00
if (sizeof(qreal) != sizeof(float)) {
Improved gradient table generation performance for two-stop gradients. Two stops is a fairly common case so we gain quite a bit by special casing it. Improves performance by 10 % in parcycle benchmark, and by 90 % in a synthetic benchmark. Reviewed-by: Andreas Kling (cherry picked from commit 5b74a70ac630073582be56f8a0539624a1080185)
2011-04-13 08:15:06 +00:00
QGradientStops stops;
stops << qMakePair(qreal(0.0), QColor(Qt::blue));
stops << qMakePair(qreal(0.2), QColor(220, 220, 220, 0));
stops << qMakePair(qreal(0.6), QColor(Qt::red));
stops << qMakePair(qreal(0.9), QColor(220, 220, 220, 255));
stops << qMakePair(qreal(1.0), QColor(Qt::black));
QTest::newRow("multiple stops") << stops;
}
{
QGradientStops stops;
stops << qMakePair(qreal(0.0), QColor(Qt::blue));
stops << qMakePair(qreal(1.0), QColor(Qt::black));
QTest::newRow("two stops") << stops;
}
Made linearGradientSymmetry test pass on qreal=float platforms. We need to loosen the requirements a bit when qreal is float... Just skip the two failing test cases for now. Reviewed-by: Eskil Abrahamsen Blomfeldt (cherry picked from commit 3c659eb590aecbcdb40cb498901e757e780fa892)
2011-04-18 08:31:05 +00:00
if (sizeof(qreal) != sizeof(float)) {
Improved gradient table generation performance for two-stop gradients. Two stops is a fairly common case so we gain quite a bit by special casing it. Improves performance by 10 % in parcycle benchmark, and by 90 % in a synthetic benchmark. Reviewed-by: Andreas Kling (cherry picked from commit 5b74a70ac630073582be56f8a0539624a1080185)
2011-04-13 08:15:06 +00:00
QGradientStops stops;
stops << qMakePair(qreal(0.3), QColor(Qt::blue));
stops << qMakePair(qreal(0.6), QColor(Qt::black));
QTest::newRow("two stops 2") << stops;
}
}
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void tst_QPainter::linearGradientSymmetry()
{
Improved gradient table generation performance for two-stop gradients. Two stops is a fairly common case so we gain quite a bit by special casing it. Improves performance by 10 % in parcycle benchmark, and by 90 % in a synthetic benchmark. Reviewed-by: Andreas Kling (cherry picked from commit 5b74a70ac630073582be56f8a0539624a1080185)
2011-04-13 08:15:06 +00:00
QFETCH(QGradientStops, stops);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
QImage a(64, 8, QImage::Format_ARGB32_Premultiplied);
QImage b(64, 8, QImage::Format_ARGB32_Premultiplied);
a.fill(0);
b.fill(0);
QLinearGradient gradient(QRectF(b.rect()).topLeft(), QRectF(b.rect()).topRight());
Improved gradient table generation performance for two-stop gradients. Two stops is a fairly common case so we gain quite a bit by special casing it. Improves performance by 10 % in parcycle benchmark, and by 90 % in a synthetic benchmark. Reviewed-by: Andreas Kling (cherry picked from commit 5b74a70ac630073582be56f8a0539624a1080185)
2011-04-13 08:15:06 +00:00
gradient.setStops(stops);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
QPainter pa(&a);
pa.fillRect(a.rect(), gradient);
pa.end();
QPainter pb(&b);
pb.fillRect(b.rect(), inverseGradient(gradient));
pb.end();
b = b.mirrored(true);
QCOMPARE(a, b);
Don't depend on moc to disable test functions. The moc tool is not aware of all defines (particularly those that are compiler builtins) and does not correctly evaluate others that depend on compiler builtins, such as Q_OS_FOO. This commit reverts parts of the following commits, but is not a complete fix as there were many instances of this problem in the tests prior to those commits: 924d810dbdcd5b5b0fa860922b2487ea9062d002 8aaff6751038b88d17e23be6fcee945771297c5b 338d3f11973412047c2c9cd41cbd0c961d738ef3 a55034062ba2bf73a9f1ed3d9cf31745b38149e3 253497b7446c7d723aa3bdd7152e25d6852f2604 7cfad460c56319ba89c4a3a0bbcb2e54ab1cdbc6 9d2ff58f3642828e494e7e9b2df7dbb8e2cd408f 0cf6baa2d61ebaad2a2a0530c37f27e719b68f4b Change-Id: I947d797fe3ec76139ba1b55561cea569895662c5 Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com>
2011-11-15 01:36:18 +00:00
}
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
Fix drawing vertical gradients in RGBA8888 formats The RGBA8888 formats was incorrectly using the qt_gradient_quint32 which is argb specific. This caused vertical gradients but only vertical gradients to be drawn incorrectly. This changes the RGBA8888 formats formats to use the generic gradient method and renames qt_gradient_quint32 to qt_gradient_argb32 to indicate its limitation. Change-Id: Ia1cd48ca7f4f78b64f31d6263e81cd8ac3b0954e Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-02-07 13:38:47 +00:00
void tst_QPainter::gradientPixelFormat_data()
{
QTest::addColumn<QImage::Format>("format");
QTest::newRow("argb32") << QImage::Format_ARGB32;
QTest::newRow("rgb32") << QImage::Format_RGB32;
QTest::newRow("rgb888") << QImage::Format_RGB888;
QTest::newRow("rgbx8888") << QImage::Format_RGBX8888;
QTest::newRow("rgba8888") << QImage::Format_RGBA8888;
QTest::newRow("rgba8888_pm") << QImage::Format_RGBA8888_Premultiplied;
}
void tst_QPainter::gradientPixelFormat()
{
QFETCH(QImage::Format, format);
QImage a(8, 64, QImage::Format_ARGB32_Premultiplied);
QImage b(8, 64, format);
QGradientStops stops;
stops << qMakePair(qreal(0.0), QColor(Qt::blue));
stops << qMakePair(qreal(0.3), QColor(Qt::red));
stops << qMakePair(qreal(0.6), QColor(Qt::green));
stops << qMakePair(qreal(1.0), QColor(Qt::black));
a.fill(0);
b.fill(0);
QLinearGradient gradient(QRectF(b.rect()).topLeft(), QRectF(b.rect()).bottomLeft());
gradient.setStops(stops);
QPainter pa(&a);
pa.fillRect(a.rect(), gradient);
pa.end();
QPainter pb(&b);
pb.fillRect(b.rect(), gradient);
pb.end();
QCOMPARE(a, b.convertToFormat(QImage::Format_ARGB32_Premultiplied));
}
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void tst_QPainter::gradientInterpolation()
{
QImage image(256, 8, QImage::Format_ARGB32_Premultiplied);
QPainter painter;
QLinearGradient gradient(QRectF(image.rect()).topLeft(), QRectF(image.rect()).topRight());
gradient.setColorAt(0.0, QColor(255, 0, 0, 0));
gradient.setColorAt(1.0, Qt::blue);
image.fill(0);
painter.begin(&image);
painter.fillRect(image.rect(), gradient);
painter.end();
const QRgb *line = reinterpret_cast<QRgb *>(image.scanLine(3));
for (int i = 0; i < 256; ++i) {
QCOMPARE(qAlpha(line[i]), qBlue(line[i])); // bright blue
QVERIFY(qAbs(qAlpha(line[i]) - i) < 3); // linear alpha
QCOMPARE(qRed(line[i]), 0); // no red component
QCOMPARE(qGreen(line[i]), 0); // no green component
}
gradient.setInterpolationMode(QGradient::ComponentInterpolation);
image.fill(0);
painter.begin(&image);
painter.fillRect(image.rect(), gradient);
painter.end();
for (int i = 1; i < 256; ++i) {
if (i < 128) {
QVERIFY(qRed(line[i]) >= qBlue(line[i])); // red is dominant
} else {
QVERIFY(qRed(line[i]) <= qBlue(line[i])); // blue is dominant
}
QVERIFY((qRed(line[i]) - 0.5) * (qAlpha(line[i - 1]) - 0.5) <= (qRed(line[i - 1]) + 0.5) * (qAlpha(line[i]) + 0.5)); // decreasing red
QVERIFY((qBlue(line[i]) + 0.5) * (qAlpha(line[i - 1]) + 0.5) >= (qBlue(line[i - 1]) - 0.5) * (qAlpha(line[i]) - 0.5)); // increasing blue
QVERIFY(qAbs(qAlpha(line[i]) - i) < 3); // linear alpha
QCOMPARE(qGreen(line[i]), 0); // no green component
}
}
Implement radial and conical gradients for rgb64 rendering Adds the last two missing source types to rgb64 rendering. Conical and radial gradients. At the same time linear gradients are moved to a template form to increase code sharing. Change-Id: I30fdd0837b0da03e3447683856ebbe4d7f48df6c Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 16:27:49 +00:00
void tst_QPainter::linearGradientRgb30_data()
Fix RGB30 painting tests Some tests were failing because the color was not read correctly from a QImage. To make it possibly to read more accurate colors a pixel accessor returing QColor has been added. Some tests also had the wrong order of arguments, confusing dest and src formats. This has been corrected, so they test what they claim to test. A test for RGB30 linear gradients is also added. Change-Id: Ic623ae1b8e0bf7383056b641c6e8230a1d7dd0dd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 09:28:33 +00:00
{
QTest::addColumn<QColor>("stop0");
QTest::addColumn<QColor>("stop1");
QTest::newRow("white->black") << QColor(Qt::white) << QColor(Qt::black);
QTest::newRow("blue->black") << QColor(Qt::blue) << QColor(Qt::black);
QTest::newRow("white->red") << QColor(Qt::white) << QColor(Qt::red);
}
Implement radial and conical gradients for rgb64 rendering Adds the last two missing source types to rgb64 rendering. Conical and radial gradients. At the same time linear gradients are moved to a template form to increase code sharing. Change-Id: I30fdd0837b0da03e3447683856ebbe4d7f48df6c Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 16:27:49 +00:00
void tst_QPainter::linearGradientRgb30()
Fix RGB30 painting tests Some tests were failing because the color was not read correctly from a QImage. To make it possibly to read more accurate colors a pixel accessor returing QColor has been added. Some tests also had the wrong order of arguments, confusing dest and src formats. This has been corrected, so they test what they claim to test. A test for RGB30 linear gradients is also added. Change-Id: Ic623ae1b8e0bf7383056b641c6e8230a1d7dd0dd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 09:28:33 +00:00
{
QFETCH(QColor, stop0);
QFETCH(QColor, stop1);
Implement radial and conical gradients for rgb64 rendering Adds the last two missing source types to rgb64 rendering. Conical and radial gradients. At the same time linear gradients are moved to a template form to increase code sharing. Change-Id: I30fdd0837b0da03e3447683856ebbe4d7f48df6c Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 16:27:49 +00:00
QLinearGradient gradient(0, 0, 1000, 1);
Fix RGB30 painting tests Some tests were failing because the color was not read correctly from a QImage. To make it possibly to read more accurate colors a pixel accessor returing QColor has been added. Some tests also had the wrong order of arguments, confusing dest and src formats. This has been corrected, so they test what they claim to test. A test for RGB30 linear gradients is also added. Change-Id: Ic623ae1b8e0bf7383056b641c6e8230a1d7dd0dd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 09:28:33 +00:00
gradient.setColorAt(0.0, stop0);
gradient.setColorAt(1.0, stop1);
Implement radial and conical gradients for rgb64 rendering Adds the last two missing source types to rgb64 rendering. Conical and radial gradients. At the same time linear gradients are moved to a template form to increase code sharing. Change-Id: I30fdd0837b0da03e3447683856ebbe4d7f48df6c Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 16:27:49 +00:00
QImage image(1000, 1, QImage::Format_RGB30);
Fix RGB30 painting tests Some tests were failing because the color was not read correctly from a QImage. To make it possibly to read more accurate colors a pixel accessor returing QColor has been added. Some tests also had the wrong order of arguments, confusing dest and src formats. This has been corrected, so they test what they claim to test. A test for RGB30 linear gradients is also added. Change-Id: Ic623ae1b8e0bf7383056b641c6e8230a1d7dd0dd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 09:28:33 +00:00
QPainter painter(&image);
painter.fillRect(image.rect(), gradient);
painter.end();
Fix overflow in rgb30 gradient tests The tests were trying to access one pixel outside of the image. Change-Id: Ieabdefbbdb76bb736214a0495bec72c881b27d2c Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-20 16:30:07 +00:00
for (int i = 1; i < 1000; ++i) {
QColor p1 = image.pixelColor(i - 1, 0);
QColor p2 = image.pixelColor(i, 0);
Implement radial and conical gradients for rgb64 rendering Adds the last two missing source types to rgb64 rendering. Conical and radial gradients. At the same time linear gradients are moved to a template form to increase code sharing. Change-Id: I30fdd0837b0da03e3447683856ebbe4d7f48df6c Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 16:27:49 +00:00
QVERIFY(p1 != p2);
QVERIFY(qGray(p1.rgb()) >= qGray(p2.rgb()));
}
}
void tst_QPainter::radialGradientRgb30_data()
{
linearGradientRgb30_data();
}
void tst_QPainter::radialGradientRgb30()
{
QFETCH(QColor, stop0);
QFETCH(QColor, stop1);
QRadialGradient gradient(0, 0, 1000);
gradient.setColorAt(0.0, stop0);
gradient.setColorAt(1.0, stop1);
QImage image(1000, 1, QImage::Format_A2BGR30_Premultiplied);
QPainter painter(&image);
painter.fillRect(image.rect(), gradient);
painter.end();
Fix overflow in rgb30 gradient tests The tests were trying to access one pixel outside of the image. Change-Id: Ieabdefbbdb76bb736214a0495bec72c881b27d2c Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-20 16:30:07 +00:00
for (int i = 1; i < 1000; ++i) {
QColor p1 = image.pixelColor(i - 1, 0);
QColor p2 = image.pixelColor(i, 0);
Fix RGB30 painting tests Some tests were failing because the color was not read correctly from a QImage. To make it possibly to read more accurate colors a pixel accessor returing QColor has been added. Some tests also had the wrong order of arguments, confusing dest and src formats. This has been corrected, so they test what they claim to test. A test for RGB30 linear gradients is also added. Change-Id: Ic623ae1b8e0bf7383056b641c6e8230a1d7dd0dd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 09:28:33 +00:00
QVERIFY(p1 != p2);
QVERIFY(qGray(p1.rgb()) >= qGray(p2.rgb()));
}
}
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void tst_QPainter::drawPolygon()
{
QImage img(128, 128, QImage::Format_ARGB32_Premultiplied);
QPainterPathStroker stroker;
stroker.setWidth(1.5);
QPainterPath path;
path.moveTo(2, 34);
path.lineTo(34, 2);
QPolygonF poly = stroker.createStroke(path).toFillPolygon();
img.fill(0xffffffff);
QPainter p(&img);
p.setRenderHint(QPainter::Antialiasing);
p.setBrush(Qt::red);
p.setPen(Qt::NoPen);
p.drawPolygon(poly);
p.translate(64, 64);
p.drawPolygon(poly);
p.end();
QImage a = img.copy();
img.fill(0xffffffff);
p.begin(&img);
p.setRenderHint(QPainter::Antialiasing);
p.setBrush(Qt::red);
p.setPen(Qt::NoPen);
p.translate(64, 64);
p.drawPolygon(poly);
p.resetTransform();
p.drawPolygon(poly);
p.end();
QCOMPARE(a, img);
}
void tst_QPainter::inactivePainter()
{
// This test succeeds if it doesn't segfault.
QPainter p;
QPainterPath path;
QRegion region(QRect(20, 20, 60, 40));
QPolygonF polygon(QVector<QPointF>() << QPointF(0, 0) << QPointF(12, 0) << QPointF(8, 6));
path.addPolygon(polygon);
p.save();
p.restore();
p.background();
p.setBackground(QBrush(Qt::blue));
p.brush();
p.setBrush(Qt::red);
p.setBrush(Qt::NoBrush);
p.setBrush(QBrush(Qt::white, Qt::DiagCrossPattern));
p.backgroundMode();
p.setBackgroundMode(Qt::OpaqueMode);
p.boundingRect(QRectF(0, 0, 100, 20), Qt::AlignCenter, QLatin1String("Hello, World!"));
p.boundingRect(QRect(0, 0, 100, 20), Qt::AlignCenter, QLatin1String("Hello, World!"));
p.brushOrigin();
p.setBrushOrigin(QPointF(12, 34));
p.setBrushOrigin(QPoint(12, 34));
p.clipPath();
p.clipRegion();
p.hasClipping();
p.setClipPath(path);
p.setClipRect(QRectF(42, 42, 42, 42));
p.setClipRect(QRect(42, 42, 42, 42));
p.setClipRegion(region);
p.setClipping(true);
p.combinedMatrix();
p.combinedTransform();
p.compositionMode();
p.setCompositionMode(QPainter::CompositionMode_Plus);
p.device();
p.deviceMatrix();
p.deviceTransform();
p.font();
p.setFont(QFont(QLatin1String("Times"), 24));
p.fontInfo();
p.fontMetrics();
p.layoutDirection();
p.setLayoutDirection(Qt::RightToLeft);
p.opacity();
p.setOpacity(0.75);
p.pen();
p.setPen(QPen(Qt::red));
p.setPen(Qt::green);
p.setPen(Qt::NoPen);
p.renderHints();
p.setRenderHint(QPainter::Antialiasing, true);
p.setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform, false);
p.resetMatrix();
p.resetTransform();
p.rotate(1);
p.scale(2, 2);
p.shear(-1, 1);
p.translate(3, 14);
p.viewTransformEnabled();
p.setViewTransformEnabled(true);
p.viewport();
p.setViewport(QRect(10, 10, 620, 460));
p.window();
p.setWindow(QRect(10, 10, 620, 460));
p.worldMatrix();
p.setWorldMatrix(QMatrix().translate(43, 21), true);
p.setWorldMatrixEnabled(true);
p.transform();
p.setTransform(QTransform().translate(12, 34), true);
p.worldTransform();
p.setWorldTransform(QTransform().scale(0.5, 0.5), true);
}
bool testCompositionMode(int src, int dst, int expected, QPainter::CompositionMode op, qreal opacity = 1.0)
{
// The test image needs to be large enough to test SIMD code
const QSize imageSize(100, 100);
QImage actual(imageSize, QImage::Format_ARGB32_Premultiplied);
actual.fill(QColor(dst, dst, dst).rgb());
QPainter p(&actual);
p.setCompositionMode(op);
p.setOpacity(opacity);
p.fillRect(QRect(QPoint(), imageSize), QColor(src, src, src));
p.end();
if (qRed(actual.pixel(0, 0)) != expected) {
qDebug("Fail: mode %d, src[%d] dst [%d] actual [%d] expected [%d]", op,
src, dst, qRed(actual.pixel(0, 0)), expected);
return false;
} else {
QImage refImage(imageSize, QImage::Format_ARGB32_Premultiplied);
refImage.fill(QColor(expected, expected, expected).rgb());
return actual == refImage;
}
}
void tst_QPainter::extendedBlendModes()
{
QVERIFY(testCompositionMode(255, 255, 255, QPainter::CompositionMode_Plus));
QVERIFY(testCompositionMode( 0, 0, 0, QPainter::CompositionMode_Plus));
QVERIFY(testCompositionMode(127, 128, 255, QPainter::CompositionMode_Plus));
QVERIFY(testCompositionMode(127, 0, 127, QPainter::CompositionMode_Plus));
QVERIFY(testCompositionMode( 0, 127, 127, QPainter::CompositionMode_Plus));
QVERIFY(testCompositionMode(255, 0, 255, QPainter::CompositionMode_Plus));
QVERIFY(testCompositionMode( 0, 255, 255, QPainter::CompositionMode_Plus));
QVERIFY(testCompositionMode(128, 128, 255, QPainter::CompositionMode_Plus));
QVERIFY(testCompositionMode(255, 255, 255, QPainter::CompositionMode_Plus, 0.3));
QVERIFY(testCompositionMode( 0, 0, 0, QPainter::CompositionMode_Plus, 0.3));
Solid and gradients in high color accuracy This patch updates the internal color precisions of solids and gradients to 16bit per color. This makes it possible to render at higher precision on non-premultiplied ARGB32, the RGB30 formats and any other hi-color formats if more are added. [ChangeLog][QtGui][Painting] Internal precision of solids and gradients is now up to 16bit per color. Change-Id: Ieae5468bd6de1f56adfa4cb9fa966faf2ed824fd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-11 10:13:03 +00:00
QVERIFY(testCompositionMode(126, 128, 165, QPainter::CompositionMode_Plus, 0.3));
QVERIFY(testCompositionMode(127, 0, 38, QPainter::CompositionMode_Plus, 0.3));
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
QVERIFY(testCompositionMode( 0, 127, 127, QPainter::CompositionMode_Plus, 0.3));
Solid and gradients in high color accuracy This patch updates the internal color precisions of solids and gradients to 16bit per color. This makes it possible to render at higher precision on non-premultiplied ARGB32, the RGB30 formats and any other hi-color formats if more are added. [ChangeLog][QtGui][Painting] Internal precision of solids and gradients is now up to 16bit per color. Change-Id: Ieae5468bd6de1f56adfa4cb9fa966faf2ed824fd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-02-11 10:13:03 +00:00
QVERIFY(testCompositionMode(255, 0, 76, QPainter::CompositionMode_Plus, 0.3));
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
QVERIFY(testCompositionMode( 0, 255, 255, QPainter::CompositionMode_Plus, 0.3));
QVERIFY(testCompositionMode(128, 128, 166, QPainter::CompositionMode_Plus, 0.3));
QVERIFY(testCompositionMode(186, 200, 255, QPainter::CompositionMode_Plus, 0.3));
QVERIFY(testCompositionMode(255, 255, 255, QPainter::CompositionMode_Multiply));
QVERIFY(testCompositionMode( 0, 0, 0, QPainter::CompositionMode_Multiply));
QVERIFY(testCompositionMode(127, 255, 127, QPainter::CompositionMode_Multiply));
QVERIFY(testCompositionMode(255, 127, 127, QPainter::CompositionMode_Multiply));
QVERIFY(testCompositionMode( 63, 255, 63, QPainter::CompositionMode_Multiply));
QVERIFY(testCompositionMode(255, 63, 63, QPainter::CompositionMode_Multiply));
QVERIFY(testCompositionMode(127, 127, 63, QPainter::CompositionMode_Multiply));
QVERIFY(testCompositionMode(255, 255, 255, QPainter::CompositionMode_Screen));
QVERIFY(testCompositionMode( 0, 0, 0, QPainter::CompositionMode_Screen));
QVERIFY(testCompositionMode( 63, 255, 255, QPainter::CompositionMode_Screen));
QVERIFY(testCompositionMode(255, 63, 255, QPainter::CompositionMode_Screen));
QVERIFY(testCompositionMode( 63, 0, 63, QPainter::CompositionMode_Screen));
QVERIFY(testCompositionMode( 0, 63, 63, QPainter::CompositionMode_Screen));
QVERIFY(testCompositionMode(127, 127, 191, QPainter::CompositionMode_Screen));
QVERIFY(testCompositionMode(255, 255, 255, QPainter::CompositionMode_Overlay));
QVERIFY(testCompositionMode( 0, 0, 0, QPainter::CompositionMode_Overlay));
QVERIFY(testCompositionMode( 63, 63, 31, QPainter::CompositionMode_Overlay));
QVERIFY(testCompositionMode( 63, 255, 255, QPainter::CompositionMode_Overlay));
QVERIFY(testCompositionMode(255, 255, 255, QPainter::CompositionMode_Darken));
QVERIFY(testCompositionMode( 0, 0, 0, QPainter::CompositionMode_Darken));
QVERIFY(testCompositionMode( 63, 63, 63, QPainter::CompositionMode_Darken));
QVERIFY(testCompositionMode( 63, 255, 63, QPainter::CompositionMode_Darken));
QVERIFY(testCompositionMode(255, 63, 63, QPainter::CompositionMode_Darken));
QVERIFY(testCompositionMode( 63, 127, 63, QPainter::CompositionMode_Darken));
QVERIFY(testCompositionMode(127, 63, 63, QPainter::CompositionMode_Darken));
QVERIFY(testCompositionMode(255, 255, 255, QPainter::CompositionMode_Lighten));
QVERIFY(testCompositionMode( 0, 0, 0, QPainter::CompositionMode_Lighten));
QVERIFY(testCompositionMode( 63, 63, 63, QPainter::CompositionMode_Lighten));
QVERIFY(testCompositionMode( 63, 255, 255, QPainter::CompositionMode_Lighten));
QVERIFY(testCompositionMode(255, 63, 255, QPainter::CompositionMode_Lighten));
QVERIFY(testCompositionMode( 63, 127, 127, QPainter::CompositionMode_Lighten));
QVERIFY(testCompositionMode(127, 63, 127, QPainter::CompositionMode_Lighten));
QVERIFY(testCompositionMode(255, 255, 255, QPainter::CompositionMode_ColorDodge));
QVERIFY(testCompositionMode( 0, 0, 0, QPainter::CompositionMode_ColorDodge));
QVERIFY(testCompositionMode( 63, 127, 169, QPainter::CompositionMode_ColorDodge));
QVERIFY(testCompositionMode(191, 127, 255, QPainter::CompositionMode_ColorDodge));
QVERIFY(testCompositionMode(127, 191, 255, QPainter::CompositionMode_ColorDodge));
QVERIFY(testCompositionMode(255, 255, 255, QPainter::CompositionMode_ColorBurn));
QVERIFY(testCompositionMode( 0, 0, 0, QPainter::CompositionMode_ColorBurn));
QVERIFY(testCompositionMode(127, 127, 0, QPainter::CompositionMode_ColorBurn));
QVERIFY(testCompositionMode(128, 128, 2, QPainter::CompositionMode_ColorBurn));
QVERIFY(testCompositionMode(191, 127, 84, QPainter::CompositionMode_ColorBurn));
QVERIFY(testCompositionMode(255, 255, 255, QPainter::CompositionMode_HardLight));
QVERIFY(testCompositionMode( 0, 0, 0, QPainter::CompositionMode_HardLight));
QVERIFY(testCompositionMode(127, 127, 127, QPainter::CompositionMode_HardLight));
QVERIFY(testCompositionMode( 63, 63, 31, QPainter::CompositionMode_HardLight));
QVERIFY(testCompositionMode(127, 63, 63, QPainter::CompositionMode_HardLight));
QVERIFY(testCompositionMode(255, 255, 255, QPainter::CompositionMode_SoftLight));
QVERIFY(testCompositionMode( 0, 0, 0, QPainter::CompositionMode_SoftLight));
QVERIFY(testCompositionMode(127, 127, 126, QPainter::CompositionMode_SoftLight));
QVERIFY(testCompositionMode( 63, 63, 39, QPainter::CompositionMode_SoftLight));
QVERIFY(testCompositionMode(127, 63, 62, QPainter::CompositionMode_SoftLight));
QVERIFY(testCompositionMode(255, 255, 0, QPainter::CompositionMode_Difference));
QVERIFY(testCompositionMode( 0, 0, 0, QPainter::CompositionMode_Difference));
QVERIFY(testCompositionMode(255, 0, 255, QPainter::CompositionMode_Difference));
QVERIFY(testCompositionMode(127, 127, 0, QPainter::CompositionMode_Difference));
QVERIFY(testCompositionMode(127, 128, 1, QPainter::CompositionMode_Difference));
QVERIFY(testCompositionMode(127, 63, 64, QPainter::CompositionMode_Difference));
QVERIFY(testCompositionMode( 0, 127, 127, QPainter::CompositionMode_Difference));
QVERIFY(testCompositionMode(255, 255, 0, QPainter::CompositionMode_Exclusion));
QVERIFY(testCompositionMode( 0, 0, 0, QPainter::CompositionMode_Exclusion));
QVERIFY(testCompositionMode(255, 0, 255, QPainter::CompositionMode_Exclusion));
QVERIFY(testCompositionMode(127, 127, 127, QPainter::CompositionMode_Exclusion));
QVERIFY(testCompositionMode( 63, 127, 127, QPainter::CompositionMode_Exclusion));
QVERIFY(testCompositionMode( 63, 63, 95, QPainter::CompositionMode_Exclusion));
QVERIFY(testCompositionMode(191, 191, 96, QPainter::CompositionMode_Exclusion));
}
void tst_QPainter::zeroOpacity()
{
QImage source(1, 1, QImage::Format_ARGB32_Premultiplied);
source.fill(0xffffffff);
QImage target(1, 1, QImage::Format_RGB32);
target.fill(0xff000000);
QPainter p(&target);
p.setOpacity(0.0);
p.drawImage(0, 0, source);
p.end();
QCOMPARE(target.pixel(0, 0), 0xff000000);
}
void tst_QPainter::clippingBug()
{
QImage img(32, 32, QImage::Format_ARGB32_Premultiplied);
img.fill(0);
QImage expected = img;
QPainter p(&expected);
p.fillRect(1, 1, 30, 30, Qt::red);
p.end();
QPainterPath path;
path.addRect(1, 1, 30, 30);
path.addRect(1, 1, 30, 30);
path.addRect(1, 1, 30, 30);
p.begin(&img);
p.setClipPath(path);
p.fillRect(0, 0, 32, 32, Qt::red);
p.end();
QCOMPARE(img, expected);
}
void tst_QPainter::emptyClip()
{
QImage img(64, 64, QImage::Format_ARGB32_Premultiplied);
QPainter p(&img);
p.setRenderHints(QPainter::Antialiasing);
p.setClipRect(0, 32, 64, 0);
p.fillRect(0, 0, 64, 64, Qt::white);
QPainterPath path;
path.lineTo(64, 0);
path.lineTo(64, 64);
path.lineTo(40, 64);
path.lineTo(40, 80);
path.lineTo(0, 80);
p.fillPath(path, Qt::green);
}
void tst_QPainter::drawImage_1x1()
{
QImage source(1, 1, QImage::Format_ARGB32_Premultiplied);
source.fill(0xffffffff);
QImage img(32, 32, QImage::Format_ARGB32_Premultiplied);
img.fill(0xff000000);
QPainter p(&img);
p.drawImage(QRectF(0.9, 0.9, 32, 32), source);
p.end();
QImage expected = img;
expected.fill(0xff000000);
p.begin(&expected);
p.fillRect(1, 1, 31, 31, Qt::white);
p.end();
QCOMPARE(img, expected);
}
void tst_QPainter::taskQT4444_dontOverflowDashOffset()
{
QPainter p;
QPen pen;
pen.setWidth(2);
pen.setStyle(Qt::DashDotLine);
QPointF point[4];
point[0] = QPointF(182.50868749707968,347.78457234212630);
point[1] = QPointF(182.50868749707968,107.22501998401277);
point[2] = QPointF(182.50868749707968,107.22501998401277);
point[3] = QPointF(520.46600762283651,107.22501998401277);
QImage crashImage(QSize(1000, 120), QImage::Format_ARGB32_Premultiplied);
p.begin(&crashImage);
p.setPen(pen);
p.drawLines(point, 2);
p.end();
QVERIFY(true); // Don't crash
}
void tst_QPainter::painterBegin()
{
QImage nullImage;
QImage indexed8Image(16, 16, QImage::Format_Indexed8);
QImage rgb32Image(16, 16, QImage::Format_RGB32);
QImage argb32Image(16, 16, QImage::Format_ARGB32_Premultiplied);
QPainter p;
// Painting on null image should fail.
QVERIFY(!p.begin(&nullImage));
// Check that the painter is not messed up by using it on another image.
QVERIFY(p.begin(&rgb32Image));
QVERIFY(p.end());
// If painting on indexed8 image fails, the painter state should still be OK.
if (p.begin(&indexed8Image))
QVERIFY(p.end());
QVERIFY(p.begin(&rgb32Image));
QVERIFY(p.end());
// Try opening a painter on the two different images.
QVERIFY(p.begin(&rgb32Image));
QVERIFY(!p.begin(&argb32Image));
QVERIFY(p.end());
// Try opening two painters on the same image.
QVERIFY(p.begin(&rgb32Image));
QPainter q;
QVERIFY(!q.begin(&rgb32Image));
QVERIFY(!q.end());
QVERIFY(p.end());
// Try ending an inactive painter.
QVERIFY(!p.end());
}
void tst_QPainter::setPenColor(QPainter& p)
{
p.setPen(Qt::NoPen);
// Setting color, then style
// Should work even though the pen is "NoPen with color", temporarily.
QPen newPen(p.pen());
newPen.setColor(Qt::red);
QCOMPARE(p.pen().style(), newPen.style());
QCOMPARE(p.pen().style(), Qt::NoPen);
p.setPen(newPen);
QCOMPARE(p.pen().color().name(), QString("#ff0000"));
QPen newPen2(p.pen());
newPen2.setStyle(Qt::SolidLine);
p.setPen(newPen2);
QCOMPARE(p.pen().color().name(), QString("#ff0000"));
}
void tst_QPainter::setPenColorOnImage()
{
QImage img(QSize(10, 10), QImage::Format_ARGB32_Premultiplied);
QPainter p(&img);
setPenColor(p);
}
void tst_QPainter::setPenColorOnPixmap()
{
QPixmap pix(10, 10);
QPainter p(&pix);
setPenColor(p);
}
Make qpainter autotest build without widgets Change-Id: I4e05871e44f7a69aaa9cd5d876c249c7dd9d86e8 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-06-05 11:58:15 +00:00
#ifndef QT_NO_WIDGETS
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
class TestProxy : public QGraphicsProxyWidget
{
public:
TestProxy() : QGraphicsProxyWidget() {}
void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
QGraphicsProxyWidget::paint(painter, option, widget);
deviceTransform = painter->deviceTransform();
}
QTransform deviceTransform;
};
class TestWidget : public QWidget
{
Q_OBJECT
public:
TestWidget() : QWidget(), painted(false) {}
void paintEvent(QPaintEvent *)
{
QPainter p(this);
deviceTransform = p.deviceTransform();
worldTransform = p.worldTransform();
painted = true;
}
QTransform deviceTransform;
QTransform worldTransform;
bool painted;
};
void tst_QPainter::QTBUG5939_attachPainterPrivate()
{
QWidget *w = new QWidget();
QGraphicsScene *scene = new QGraphicsScene();
QGraphicsView *view = new QGraphicsView(scene, w);
view->move(50 ,50);
TestProxy *proxy = new TestProxy();
TestWidget *widget = new TestWidget();
proxy->setWidget(widget);
scene->addItem(proxy);
qtbase tests: Remove QT_DISABLE_DEPRECATED_BEFORE=0 for simple cases. Fix usage of API that is marked deprecated. Change-Id: Ie31b6ee029c5b5f015fe52fb9bcd8e94b22d6cd0 Reviewed-by: Liang Qi <liang.qi@theqtcompany.com>
2015-08-24 11:35:22 +00:00
proxy->setTransform(QTransform().rotate(45));
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
w->resize(scene->sceneRect().size().toSize());
w->show();
QTRY_VERIFY(widget->painted);
QVERIFY(widget->worldTransform.isIdentity());
QCOMPARE(widget->deviceTransform, proxy->deviceTransform);
}
Make qpainter autotest build without widgets Change-Id: I4e05871e44f7a69aaa9cd5d876c249c7dd9d86e8 Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
2012-06-05 11:58:15 +00:00
#endif
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void tst_QPainter::clipBoundingRect()
{
QPixmap pix(500, 500);
QPainter p(&pix);
// Test a basic rectangle
p.setClipRect(100, 100, 200, 100);
QVERIFY(p.clipBoundingRect().contains(QRectF(100, 100, 200, 100)));
QVERIFY(!p.clipBoundingRect().contains(QRectF(50, 50, 300, 200)));
p.setClipRect(120, 120, 20, 20, Qt::IntersectClip);
QVERIFY(p.clipBoundingRect().contains(QRect(120, 120, 20, 20)));
QVERIFY(!p.clipBoundingRect().contains(QRectF(100, 100, 200, 100)));
// Test a basic float rectangle
p.setClipRect(QRectF(100, 100, 200, 100));
QVERIFY(p.clipBoundingRect().contains(QRectF(100, 100, 200, 100)));
QVERIFY(!p.clipBoundingRect().contains(QRectF(50, 50, 300, 200)));
p.setClipRect(QRectF(120, 120, 20, 20), Qt::IntersectClip);
QVERIFY(p.clipBoundingRect().contains(QRect(120, 120, 20, 20)));
QVERIFY(!p.clipBoundingRect().contains(QRectF(100, 100, 200, 100)));
// Test a basic path + region
QPainterPath path;
path.addRect(100, 100, 200, 100);
p.setClipPath(path);
QVERIFY(p.clipBoundingRect().contains(QRectF(100, 100, 200, 100)));
QVERIFY(!p.clipBoundingRect().contains(QRectF(50, 50, 300, 200)));
p.setClipRegion(QRegion(120, 120, 20, 20), Qt::IntersectClip);
QVERIFY(p.clipBoundingRect().contains(QRect(120, 120, 20, 20)));
QVERIFY(!p.clipBoundingRect().contains(QRectF(100, 100, 200, 100)));
p.setClipRect(0, 0, 500, 500);
p.translate(250, 250);
for (int i=0; i<360; ++i) {
p.rotate(1);
p.setClipRect(-100, -100, 200, 200, Qt::IntersectClip);
}
QVERIFY(p.clipBoundingRect().contains(QRectF(-100, -100, 200, 200)));
QVERIFY(!p.clipBoundingRect().contains(QRectF(-250, -250, 500, 500)));
}
test: Remove QSKIP from tst_QPainter::drawText_subPixelPositionsInRaster_qtbug5053() Change-Id: I1aa329323767a3e849beca8fe41e39dbe98de4ee Reviewed-by: Caroline Chao <caroline.chao@digia.com>
2012-10-29 22:21:35 +00:00
#if defined(Q_OS_MAC)
// Only Mac supports sub pixel positions in raster engine currently
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void tst_QPainter::drawText_subPixelPositionsInRaster_qtbug5053()
{
Don't depend on moc to disable test functions. The moc tool is not aware of all defines (particularly those that are compiler builtins) and does not correctly evaluate others that depend on compiler builtins, such as Q_OS_FOO. This commit reverts parts of the following commits, but is not a complete fix as there were many instances of this problem in the tests prior to those commits: 924d810dbdcd5b5b0fa860922b2487ea9062d002 8aaff6751038b88d17e23be6fcee945771297c5b 338d3f11973412047c2c9cd41cbd0c961d738ef3 a55034062ba2bf73a9f1ed3d9cf31745b38149e3 253497b7446c7d723aa3bdd7152e25d6852f2604 7cfad460c56319ba89c4a3a0bbcb2e54ab1cdbc6 9d2ff58f3642828e494e7e9b2df7dbb8e2cd408f 0cf6baa2d61ebaad2a2a0530c37f27e719b68f4b Change-Id: I947d797fe3ec76139ba1b55561cea569895662c5 Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com>
2011-11-15 01:36:18 +00:00
QFontMetricsF fm(qApp->font());
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
QImage baseLine(fm.width(QChar::fromLatin1('e')), fm.height(), QImage::Format_RGB32);
baseLine.fill(Qt::white);
{
QPainter p(&baseLine);
Fixed inconsistent QPainter fill rules for aliased painting. Qt 5 is the time to get rid of all the old inconsistencies in the raster paint engine caused by trying to preserve the old X11 based coordinate system where (0, 0) is in the center of the top-left pixel instead of the upper left corner of said pixel. However, this was only adhered for line drawing and path / rect filling, and not for image or pixmap drawing and not at all when doing antialiased painting. By defining the antialiased coordinate system as being the right one and letting the aliased fill rules follow from that we finally end up with some consistent behavior that doesn't lead to surprises and workarounds in application code. It is still possible for applications to get the old behavior by setting the QPainter::Qt4CompatiblePainting render hint. This should make porting easier for the few cases where an application relies on the aliased fill rules we used to have in Qt 4. Task-number: QTBUG-27500 Change-Id: If86b95e77d838ec83033d64af86632b9a73c74a9 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-10-10 10:38:07 +00:00
p.setRenderHint(QPainter::Qt4CompatiblePainting);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
p.drawText(0, fm.ascent(), QString::fromLatin1("e"));
}
bool foundDifferentRasterization = false;
for (int i=1; i<12; ++i) {
QImage comparison(baseLine.size(), QImage::Format_RGB32);
comparison.fill(Qt::white);
{
QPainter p(&comparison);
Fixed inconsistent QPainter fill rules for aliased painting. Qt 5 is the time to get rid of all the old inconsistencies in the raster paint engine caused by trying to preserve the old X11 based coordinate system where (0, 0) is in the center of the top-left pixel instead of the upper left corner of said pixel. However, this was only adhered for line drawing and path / rect filling, and not for image or pixmap drawing and not at all when doing antialiased painting. By defining the antialiased coordinate system as being the right one and letting the aliased fill rules follow from that we finally end up with some consistent behavior that doesn't lead to surprises and workarounds in application code. It is still possible for applications to get the old behavior by setting the QPainter::Qt4CompatiblePainting render hint. This should make porting easier for the few cases where an application relies on the aliased fill rules we used to have in Qt 4. Task-number: QTBUG-27500 Change-Id: If86b95e77d838ec83033d64af86632b9a73c74a9 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-10-10 10:38:07 +00:00
p.setRenderHint(QPainter::Qt4CompatiblePainting);
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
p.drawText(QPointF(i / 12.0, fm.ascent()), QString::fromLatin1("e"));
}
if (comparison != baseLine) {
foundDifferentRasterization = true;
break;
}
}
QVERIFY(foundDifferentRasterization);
}
test: Remove QSKIP from tst_QPainter::drawText_subPixelPositionsInRaster_qtbug5053() Change-Id: I1aa329323767a3e849beca8fe41e39dbe98de4ee Reviewed-by: Caroline Chao <caroline.chao@digia.com>
2012-10-29 22:21:35 +00:00
#endif
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
void tst_QPainter::drawPointScaled()
{
QImage image(32, 32, QImage::Format_RGB32);
image.fill(0xffffffff);
QPainter p(&image);
p.scale(0.1, 0.1);
QPen pen;
pen.setWidth(1000);
pen.setColor(Qt::red);
p.setPen(pen);
p.drawPoint(0, 0);
p.end();
QCOMPARE(image.pixel(16, 16), 0xffff0000);
}
class GradientProducer : public QThread
{
protected:
void run();
};
void GradientProducer::run()
{
QImage image(1, 1, QImage::Format_RGB32);
QPainter p(&image);
for (int i = 0; i < 1000; ++i) {
QLinearGradient g;
g.setColorAt(0, QColor(i % 256, 0, 0));
g.setColorAt(1, Qt::white);
p.fillRect(image.rect(), g);
}
}
void tst_QPainter::QTBUG14614_gradientCacheRaceCondition()
{
const int threadCount = 16;
GradientProducer producers[threadCount];
for (int i = 0; i < threadCount; ++i)
producers[i].start();
for (int i = 0; i < threadCount; ++i)
producers[i].wait();
}
void tst_QPainter::drawTextOpacity()
{
QImage image(32, 32, QImage::Format_RGB32);
image.fill(0xffffffff);
QPainter p(&image);
p.setPen(QColor("#6F6F6F"));
p.setOpacity(0.5);
p.drawText(5, 30, QLatin1String("Qt"));
p.end();
QImage copy = image;
image.fill(0xffffffff);
p.begin(&image);
p.setPen(QColor("#6F6F6F"));
p.drawLine(-10, -10, -1, -1);
p.setOpacity(0.5);
p.drawText(5, 30, QLatin1String("Qt"));
p.end();
QCOMPARE(image, copy);
}
void tst_QPainter::QTBUG17053_zeroDashPattern()
{
QImage image(32, 32, QImage::Format_RGB32);
image.fill(0xffffffff);
QImage original = image;
QVector<qreal> pattern;
pattern << qreal(0) << qreal(0);
QPainter p(&image);
QPen pen(Qt::black, 2.0);
pen.setDashPattern(pattern);
p.setPen(pen);
p.drawLine(0, 0, image.width(), image.height());
QCOMPARE(image, original);
}
QPainter on QBitmap: make setBrush(NoBrush) work as expected. It had no effect because of an explicit check for NoBrush. However the default in QBitmap is (unfortunately) QBrush(color0), rather than NoBrush, so the brush must be updated when calling setBrush(NoBrush). I suppose the real issue is that lastBrush is default-constructed in QRasterPaintEngine, rather than starting with the brush from QPainter, which is QBrush(color0) for the case of the bitmap. But no reason to special case NoBrush here anyway. Task-Number: QTBUG-38781 Change-Id: I9996ac12bf628920cfaf0de9c886f637a336028b Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-05-05 17:02:46 +00:00
void tst_QPainter::QTBUG38781_NoBrushAndQBitmap()
{
QBitmap bitmap(10, 10);
bitmap.fill(Qt::color0);
QPainter p(&bitmap);
p.setPen(Qt::color1);
p.drawLine(0, 1, 9, 1); // at horizontal line at y=1
p.setBrush(Qt::NoBrush);
p.drawRect(0, 0, 9, 9); // a rect all around
QRgb white = qRgb(0xff, 0xff, 0xff);
QRgb black = qRgb(0, 0, 0);
QImage image = bitmap.toImage();
QCOMPARE(image.pixel(0, 0), black);
QCOMPARE(image.pixel(5, 5), white);
// Check that the rect didn't overwrite the line
QCOMPARE(image.pixel(5, 1), black);
}
Added autotest for threaded text rendering. Task-number: QTBUG-18516 Reviewed-by: TRUSTME (cherry picked from commit 903d4dc2196df2775255c24c707bfeb571992bb7)
2011-04-26 14:01:08 +00:00
class TextDrawerThread : public QThread
{
public:
void run();
QImage rendering;
};
void TextDrawerThread::run()
{
rendering = QImage(100, 100, QImage::Format_ARGB32_Premultiplied);
rendering.fill(0);
QPainter p(&rendering);
p.fillRect(10, 10, 100, 100, Qt::blue);
p.setPen(Qt::green);
p.drawText(20, 20, "some text");
p.end();
}
void tst_QPainter::drawTextOutsideGuiThread()
{
QImage referenceRendering(100, 100, QImage::Format_ARGB32_Premultiplied);
referenceRendering.fill(0);
QPainter p(&referenceRendering);
p.fillRect(10, 10, 100, 100, Qt::blue);
p.setPen(Qt::green);
p.drawText(20, 20, "some text");
p.end();
TextDrawerThread t;
t.start();
t.wait();
QCOMPARE(referenceRendering, t.rendering);
}
Fix QPainter::drawText with complex brushes Commit d52fd497f60a3c4456994f4f10e9451d611c9ea4 introduced a call path to QPaintEngineEx::drawStaticTextItem, which has a bug in using the pen's color instead of the entire brush. This patch replaces the use of the color with the pen's brush(). Task-number: QTBUG-23450 Change-Id: Ieb3bf352c840ff0d3fb4ac678caf7b13f4f9a8f1 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@nokia.com>
2012-01-04 15:32:55 +00:00
void tst_QPainter::drawTextWithComplexBrush()
{
QImage texture(10, 10, QImage::Format_ARGB32_Premultiplied);
texture.fill(Qt::red);
QImage image(100, 100, QImage::Format_ARGB32_Premultiplied);
image.fill(Qt::white);
QPainter p(&image);
QFont f = p.font();
f.setPixelSize(70);
p.setFont(f);
QBrush brush(Qt::white);
brush.setTextureImage(texture);
p.setPen(QPen(brush, 2));
p.drawText(10, 10, "Hello World");
int paintedPixels = getPaintedPixels(image, Qt::white);
QVERIFY(paintedPixels > 0);
}
Fixed inconsistent rounding of square cap pens. A horizontal line should round up at the same time as a vertical line with square cap, when rendering at subpixel coordinates. Thus, the special casing in the cosmetic stroker of offsetting by half a pixel should be for flat caps instead of for square caps. Task-number: QTBUG-26013 Change-Id: Ic09249337f814c7de95a17976ec9e651561a744b Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-09-20 13:30:24 +00:00
void tst_QPainter::QTBUG26013_squareCapStroke()
{
QImage image(4, 4, QImage::Format_RGB32);
QPainter p(&image);
p.setPen(QPen(Qt::black, 0, Qt::SolidLine, Qt::SquareCap));
for (int i = 0; i < 3; ++i) {
qreal d = i / 3.0;
image.fill(0xffffffff);
p.drawLine(QLineF(0, d, 0, d + 2));
p.drawLine(QLineF(1, d, 3, d));
// ensure that a horizontal line and a vertical line with square cap round up (downwards) at the same time
QCOMPARE(image.pixel(0, 0), image.pixel(1, 0));
image.fill(0xffffffff);
p.drawLine(QLineF(d, 0, d + 2, 0));
p.drawLine(QLineF(d, 1, d, 3));
// ensure that a vertical line and a horizontal line with square cap round up (to the right) at the same time
QCOMPARE(image.pixel(0, 0), image.pixel(0, 1));
}
}
Fixed cosmetic line drawing where begin and end points are equal. This case has typically required specific work-arounds in other rendering paths as well. Task-number: QTBUG-25153 Change-Id: I217e710a30222792ebca3bf297e438d944c32992 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2012-10-10 14:14:32 +00:00
void tst_QPainter::QTBUG25153_drawLine()
{
QImage image(2, 2, QImage::Format_RGB32);
QVector<Qt::PenCapStyle> styles;
styles << Qt::FlatCap << Qt::SquareCap << Qt::RoundCap;
foreach (Qt::PenCapStyle style, styles) {
image.fill(0xffffffff);
QPainter p(&image);
p.setPen(QPen(Qt::black, 0, Qt::SolidLine, style));
p.drawLine(QLineF(0, 0, 0, 0));
p.end();
QCOMPARE(image.pixel(0, 0), 0xff000000);
QCOMPARE(image.pixel(0, 1), 0xffffffff);
QCOMPARE(image.pixel(1, 0), 0xffffffff);
}
}
Tests for semi transparent blend on opaque formats This patch adds tests for the consistent handling of transparent drawing results on opaque formats that was introduced with commit 6f7d370adec3054656f36b0d2a0777a8a1df3602 Change-Id: If5d11d0f2e111ef88490a4dc20a64b0858ad5426 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-01-23 09:44:08 +00:00
void tst_QPainter::blendARGBonRGB_data()
{
QTest::addColumn<QImage::Format>("dst_format");
QTest::addColumn<QImage::Format>("src_format");
QTest::addColumn<QPainter::CompositionMode>("compositionMode");
QTest::addColumn<QRgb>("color");
QTest::addColumn<int>("expected_red");
QTest::newRow("ARGB over ARGB32") << QImage::Format_ARGB32 << QImage::Format_ARGB32
<< QPainter::CompositionMode_SourceOver << qRgba(255, 0, 0, 127) << 127 ;
QTest::newRow("ARGB_PM over ARGB32") << QImage::Format_ARGB32 << QImage::Format_ARGB32_Premultiplied
<< QPainter::CompositionMode_SourceOver<< qRgba(127, 0, 0, 127) << 127;
QTest::newRow("ARGB source ARGB32") << QImage::Format_ARGB32 << QImage::Format_ARGB32
<< QPainter::CompositionMode_Source << qRgba(255, 0, 0, 127) << 255;
QTest::newRow("ARGB_PM source ARGB32") << QImage::Format_ARGB32 << QImage::Format_ARGB32_Premultiplied
<< QPainter::CompositionMode_Source << qRgba(127, 0, 0, 127) << 255;
QTest::newRow("ARGB source-in ARGB32") << QImage::Format_ARGB32 << QImage::Format_ARGB32
<< QPainter::CompositionMode_SourceIn << qRgba(255, 0, 0, 127) << 255 ;
QTest::newRow("ARGB_PM source-in ARGB32") << QImage::Format_ARGB32 << QImage::Format_ARGB32_Premultiplied
<< QPainter::CompositionMode_SourceIn << qRgba(127, 0, 0, 127) << 255;
// Only ARGB does inverse premultiply, on the rest over and source gives similar results:
QTest::newRow("ARGB over RGB32") << QImage::Format_RGB32 << QImage::Format_ARGB32
<< QPainter::CompositionMode_SourceOver << qRgba(255, 0, 0, 127) << 127;
QTest::newRow("ARGB_PM over RGB32") << QImage::Format_RGB32 << QImage::Format_ARGB32_Premultiplied
<< QPainter::CompositionMode_SourceOver << qRgba(127, 0, 0, 127) << 127;
QTest::newRow("ARGB source RGB32") << QImage::Format_RGB32 << QImage::Format_ARGB32
<< QPainter::CompositionMode_Source << qRgba(255, 0, 0, 127) << 127;
QTest::newRow("ARGB_PM source RGB32") << QImage::Format_RGB32 << QImage::Format_ARGB32_Premultiplied
<< QPainter::CompositionMode_Source << qRgba(127, 0, 0, 127) << 127;
QTest::newRow("ARGB source-in RGB32") << QImage::Format_RGB32 << QImage::Format_ARGB32
<< QPainter::CompositionMode_SourceIn << qRgba(255, 0, 0, 127) << 127;
QTest::newRow("ARGB_PM source-in RGB32") << QImage::Format_RGB32 << QImage::Format_ARGB32_Premultiplied
<< QPainter::CompositionMode_SourceIn << qRgba(127, 0, 0, 127) << 127;
QTest::newRow("ARGB over RGB888") << QImage::Format_RGB888 << QImage::Format_ARGB32
<< QPainter::CompositionMode_SourceOver << qRgba(255, 0, 0, 127) << 127;
QTest::newRow("ARGB_PM over RGB888") << QImage::Format_RGB888 << QImage::Format_ARGB32_Premultiplied
<< QPainter::CompositionMode_SourceOver << qRgba(127, 0, 0, 127) << 127;
QTest::newRow("ARGB source RGB888") << QImage::Format_RGB888 << QImage::Format_ARGB32
<< QPainter::CompositionMode_Source << qRgba(255, 0, 0, 127) << 127;
QTest::newRow("ARGB_PM source RGB888") << QImage::Format_RGB888 << QImage::Format_ARGB32_Premultiplied
<< QPainter::CompositionMode_Source << qRgba(127, 0, 0, 127) << 127;
QTest::newRow("ARGB source-in RGB888") << QImage::Format_RGB888 << QImage::Format_ARGB32
<< QPainter::CompositionMode_SourceIn << qRgba(255, 0, 0, 127) << 127;
QTest::newRow("ARGB_PM source-in RGB888") << QImage::Format_RGB888 << QImage::Format_ARGB32_Premultiplied
<< QPainter::CompositionMode_SourceIn << qRgba(127, 0, 0, 127) << 127;
QTest::newRow("ARGB over RGBx8888") << QImage::Format_RGBX8888 << QImage::Format_ARGB32
<< QPainter::CompositionMode_SourceOver << qRgba(255, 0, 0, 127) << 127;
QTest::newRow("ARGB_PM over RGBx8888") << QImage::Format_RGBX8888 << QImage::Format_ARGB32_Premultiplied
<< QPainter::CompositionMode_SourceOver << qRgba(127, 0, 0, 127) << 127;
QTest::newRow("ARGB source RGBx8888") << QImage::Format_RGBX8888 << QImage::Format_ARGB32
<< QPainter::CompositionMode_Source << qRgba(255, 0, 0, 127) << 127;
QTest::newRow("ARGB_PM source RGBx8888") << QImage::Format_RGBX8888 << QImage::Format_ARGB32_Premultiplied
<< QPainter::CompositionMode_Source << qRgba(127, 0, 0, 127) << 127;
QTest::newRow("ARGB source-in RGBx8888") << QImage::Format_RGBX8888 << QImage::Format_ARGB32
<< QPainter::CompositionMode_SourceIn << qRgba(255, 0, 0, 127) << 127;
QTest::newRow("ARGB_PM source-in RGBx8888") << QImage::Format_RGBX8888 << QImage::Format_ARGB32_Premultiplied
<< QPainter::CompositionMode_SourceIn << qRgba(127, 0, 0, 127) << 127;
Use RGB64 qdrawhelper routines for unpremultiplied formats The ARGB32PM code-path doesn't have enough precision to accurately render ARGB32 images, but the RGB64 code-path does. Since this is already a slow configuration and the most costly part is the conversion we can switch to the more accurate code-path for little cost. Task-number: QTBUG-55720 Change-Id: Ifa0afba8d8cc0c2f699bb91f51726f4ee5228f3e Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2016-12-01 11:33:29 +00:00
QTest::newRow("ARGB over RGBA8888") << QImage::Format_RGBA8888 << QImage::Format_ARGB32
<< QPainter::CompositionMode_SourceOver << qRgba(255, 0, 0, 127) << 127;
QTest::newRow("ARGB_PM over RGBA8888") << QImage::Format_RGBA8888 << QImage::Format_ARGB32_Premultiplied
<< QPainter::CompositionMode_SourceOver << qRgba(127, 0, 0, 127) << 127;
QTest::newRow("ARGB source RGBA8888") << QImage::Format_RGBA8888 << QImage::Format_ARGB32
<< QPainter::CompositionMode_Source << qRgba(255, 0, 0, 127) << 255;
QTest::newRow("ARGB_PM source RGBA8888") << QImage::Format_RGBA8888 << QImage::Format_ARGB32_Premultiplied
<< QPainter::CompositionMode_Source << qRgba(127, 0, 0, 127) << 255;
QTest::newRow("ARGB source-in RGBA8888") << QImage::Format_RGBA8888 << QImage::Format_ARGB32
<< QPainter::CompositionMode_SourceIn << qRgba(255, 0, 0, 127) << 255;
QTest::newRow("ARGB_PM source-in RGBA8888") << QImage::Format_RGBA8888 << QImage::Format_ARGB32_Premultiplied
<< QPainter::CompositionMode_SourceIn << qRgba(127, 0, 0, 127) << 255;
Tests for semi transparent blend on opaque formats This patch adds tests for the consistent handling of transparent drawing results on opaque formats that was introduced with commit 6f7d370adec3054656f36b0d2a0777a8a1df3602 Change-Id: If5d11d0f2e111ef88490a4dc20a64b0858ad5426 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-01-23 09:44:08 +00:00
QTest::newRow("ARGB over RGB16") << QImage::Format_RGB16 << QImage::Format_ARGB32
<< QPainter::CompositionMode_SourceOver << qRgba(255, 0, 0, 127) << 123;
QTest::newRow("ARGB_PM over RGB16") << QImage::Format_RGB16 << QImage::Format_ARGB32_Premultiplied
<< QPainter::CompositionMode_SourceOver << qRgba(127, 0, 0, 127) << 123;
QTest::newRow("ARGB source RGB16") << QImage::Format_RGB16 << QImage::Format_ARGB32
<< QPainter::CompositionMode_Source << qRgba(255, 0, 0, 127) << 123;
QTest::newRow("ARGB_PM source RGB16") << QImage::Format_RGB16 << QImage::Format_ARGB32_Premultiplied
<< QPainter::CompositionMode_Source << qRgba(127, 0, 0, 127) << 123;
QTest::newRow("ARGB source-in RGB16") << QImage::Format_RGB16 << QImage::Format_ARGB32
<< QPainter::CompositionMode_SourceIn << qRgba(255, 0, 0, 127) << 123;
QTest::newRow("ARGB_PM source-in RGB16") << QImage::Format_RGB16 << QImage::Format_ARGB32_Premultiplied
<< QPainter::CompositionMode_SourceIn << qRgba(127, 0, 0, 127) << 123;
QTest::newRow("ARGB over RGB666") << QImage::Format_RGB666 << QImage::Format_ARGB32
<< QPainter::CompositionMode_SourceOver << qRgba(255, 0, 0, 127) << 125;
QTest::newRow("ARGB_PM over RGB666") << QImage::Format_RGB666 << QImage::Format_ARGB32_Premultiplied
<< QPainter::CompositionMode_SourceOver << qRgba(127, 0, 0, 127) << 125;
QTest::newRow("ARGB source RGB666") << QImage::Format_RGB666 << QImage::Format_ARGB32
<< QPainter::CompositionMode_Source << qRgba(255, 0, 0, 127) << 125;
QTest::newRow("ARGB_PM source RGB666") << QImage::Format_RGB666 << QImage::Format_ARGB32_Premultiplied
<< QPainter::CompositionMode_Source << qRgba(127, 0, 0, 127) << 125;
QTest::newRow("ARGB source-in RGB666") << QImage::Format_RGB666 << QImage::Format_ARGB32
<< QPainter::CompositionMode_SourceIn << qRgba(255, 0, 0, 127) << 125;
QTest::newRow("ARGB_PM source-in RGB666") << QImage::Format_RGB666 << QImage::Format_ARGB32_Premultiplied
<< QPainter::CompositionMode_SourceIn << qRgba(127, 0, 0, 127) << 125;
Fix RGB30 painting tests Some tests were failing because the color was not read correctly from a QImage. To make it possibly to read more accurate colors a pixel accessor returing QColor has been added. Some tests also had the wrong order of arguments, confusing dest and src formats. This has been corrected, so they test what they claim to test. A test for RGB30 linear gradients is also added. Change-Id: Ic623ae1b8e0bf7383056b641c6e8230a1d7dd0dd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 09:28:33 +00:00
QTest::newRow("ARGB over RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32
Fix A2RGB30 compositing tests With two alpha-bits half opacity can not be represented, so we must use one third (85) instead of half (127). Change-Id: I2b3f1c983a3034196bf2604840945ad3a81f5b38 Reviewed-by: Liang Qi <liang.qi@theqtcompany.com>
2015-07-01 08:48:33 +00:00
<< QPainter::CompositionMode_SourceOver << qRgba(255, 0, 0, 85) << 85;
Fix RGB30 painting tests Some tests were failing because the color was not read correctly from a QImage. To make it possibly to read more accurate colors a pixel accessor returing QColor has been added. Some tests also had the wrong order of arguments, confusing dest and src formats. This has been corrected, so they test what they claim to test. A test for RGB30 linear gradients is also added. Change-Id: Ic623ae1b8e0bf7383056b641c6e8230a1d7dd0dd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 09:28:33 +00:00
QTest::newRow("ARGB_PM over RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32_Premultiplied
Fix A2RGB30 compositing tests With two alpha-bits half opacity can not be represented, so we must use one third (85) instead of half (127). Change-Id: I2b3f1c983a3034196bf2604840945ad3a81f5b38 Reviewed-by: Liang Qi <liang.qi@theqtcompany.com>
2015-07-01 08:48:33 +00:00
<< QPainter::CompositionMode_SourceOver << qRgba(85, 0, 0, 85) << 85;
Fix RGB30 painting tests Some tests were failing because the color was not read correctly from a QImage. To make it possibly to read more accurate colors a pixel accessor returing QColor has been added. Some tests also had the wrong order of arguments, confusing dest and src formats. This has been corrected, so they test what they claim to test. A test for RGB30 linear gradients is also added. Change-Id: Ic623ae1b8e0bf7383056b641c6e8230a1d7dd0dd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 09:28:33 +00:00
QTest::newRow("ARGB source RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32
Fix A2RGB30 compositing tests With two alpha-bits half opacity can not be represented, so we must use one third (85) instead of half (127). Change-Id: I2b3f1c983a3034196bf2604840945ad3a81f5b38 Reviewed-by: Liang Qi <liang.qi@theqtcompany.com>
2015-07-01 08:48:33 +00:00
<< QPainter::CompositionMode_Source << qRgba(255, 0, 0, 85) << 85;
Fix repremultiply from RGB64 to RGB30 Just like from RGB32 to RGB30 we must also repremultiply when converting from RGB64 because the alpha channel loses more precision than the other color channels. Since this is not approximated accurately in the simple blending functions and the functions are no longer needed now the main render engine supports higher accuracy, the simple blending routines for RGB30 have been removed. Change-Id: I2b7b8eb015e330a487848fc4370ad3a1e966be91 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-06-30 11:26:25 +00:00
QTest::newRow("ARGB source RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32
<< QPainter::CompositionMode_Source << qRgba(255, 0, 0, 120) << 85;
Fix RGB30 painting tests Some tests were failing because the color was not read correctly from a QImage. To make it possibly to read more accurate colors a pixel accessor returing QColor has been added. Some tests also had the wrong order of arguments, confusing dest and src formats. This has been corrected, so they test what they claim to test. A test for RGB30 linear gradients is also added. Change-Id: Ic623ae1b8e0bf7383056b641c6e8230a1d7dd0dd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 09:28:33 +00:00
QTest::newRow("ARGB_PM source RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32_Premultiplied
Fix A2RGB30 compositing tests With two alpha-bits half opacity can not be represented, so we must use one third (85) instead of half (127). Change-Id: I2b3f1c983a3034196bf2604840945ad3a81f5b38 Reviewed-by: Liang Qi <liang.qi@theqtcompany.com>
2015-07-01 08:48:33 +00:00
<< QPainter::CompositionMode_Source << qRgba(85, 0, 0, 85) << 85;
Fix repremultiply from RGB64 to RGB30 Just like from RGB32 to RGB30 we must also repremultiply when converting from RGB64 because the alpha channel loses more precision than the other color channels. Since this is not approximated accurately in the simple blending functions and the functions are no longer needed now the main render engine supports higher accuracy, the simple blending routines for RGB30 have been removed. Change-Id: I2b7b8eb015e330a487848fc4370ad3a1e966be91 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-06-30 11:26:25 +00:00
QTest::newRow("ARGB_PM source RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32_Premultiplied
<< QPainter::CompositionMode_Source << qRgba(180, 0, 0, 180) << 170;
Fix RGB30 painting tests Some tests were failing because the color was not read correctly from a QImage. To make it possibly to read more accurate colors a pixel accessor returing QColor has been added. Some tests also had the wrong order of arguments, confusing dest and src formats. This has been corrected, so they test what they claim to test. A test for RGB30 linear gradients is also added. Change-Id: Ic623ae1b8e0bf7383056b641c6e8230a1d7dd0dd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 09:28:33 +00:00
QTest::newRow("ARGB source-in RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32
Fix A2RGB30 compositing tests With two alpha-bits half opacity can not be represented, so we must use one third (85) instead of half (127). Change-Id: I2b3f1c983a3034196bf2604840945ad3a81f5b38 Reviewed-by: Liang Qi <liang.qi@theqtcompany.com>
2015-07-01 08:48:33 +00:00
<< QPainter::CompositionMode_SourceIn << qRgba(255, 0, 0, 85) << 85;
Fix RGB30 painting tests Some tests were failing because the color was not read correctly from a QImage. To make it possibly to read more accurate colors a pixel accessor returing QColor has been added. Some tests also had the wrong order of arguments, confusing dest and src formats. This has been corrected, so they test what they claim to test. A test for RGB30 linear gradients is also added. Change-Id: Ic623ae1b8e0bf7383056b641c6e8230a1d7dd0dd Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-04-13 09:28:33 +00:00
QTest::newRow("ARGB_PM source-in RGB30") << QImage::Format_RGB30 << QImage::Format_ARGB32_Premultiplied
Fix A2RGB30 compositing tests With two alpha-bits half opacity can not be represented, so we must use one third (85) instead of half (127). Change-Id: I2b3f1c983a3034196bf2604840945ad3a81f5b38 Reviewed-by: Liang Qi <liang.qi@theqtcompany.com>
2015-07-01 08:48:33 +00:00
<< QPainter::CompositionMode_SourceIn << qRgba(85, 0, 0, 85) << 85;
Tests for semi transparent blend on opaque formats This patch adds tests for the consistent handling of transparent drawing results on opaque formats that was introduced with commit 6f7d370adec3054656f36b0d2a0777a8a1df3602 Change-Id: If5d11d0f2e111ef88490a4dc20a64b0858ad5426 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-01-23 09:44:08 +00:00
}
void tst_QPainter::blendARGBonRGB()
{
QFETCH(QImage::Format, dst_format);
QFETCH(QImage::Format, src_format);
QFETCH(QPainter::CompositionMode, compositionMode);
QFETCH(QRgb, color);
QFETCH(int, expected_red);
QImage imageRgb(16,16, dst_format);
QImage imageArgb(16,16, src_format);
QPainter painter;
imageArgb.fill(color);
imageRgb.fill(Qt::black);
painter.begin(&imageRgb);
painter.setCompositionMode(compositionMode);
painter.drawImage(0, 0, imageArgb);
painter.end();
Use RGB64 qdrawhelper routines for unpremultiplied formats The ARGB32PM code-path doesn't have enough precision to accurately render ARGB32 images, but the RGB64 code-path does. Since this is already a slow configuration and the most costly part is the conversion we can switch to the more accurate code-path for little cost. Task-number: QTBUG-55720 Change-Id: Ifa0afba8d8cc0c2f699bb91f51726f4ee5228f3e Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2016-12-01 11:33:29 +00:00
QCOMPARE(imageRgb.pixelColor(0,0).red(), expected_red);
Tests for semi transparent blend on opaque formats This patch adds tests for the consistent handling of transparent drawing results on opaque formats that was introduced with commit 6f7d370adec3054656f36b0d2a0777a8a1df3602 Change-Id: If5d11d0f2e111ef88490a4dc20a64b0858ad5426 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-01-23 09:44:08 +00:00
}
Fixed artifacts when drawing same line with different clips. Expanding on the change fixing QTBUG-24762 with the realization that any line needs to be drawn in a consistent way regardless of system or painter clip, not just dashed lines. Task-number: QTBUG-25036 Change-Id: Ief7ef19cc92c52e7d792500a581a072ba032767e Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-03-14 07:51:07 +00:00
enum CosmeticStrokerPaint
{
Antialiasing,
Dashing
};
static void paint_func(QPainter *p, CosmeticStrokerPaint type)
{
p->save();
switch (type) {
case Antialiasing:
p->setPen(Qt::black);
p->setRenderHint(QPainter::Antialiasing);
p->drawLine(4, 8, 42, 42);
break;
case Dashing:
p->setPen(QPen(Qt::black, 1, Qt::DashLine, Qt::RoundCap, Qt::MiterJoin));
p->drawLine(8, 8, 42, 8);
p->drawLine(42, 8, 42, 42);
p->drawLine(42, 42, 8, 42);
p->drawLine(8, 42, 8, 8);
break;
default:
Q_ASSERT(false);
break;
}
p->restore();
}
Q_DECLARE_METATYPE(CosmeticStrokerPaint)
void tst_QPainter::cosmeticStrokerClipping_data()
Fixed dashes being rendered differently depending on system clip. We need to clip lines to the unclipped device rect in the case of dashing, since otherwise the dashes will be shifted and rendered differently when partial repaints are done. Task-number: QTBUG-24762 Change-Id: I3599b54baa552acc20bf8cc2e12f846b45f6019e Reviewed-by: Lars Knoll <lars.knoll@digia.com> Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-03-05 14:43:50 +00:00
{
Fixed artifacts when drawing same line with different clips. Expanding on the change fixing QTBUG-24762 with the realization that any line needs to be drawn in a consistent way regardless of system or painter clip, not just dashed lines. Task-number: QTBUG-25036 Change-Id: Ief7ef19cc92c52e7d792500a581a072ba032767e Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-03-14 07:51:07 +00:00
QTest::addColumn<CosmeticStrokerPaint>("paint");
QTest::newRow("antialiasing_paint") << Antialiasing;
QTest::newRow("dashing_paint") << Dashing;
Fixed dashes being rendered differently depending on system clip. We need to clip lines to the unclipped device rect in the case of dashing, since otherwise the dashes will be shifted and rendered differently when partial repaints are done. Task-number: QTBUG-24762 Change-Id: I3599b54baa552acc20bf8cc2e12f846b45f6019e Reviewed-by: Lars Knoll <lars.knoll@digia.com> Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-03-05 14:43:50 +00:00
}
Fixed artifacts when drawing same line with different clips. Expanding on the change fixing QTBUG-24762 with the realization that any line needs to be drawn in a consistent way regardless of system or painter clip, not just dashed lines. Task-number: QTBUG-25036 Change-Id: Ief7ef19cc92c52e7d792500a581a072ba032767e Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-03-14 07:51:07 +00:00
void tst_QPainter::cosmeticStrokerClipping()
Fixed dashes being rendered differently depending on system clip. We need to clip lines to the unclipped device rect in the case of dashing, since otherwise the dashes will be shifted and rendered differently when partial repaints are done. Task-number: QTBUG-24762 Change-Id: I3599b54baa552acc20bf8cc2e12f846b45f6019e Reviewed-by: Lars Knoll <lars.knoll@digia.com> Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-03-05 14:43:50 +00:00
{
Fixed artifacts when drawing same line with different clips. Expanding on the change fixing QTBUG-24762 with the realization that any line needs to be drawn in a consistent way regardless of system or painter clip, not just dashed lines. Task-number: QTBUG-25036 Change-Id: Ief7ef19cc92c52e7d792500a581a072ba032767e Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-03-14 07:51:07 +00:00
QFETCH(CosmeticStrokerPaint, paint);
Fixed dashes being rendered differently depending on system clip. We need to clip lines to the unclipped device rect in the case of dashing, since otherwise the dashes will be shifted and rendered differently when partial repaints are done. Task-number: QTBUG-24762 Change-Id: I3599b54baa552acc20bf8cc2e12f846b45f6019e Reviewed-by: Lars Knoll <lars.knoll@digia.com> Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-03-05 14:43:50 +00:00
QImage image(50, 50, QImage::Format_RGB32);
image.fill(Qt::white);
QPainter p(&image);
Fixed artifacts when drawing same line with different clips. Expanding on the change fixing QTBUG-24762 with the realization that any line needs to be drawn in a consistent way regardless of system or painter clip, not just dashed lines. Task-number: QTBUG-25036 Change-Id: Ief7ef19cc92c52e7d792500a581a072ba032767e Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-03-14 07:51:07 +00:00
paint_func(&p, paint);
Fixed dashes being rendered differently depending on system clip. We need to clip lines to the unclipped device rect in the case of dashing, since otherwise the dashes will be shifted and rendered differently when partial repaints are done. Task-number: QTBUG-24762 Change-Id: I3599b54baa552acc20bf8cc2e12f846b45f6019e Reviewed-by: Lars Knoll <lars.knoll@digia.com> Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-03-05 14:43:50 +00:00
p.end();
QImage old = image.copy();
image.paintEngine()->setSystemClip(QRect(10, 0, image.width() - 10, image.height()));
p.begin(&image);
Fixed artifacts when drawing same line with different clips. Expanding on the change fixing QTBUG-24762 with the realization that any line needs to be drawn in a consistent way regardless of system or painter clip, not just dashed lines. Task-number: QTBUG-25036 Change-Id: Ief7ef19cc92c52e7d792500a581a072ba032767e Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-03-14 07:51:07 +00:00
p.fillRect(image.rect(), Qt::white);
paint_func(&p, paint);
Fixed dashes being rendered differently depending on system clip. We need to clip lines to the unclipped device rect in the case of dashing, since otherwise the dashes will be shifted and rendered differently when partial repaints are done. Task-number: QTBUG-24762 Change-Id: I3599b54baa552acc20bf8cc2e12f846b45f6019e Reviewed-by: Lars Knoll <lars.knoll@digia.com> Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-03-05 14:43:50 +00:00
// doing same paint operation again with different system clip should not change the image
QCOMPARE(old, image);
old = image;
p.setClipRect(QRect(20, 20, 30, 30));
Fixed artifacts when drawing same line with different clips. Expanding on the change fixing QTBUG-24762 with the realization that any line needs to be drawn in a consistent way regardless of system or painter clip, not just dashed lines. Task-number: QTBUG-25036 Change-Id: Ief7ef19cc92c52e7d792500a581a072ba032767e Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-03-14 07:51:07 +00:00
p.fillRect(image.rect(), Qt::white);
paint_func(&p, paint);
Fixed dashes being rendered differently depending on system clip. We need to clip lines to the unclipped device rect in the case of dashing, since otherwise the dashes will be shifted and rendered differently when partial repaints are done. Task-number: QTBUG-24762 Change-Id: I3599b54baa552acc20bf8cc2e12f846b45f6019e Reviewed-by: Lars Knoll <lars.knoll@digia.com> Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com>
2013-03-05 14:43:50 +00:00
// ditto for regular clips
QCOMPARE(old, image);
}
Fix default implementations of raster ops In the list of default implementations, the raster ops added in ae0ddb8c729c105a5b4f32a4f6765af8fe546333 were all offset by one composition mode because of a duplicate entry in the array. The effect would be, e.g. that using the NotDestination operator would resolve to the Set operator instead. Most users will probably not have experienced this since any of the asm-based functions will be preferred. [ChangeLog][Painting] Fixed some very rare cases of mismatched raster modes in QPainter. Change-Id: Ia242b54c78acbe1c89d9b4ecd10936564ec134b2 Task-number: QTBUG-41413 Reviewed-by: Andy Shaw <andy.shaw@digia.com>
2014-09-19 08:25:05 +00:00
void tst_QPainter::RasterOp_NotDestination()
{
QImage image(3, 3, QImage::Format_RGB32);
image.fill(Qt::red);
{
QPainter p(&image);
p.setCompositionMode(QPainter::RasterOp_NotDestination);
p.fillRect(image.rect(), Qt::black);
}
uint pixel = image.pixel(1, 1);
QCOMPARE(pixel, 0xff00ffff);
}
Prevent buffer overrun when getting the glyph images The change 35bc3dc45aacaf36a8bdfccc7627136cc2e5b185 moved some padding out of QTextureGlyphCache into the font engines directly, however this was not done for the DirectWrite font engine so it caused a buffer overrun. Task-number: QTBUG-41782 Change-Id: I4e643159036f06c5edd8a742dc6694d517a47826 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@theqtcompany.com>
2015-01-05 13:26:03 +00:00
void tst_QPainter::drawTextNoHinting()
{
{
QImage image(250, 250, QImage::Format_RGB32);
QPainter p(&image);
QFont font("Arial", 8);
font.setHintingPreference(QFont::PreferNoHinting);
font.setStyleStrategy(QFont::PreferAntialias);
p.setFont(font);
p.drawText(image.rect(), "ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz");
}
// Testing for a crash when DirectWrite is used on Windows
QVERIFY(true);
}
Fix rasterization errors in aliased cosmetic drawPolyLine If a cosmetic polyline contained a 1-pixel segment, the next segment would be drawn with wrong starting point. The original fix for QTBUG-26156 had some unwanted side effects (QTBUG-31579 and now QTBUG-42398). It tried to skip start-point update if stroke() did not actually draw anything (because the segment was too small). However, to determine that, it tested for a change in lastPixel. But that was not failsafe; in some cases (1-pixel segment), lastPixel could be unchanged even though the segment had been drawn. With this change, we instead test directly whether stroke() skipped the segment or not. Task-number: QTBUG-42398 Change-Id: Id751db69a18cd1af4f45070db9d5698aa532d22a Reviewed-by: Allan Sandfeld Jensen <allan.jensen@theqtcompany.com>
2015-03-19 07:46:56 +00:00
void tst_QPainter::drawPolyline_data()
{
QTest::addColumn< QVector<QPointF> >("points");
QTest::newRow("basic") << (QVector<QPointF>() << QPointF(10, 10) << QPointF(20, 10) << QPointF(20, 20) << QPointF(10, 20));
QTest::newRow("clipped") << (QVector<QPointF>() << QPoint(-10, 100) << QPoint(-1, 100) << QPoint(-1, -2) << QPoint(100, -2) << QPoint(100, 40)); // QTBUG-31579
QTest::newRow("shortsegment") << (QVector<QPointF>() << QPoint(20, 100) << QPoint(20, 99) << QPoint(21, 99) << QPoint(21, 104)); // QTBUG-42398
Another fix of cosmetic QPainter::drawPolyline() At the edge of the view, a line segment could end up as not producing any pixels even if not clipped by the floating-point clip routine. Make sure the starting point for the next line is still updated correctly for any significant segment lengths. Change-Id: I381a4efb81ce6006f3da4c67abf279aea79e4663 Reviewed-by: Allan Sandfeld Jensen <allan.jensen@theqtcompany.com>
2015-08-11 12:13:51 +00:00
QTest::newRow("edge") << (QVector<QPointF>() << QPointF(4.5, 121.6) << QPointF(9.4, 150.9) << QPointF(14.2, 184.8) << QPointF(19.1, 130.4));
Fix rasterization errors in aliased cosmetic drawPolyLine If a cosmetic polyline contained a 1-pixel segment, the next segment would be drawn with wrong starting point. The original fix for QTBUG-26156 had some unwanted side effects (QTBUG-31579 and now QTBUG-42398). It tried to skip start-point update if stroke() did not actually draw anything (because the segment was too small). However, to determine that, it tested for a change in lastPixel. But that was not failsafe; in some cases (1-pixel segment), lastPixel could be unchanged even though the segment had been drawn. With this change, we instead test directly whether stroke() skipped the segment or not. Task-number: QTBUG-42398 Change-Id: Id751db69a18cd1af4f45070db9d5698aa532d22a Reviewed-by: Allan Sandfeld Jensen <allan.jensen@theqtcompany.com>
2015-03-19 07:46:56 +00:00
}
void tst_QPainter::drawPolyline()
{
QFETCH(QVector<QPointF>, points);
QImage images[2];
for (int r = 0; r < 2; r++) {
images[r] = QImage(150, 150, QImage::Format_ARGB32);
Another fix of cosmetic QPainter::drawPolyline() At the edge of the view, a line segment could end up as not producing any pixels even if not clipped by the floating-point clip routine. Make sure the starting point for the next line is still updated correctly for any significant segment lengths. Change-Id: I381a4efb81ce6006f3da4c67abf279aea79e4663 Reviewed-by: Allan Sandfeld Jensen <allan.jensen@theqtcompany.com>
2015-08-11 12:13:51 +00:00
images[r].fill(Qt::white);
Fix rasterization errors in aliased cosmetic drawPolyLine If a cosmetic polyline contained a 1-pixel segment, the next segment would be drawn with wrong starting point. The original fix for QTBUG-26156 had some unwanted side effects (QTBUG-31579 and now QTBUG-42398). It tried to skip start-point update if stroke() did not actually draw anything (because the segment was too small). However, to determine that, it tested for a change in lastPixel. But that was not failsafe; in some cases (1-pixel segment), lastPixel could be unchanged even though the segment had been drawn. With this change, we instead test directly whether stroke() skipped the segment or not. Task-number: QTBUG-42398 Change-Id: Id751db69a18cd1af4f45070db9d5698aa532d22a Reviewed-by: Allan Sandfeld Jensen <allan.jensen@theqtcompany.com>
2015-03-19 07:46:56 +00:00
QPainter p(images + r);
QPen pen(Qt::red, 0, Qt::SolidLine, Qt::FlatCap);
p.setPen(pen);
QVERIFY(p.pen().isCosmetic());
if (r) {
for (int i = 0; i < points.count()-1; i++) {
p.drawLine(points.at(i), points.at(i+1));
}
} else {
p.drawPolyline(points);
}
}
QCOMPARE(images[0], images[1]);
}
Fix rounding error in fetchTransformedBilinear To calculate the real count we need to use the actual fixed point increment and can not use the floating point value increment wass based on since it might round differently. Includes auto-test by Gabriel de Dietrich. Task-number: QTBUG-50153 Change-Id: Ia973088f361c90370fa20bac14a4b8f373b5d234 Reviewed-by: Gabriel de Dietrich <gabriel.dedietrich@theqtcompany.com> Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
2016-02-02 13:55:17 +00:00
void tst_QPainter::QTBUG50153_drawImage_assert()
{
QImage::Format formats[] = {
QImage::Format_RGB32, // fetchTransformedBilinearARGB32PM
QImage::Format_ARGB32 // fetchTransformedBilinear
};
for (unsigned i = 0; i < sizeof(formats) / sizeof(formats[0]); i++) {
QImage image(3027, 2999, formats[i]);
QImage backingStore(image.size(), QImage::Format_ARGB32);
QPainter backingStorePainter(&backingStore);
QTransform transform;
transform.scale( 0.999987, 0.999987 );
backingStorePainter.setTransform(transform);
backingStorePainter.setRenderHint(QPainter::SmoothPixmapTransform, true);
backingStorePainter.drawImage(0, 0, image);
// No crash, all fine
}
}
Fix regression in rotated bilinear sampling Fix a mistake introduced recently and revealed by lancelot. Adds an auto-test for rotations to catch similar errors faster in the future. Change-Id: I028a160107d98899e723481b6201ef776f20c721 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2016-07-26 08:09:55 +00:00
void tst_QPainter::rotateImage_data()
{
QTest::addColumn<QImage>("image");
QTest::addColumn<bool>("smooth");
QImage image(128, 128, QImage::Format_RGB32);
for (int y = 0; y < 128; ++y) {
for (int x = 0; x < 128; ++x) {
image.setPixel(x, y, qRgb(x + y, x + y, x + y));
}
}
QTest::newRow("fast") << image << false;
QTest::newRow("smooth") << image << true;
}
void tst_QPainter::rotateImage()
{
QFETCH(QImage, image);
QFETCH(bool, smooth);
QImage dest(184, 184, QImage::Format_ARGB32_Premultiplied);
dest.fill(Qt::transparent);
QPainter painter(&dest);
QTransform transform;
transform.translate(92, 0);
transform.rotate(45);
painter.setTransform(transform);
painter.setRenderHint(QPainter::SmoothPixmapTransform, smooth);
painter.drawImage(0, 0, image);
painter.end();
QRgb lastRow = qRgba(0, 0, 0, 0);
for (int y = 0; y < 184; ++y) {
QRgb row = qRgba(0, 0, 0, 0);
for (int x = 0; x < 184; ++x) {
QRgb pixel = dest.pixel(x, y);
if (qAlpha(pixel) < 255)
continue;
if (qAlpha(row) == 0) {
row = pixel;
} else {
QCOMPARE(qRed(pixel), qGreen(pixel));
QCOMPARE(qGreen(pixel), qBlue(pixel));
QVERIFY(qAbs(qRed(row) - qRed(pixel)) <= 2);
QVERIFY(qAbs(qGreen(row) - qGreen(pixel)) <= 2);
QVERIFY(qAbs(qBlue(row) - qBlue(pixel)) <= 2);
}
}
if (qAlpha(row) && qAlpha(lastRow))
QVERIFY(qGray(lastRow) <= qGray(row));
lastRow = row;
}
}
Fix illegal memory access on simple image rotates Clip the transformed and rounded sourceClip to the source rectangle, so we don't try to rotate pixels outside the source. Task-number: QTBUG-56252 Change-Id: Ib9cb80f9856724118867aea37ead0b02a6c71495 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io> Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2016-10-05 13:45:55 +00:00
void tst_QPainter::QTBUG56252()
{
QImage sourceImage(1770, 1477, QImage::Format_RGB32);
QImage rotatedImage(1478, 1771, QImage::Format_RGB32);
QTransform transformCenter;
transformCenter.translate(739.0, 885.5);
transformCenter.rotate(270.0);
transformCenter.translate(-885.0, -738.5);
QPainter painter;
painter.begin(&rotatedImage);
painter.setTransform(transformCenter);
painter.drawImage(QPoint(0, 0),sourceImage);
painter.end();
// If no crash or illegal memory read, all is fine
}
Fix blending of RGB32 on RGB32 with partial opacity The alpha channel of an RGB32 image was not properly ignored when doing blending with partial opacity. Now the alpha value is properly ignored, which is both more correct and faster. This also makes SSE2 and AVX2 implementations match NEON which was already doing the right thing (though had dead code for doing it wrong). Change-Id: I4613b8d70ed8c2e36ced10baaa7a4a55bd36a940 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2016-11-18 15:33:12 +00:00
void tst_QPainter::blendNullRGB32()
{
quint32 data[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
QImage nullImage((const uchar*)data, 16, 1, QImage::Format_RGB32);
QImage image(16, 1, QImage::Format_RGB32);
image.fill(Qt::white);
QPainter paint(&image);
paint.setCompositionMode(QPainter::CompositionMode_Source);
paint.setOpacity(0.5);
paint.drawImage(0, 0, nullImage);
paint.end();
for (int i=0; i < image.width(); ++i)
QVERIFY(image.pixel(i,0) != 0xffffffff);
}
Fix qdrawhelper function toRGB64 The function was incorrectly handling green and blue color channels causing them to be dropped. This affects drawing non 32-bit images onto 10-bit per color channels formats such as RGB30. Change-Id: I9211e253b1a9da0dada5c418d592a8f531265989 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2016-12-07 12:03:44 +00:00
void tst_QPainter::toRGB64()
{
QImage dst(10, 1, QImage::Format_BGR30);
QImage src(10, 1, QImage::Format_RGB16);
src.fill(Qt::white);
QPainter paint(&dst);
paint.drawImage(0, 0, src);
paint.end();
for (int i=0; i < dst.width(); ++i) {
QVERIFY(dst.pixelColor(i,0) == QColor(Qt::white));
}
}
Fix polygon stroking with cosmetic pen Fix a number of issues that caused polygons to not always be drawn fully connected. Ensures the original lastPixel is set when drawing closed polygons, ensure we don't round away from the original starting point, and add handling of edges that need to be rounded half a pixel sideways to line up with endpoints. Task-number: QTBUG-27053 Change-Id: Ib51ee5623a629996af51a0967096383f04e91e2f Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2017-07-04 15:24:04 +00:00
void tst_QPainter::fillPolygon()
{
QImage image(50, 50, QImage::Format_RGB32);
image.fill(Qt::white);
QPainter painter(&image);
QBrush brush(Qt::black, Qt::SolidPattern);
painter.setBrush(brush);
QPen pen(Qt::red, 0, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
painter.setPen(pen);
const QPoint diamondpoints[5] = {
QPoint(-15, 0),
QPoint(0, -15),
QPoint(15, 0),
QPoint(0, 15),
QPoint(-15, 0)
};
enum { Outside1, Border1, Inside, Border2, Outside2 } state;
for (int i = 0; i < 16 ; i++)
{
for (int j = 0; j < 16 ; j++)
{
image.fill(Qt::white);
painter.resetTransform();
painter.translate(25 + i/16., 25 + j/16.);
painter.drawPolygon(diamondpoints, 5);
for (int x = 0; x < 50; x++) {
state = Outside1;
for (int y = 0; y < 50; y++) {
QRgb c = image.pixel(x, y);
switch (state) {
case Outside1:
if (c == QColor(Qt::red).rgb())
state = Border1;
else
QCOMPARE(c, QColor(Qt::white).rgb());
break;
case Border1:
if (c == QColor(Qt::black).rgb())
state = Inside;
else if (c == QColor(Qt::white).rgb())
state = Outside2;
else
QCOMPARE(c, QColor(Qt::red).rgb());
break;
case Inside:
if (c == QColor(Qt::red).rgb())
state = Border2;
else
QCOMPARE(c, QColor(Qt::black).rgb());
break;
case Border2:
if (c == QColor(Qt::white).rgb())
state = Outside2;
else
QCOMPARE(c, QColor(Qt::red).rgb());
break;
case Outside2:
QCOMPARE(c, QColor(Qt::white).rgb());
}
}
}
for (int y = 0; y < 50; y++) {
state = Outside1;
for (int x = 0; x < 50; x++) {
QRgb c = image.pixel(x, y);
switch (state) {
case Outside1:
if (c == QColor(Qt::red).rgb())
state = Border1;
else
QCOMPARE(c, QColor(Qt::white).rgb());
break;
case Border1:
if (c == QColor(Qt::black).rgb())
state = Inside;
else if (c == QColor(Qt::white).rgb())
state = Outside2;
else
QCOMPARE(c, QColor(Qt::red).rgb());
break;
case Inside:
if (c == QColor(Qt::red).rgb())
state = Border2;
else
QCOMPARE(c, QColor(Qt::black).rgb());
break;
case Border2:
if (c == QColor(Qt::white).rgb())
state = Outside2;
else
QCOMPARE(c, QColor(Qt::red).rgb());
break;
case Outside2:
QCOMPARE(c, QColor(Qt::white).rgb());
}
}
}
}
}
}
Initial import from the monolithic Qt. This is the beginning of revision history for this module. If you want to look at revision history older than this, please refer to the Qt Git wiki for how to use Git history grafting. At the time of writing, this wiki is located here: http://qt.gitorious.org/qt/pages/GitIntroductionWithQt If you have already performed the grafting and you don't see any history beyond this commit, try running "git log" with the "--follow" argument. Branched from the monolithic repo, Qt master branch, at commit 896db169ea224deb96c59ce8af800d019de63f12
2011-04-27 10:05:43 +00:00
QTEST_MAIN(tst_QPainter)
#include "tst_qpainter.moc"
Reference in New Issue Copy Permalink