AuroraMiddleware/qt5base-lts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
6e7ad733a4
qt5base-lts/tests/auto/qwidget/tst_qwidget.cpp
Gabriel de Dietrich d49973f834 Fix infinite recursion when changing geometry on Mac 
Some complex widgets might get a negatively sized rectangle when
calling QWidgetPrivate:setGeometry_sys_helper(), triggering a infinite
recursion. Normalizing the rectangle size before checking for size
change is enough to break this infinite recursion.

Task-number: QTBUG-17333
Change-Id: I4682c3088ea53fb9f28f746c8264f573b5284825
Reviewed-on: http://codereview.qt.nokia.com/156
Reviewed-by: Olivier Goffart <olivier.goffart@nokia.com>
2011-05-26 20:39:30 +02:00

10506 lines
330 KiB
C++
Raw Blame History

/****************************************************************************
**
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** GNU Lesser General Public License Usage
** This file may be used under the terms of the GNU Lesser General Public
** License version 2.1 as published by the Free Software Foundation and
** appearing in the file LICENSE.LGPL included in the packaging of this
** file. Please review the following information to ensure the GNU Lesser
** General Public License version 2.1 requirements will be met:
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU General
** Public License version 3.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of this
** file. Please review the following information to ensure the GNU General
** Public License version 3.0 requirements will be met:
** http://www.gnu.org/copyleft/gpl.html.
**
** Other Usage
** Alternatively, this file may be used in accordance with the terms and
** conditions contained in a signed written agreement between you and Nokia.
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <qboxlayout.h>
#include <qapplication.h>
#include <qbitmap.h>
#include <qdebug.h>
#include <qeventloop.h>
#include <qlabel.h>
#include <qlayout.h>
#include <qlineedit.h>
#include <qlistview.h>
#include <qmessagebox.h>
#include <qpainter.h>
#include <qpoint.h>
#include <qpushbutton.h>
#include <qstyle.h>
#include <qwidget.h>
#include <qwindowsstyle.h>
#include <qinputcontext.h>
#include <qdesktopwidget.h>
#include <private/qwidget_p.h>
#include <private/qapplication_p.h>
#include <qcalendarwidget.h>
#include <qmainwindow.h>
#include <qdockwidget.h>
#include <qtoolbar.h>
#include <QtGui/qpaintengine.h>
#include <private/qbackingstore_p.h>
#include <qmenubar.h>
#include <qtableview.h>
#include <QtGui/QGraphicsView>
#include <QtGui/QGraphicsProxyWidget>
#include "../../shared/util.h"
#ifdef Q_WS_S60
#include <avkon.hrh> // EEikStatusPaneUidTitle
#include <akntitle.h> // CAknTitlePane
#include <akncontext.h> // CAknContextPane
#endif
#ifdef Q_OS_SYMBIAN
#include <eikspane.h> // CEikStatusPane
#include <eikbtgpc.h> // CEikButtonGroupContainer
#include <eikenv.h> // CEikonEnv
#include <eikaufty.h> // MEikAppUiFactory
#include <eikmenub.h> // CEikMenuBar
#endif
#ifdef Q_WS_QWS
# include <qscreen_qws.h>
#endif
// I *MUST* have QtTest afterwards or this test won't work with newer headers
#if defined(Q_WS_MAC)
# include <private/qt_mac_p.h>
#undef verify
#include "tst_qwidget_mac_helpers.h" // Abstract the ObjC stuff out so not everyone must run an ObjC++ compile.
#endif
#include <QtTest/QtTest>
#if defined(Q_WS_WIN)
# include <qt_windows.h>
# if !defined(Q_OS_WINCE)
#define Q_CHECK_PAINTEVENTS \
if (::SwitchDesktop(::GetThreadDesktop(::GetCurrentThreadId())) == 0) \
QSKIP("desktop is not visible, this test would fail", SkipSingle);
# else
# define Q_CHECK_PAINTEVENTS
# endif
#elif defined(Q_WS_X11)
# include <private/qt_x11_p.h>
# include <qx11info_x11.h>
#elif defined(Q_WS_QWS)
# include <qwindowsystem_qws.h>
#endif
#if !defined(Q_WS_WIN)
#define Q_CHECK_PAINTEVENTS
#endif
#if defined(Q_OS_WINCE_WM)
#include <qguifunctions_wince.h>
// taken from qguifunctions_wce.cpp
#define SPI_GETPLATFORMTYPE 257
bool qt_wince_is_platform(const QString &platformString) {
wchar_t tszPlatform[64];
if (SystemParametersInfo(SPI_GETPLATFORMTYPE,
sizeof(tszPlatform)/sizeof(*tszPlatform),tszPlatform,0))
if (0 == _tcsicmp(reinterpret_cast<const wchar_t *> (platformString.utf16()), tszPlatform))
return true;
return false;
}
bool qt_wince_is_smartphone() {
return qt_wince_is_platform(QString::fromLatin1("Smartphone"));
}
#endif
#ifdef Q_WS_MAC
#include <Security/AuthSession.h>
bool macHasAccessToWindowsServer()
{
SecuritySessionId mySession;
SessionAttributeBits sessionInfo;
SessionGetInfo(callerSecuritySession, &mySession, &sessionInfo);
return (sessionInfo & sessionHasGraphicAccess);
}
#endif
#if defined(Bool)
#undef Bool
#endif
//TESTED_CLASS=
//TESTED_FILES=
class tst_QWidget : public QObject
{
Q_OBJECT
public:
tst_QWidget();
virtual ~tst_QWidget();
public slots:
void initTestCase();
void cleanupTestCase();
void init();
void cleanup();
private slots:
void getSetCheck();
void fontPropagation();
void fontPropagation2();
void palettePropagation();
void palettePropagation2();
void enabledPropagation();
void acceptDropsPropagation();
void isEnabledTo();
void visible();
void visible_setWindowOpacity();
void isVisibleTo();
void isHidden();
void fonts();
void mapFromAndTo_data();
void mapFromAndTo();
void focusChainOnHide();
void focusChainOnReparent();
void setTabOrder();
void activation();
void reparent();
void windowState();
void showMaximized();
void showFullScreen();
void showMinimized();
void showMinimizedKeepsFocus();
void icon();
void hideWhenFocusWidgetIsChild();
void normalGeometry();
void setGeometry();
void windowOpacity();
void raise();
void lower();
void stackUnder();
void testContentsPropagation();
void saveRestoreGeometry();
void restoreVersion1Geometry_data();
void restoreVersion1Geometry();
void windowTitle();
void windowModified();
void windowIconText();
void widgetAt();
#ifdef Q_WS_MAC
void retainHIView();
void sheetOpacity();
void setMask();
#endif
void optimizedResizeMove();
void optimizedResize_topLevel();
void resizeEvent();
void task110173();
void testDeletionInEventHandlers();
void childDeletesItsSibling();
void setMinimumSize();
void setMaximumSize();
void setFixedSize();
void ensureCreated();
void winIdChangeEvent();
#ifdef Q_OS_SYMBIAN
void reparentCausesChildWinIdChange();
#else
void persistentWinId();
#endif
void showNativeChild();
void qobject_castInDestroyedSlot();
void showHideEvent_data();
void showHideEvent();
void lostUpdatesOnHide();
void update();
void isOpaque();
#ifndef Q_WS_MAC
void scroll();
#endif
// tests QWidget::setGeometry() on windows only
void setWindowGeometry_data();
void setWindowGeometry();
// tests QWidget::move() and resize() on windows only
void windowMoveResize_data();
void windowMoveResize();
void moveChild_data();
void moveChild();
void showAndMoveChild();
void subtractOpaqueSiblings();
#ifdef Q_WS_WIN
void getDC();
#ifndef Q_OS_WINCE
void setGeometry_win();
#endif
#endif
void setLocale();
void deleteStyle();
void multipleToplevelFocusCheck();
void setFocus();
void setCursor();
void setToolTip();
void testWindowIconChangeEventPropagation();
#ifdef Q_WS_X11
void minAndMaxSizeWithX11BypassWindowManagerHint();
void showHideShow();
void clean_qt_x11_enforce_cursor();
#endif
void compatibilityChildInsertedEvents();
void render();
void renderInvisible();
void renderWithPainter();
void render_task188133();
void render_task211796();
void render_task217815();
void render_windowOpacity();
void render_systemClip();
void render_systemClip2_data();
void render_systemClip2();
void render_systemClip3_data();
void render_systemClip3();
void render_task252837();
void render_worldTransform();
void setContentsMargins();
void moveWindowInShowEvent_data();
void moveWindowInShowEvent();
void repaintWhenChildDeleted();
void hideOpaqueChildWhileHidden();
void updateWhileMinimized();
#if defined(Q_WS_WIN) || defined(Q_WS_X11)
void alienWidgets();
#endif
void adjustSize();
void adjustSize_data();
void updateGeometry();
void updateGeometry_data();
void sendUpdateRequestImmediately();
void painterRedirection();
void doubleRepaint();
#ifndef Q_WS_MAC
void resizeInPaintEvent();
void opaqueChildren();
#endif
void setMaskInResizeEvent();
void moveInResizeEvent();
#if defined(Q_WS_WIN) || defined(Q_WS_X11)
// We don't support immediate repaint right after show on
// other platforms. Must be compatible with Qt 4.3.
void immediateRepaintAfterShow();
void immediateRepaintAfterInvalidateBuffer();
#endif
void effectiveWinId();
void effectiveWinId2();
void customDpi();
void customDpiProperty();
void quitOnCloseAttribute();
void moveRect();
#if defined (Q_WS_WIN)
void gdiPainting();
void paintOnScreenPossible();
#endif
void reparentStaticWidget();
void QTBUG6883_reparentStaticWidget2();
#ifdef Q_WS_QWS
void updateOutsideSurfaceClip();
#endif
void translucentWidget();
void setClearAndResizeMask();
void maskedUpdate();
#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined(Q_WS_QWS) || defined(Q_WS_QPA)
void syntheticEnterLeave();
void taskQTBUG_4055_sendSyntheticEnterLeave();
#endif
void windowFlags();
void initialPosForDontShowOnScreenWidgets();
#ifdef Q_WS_X11
void paintOutsidePaintEvent();
#endif
void updateOnDestroyedSignal();
void toplevelLineEditFocus();
void inputFocus_task257832();
void focusWidget_task254563();
void rectOutsideCoordinatesLimit_task144779();
void setGraphicsEffect();
void destroyBackingStore();
void destroyBackingStoreWhenHidden();
void activateWindow();
void openModal_taskQTBUG_5804();
#ifdef Q_OS_SYMBIAN
void cbaVisibility();
void fullScreenWindowModeTransitions();
void maximizedWindowModeTransitions();
void minimizedWindowModeTransitions();
void normalWindowModeTransitions();
void focusSwitchClosesPopupMenu();
#endif
void focusProxyAndInputMethods();
void scrollWithoutBackingStore();
void taskQTBUG_7532_tabOrderWithFocusProxy();
void movedAndResizedAttributes();
void childAt();
#ifdef Q_WS_MAC
void childAt_unifiedToolBar();
#ifdef QT_MAC_USE_COCOA
void taskQTBUG_11373();
#endif // QT_MAC_USE_COCOA
#endif
void taskQTBUG_17333_ResizeInfiniteRecursion();
void nativeChildFocus();
private:
bool ensureScreenSize(int width, int height);
QWidget *testWidget;
};
bool tst_QWidget::ensureScreenSize(int width, int height)
{
QSize available;
#ifdef Q_WS_QWS
available = QDesktopWidget().availableGeometry().size();
if (available.width() < width || available.height() < height) {
QScreen *screen = QScreen::instance();
if (!screen)
return false;
screen->setMode(width, height, screen->depth());
}
#endif // Q_WS_QWS
available = QDesktopWidget().availableGeometry().size();
return (available.width() >= width && available.height() >= height);
}
class MyInputContext : public QInputContext
{
public:
MyInputContext() : QInputContext() {}
QString identifierName() { return QString("NoName"); }
QString language() { return QString("NoLanguage"); }
void reset() {}
bool isComposing() const { return false; }
};
// Testing get/set functions
void tst_QWidget::getSetCheck()
{
QWidget obj1;
QWidget child1(&obj1);
// QStyle * QWidget::style()
// void QWidget::setStyle(QStyle *)
QWindowsStyle *var1 = new QWindowsStyle;
obj1.setStyle(var1);
QCOMPARE(static_cast<QStyle *>(var1), obj1.style());
obj1.setStyle((QStyle *)0);
QVERIFY(var1 != obj1.style());
QVERIFY(0 != obj1.style()); // style can never be 0 for a widget
// int QWidget::minimumWidth()
// void QWidget::setMinimumWidth(int)
obj1.setMinimumWidth(0);
QCOMPARE(obj1.minimumWidth(), 0);
obj1.setMinimumWidth(INT_MIN);
QCOMPARE(obj1.minimumWidth(), 0); // A widgets width can never be less than 0
obj1.setMinimumWidth(INT_MAX);
#ifndef Q_WS_QWS //QWS doesn't allow toplevels to be bigger than the screen
QCOMPARE(obj1.minimumWidth(), QWIDGETSIZE_MAX); // The largest minimum size should only be as big as the maximium
#endif
child1.setMinimumWidth(0);
QCOMPARE(child1.minimumWidth(), 0);
child1.setMinimumWidth(INT_MIN);
QCOMPARE(child1.minimumWidth(), 0); // A widgets width can never be less than 0
child1.setMinimumWidth(INT_MAX);
QCOMPARE(child1.minimumWidth(), QWIDGETSIZE_MAX); // The largest minimum size should only be as big as the maximium
// int QWidget::minimumHeight()
// void QWidget::setMinimumHeight(int)
obj1.setMinimumHeight(0);
QCOMPARE(obj1.minimumHeight(), 0);
obj1.setMinimumHeight(INT_MIN);
QCOMPARE(obj1.minimumHeight(), 0); // A widgets height can never be less than 0
obj1.setMinimumHeight(INT_MAX);
#ifndef Q_WS_QWS //QWS doesn't allow toplevels to be bigger than the screen
QCOMPARE(obj1.minimumHeight(), QWIDGETSIZE_MAX); // The largest minimum size should only be as big as the maximium
#endif
child1.setMinimumHeight(0);
QCOMPARE(child1.minimumHeight(), 0);
child1.setMinimumHeight(INT_MIN);
QCOMPARE(child1.minimumHeight(), 0); // A widgets height can never be less than 0
child1.setMinimumHeight(INT_MAX);
QCOMPARE(child1.minimumHeight(), QWIDGETSIZE_MAX); // The largest minimum size should only be as big as the maximium
// int QWidget::maximumWidth()
// void QWidget::setMaximumWidth(int)
obj1.setMaximumWidth(0);
QCOMPARE(obj1.maximumWidth(), 0);
obj1.setMaximumWidth(INT_MIN);
QCOMPARE(obj1.maximumWidth(), 0); // A widgets width can never be less than 0
obj1.setMaximumWidth(INT_MAX);
QCOMPARE(obj1.maximumWidth(), QWIDGETSIZE_MAX); // QWIDGETSIZE_MAX is the abs max, not INT_MAX
// int QWidget::maximumHeight()
// void QWidget::setMaximumHeight(int)
obj1.setMaximumHeight(0);
QCOMPARE(obj1.maximumHeight(), 0);
obj1.setMaximumHeight(INT_MIN);
QCOMPARE(obj1.maximumHeight(), 0); // A widgets height can never be less than 0
obj1.setMaximumHeight(INT_MAX);
QCOMPARE(obj1.maximumHeight(), QWIDGETSIZE_MAX); // QWIDGETSIZE_MAX is the abs max, not INT_MAX
// back to normal
obj1.setMinimumWidth(0);
obj1.setMinimumHeight(0);
obj1.setMaximumWidth(QWIDGETSIZE_MAX);
obj1.setMaximumHeight(QWIDGETSIZE_MAX);
// const QPalette & QWidget::palette()
// void QWidget::setPalette(const QPalette &)
QPalette var6;
obj1.setPalette(var6);
QCOMPARE(var6, obj1.palette());
obj1.setPalette(QPalette());
QCOMPARE(QPalette(), obj1.palette());
// const QFont & QWidget::font()
// void QWidget::setFont(const QFont &)
QFont var7;
obj1.setFont(var7);
QCOMPARE(var7, obj1.font());
obj1.setFont(QFont());
QCOMPARE(QFont(), obj1.font());
// qreal QWidget::windowOpacity()
// void QWidget::setWindowOpacity(qreal)
obj1.setWindowOpacity(0.0);
QCOMPARE(0.0, obj1.windowOpacity());
obj1.setWindowOpacity(1.1f);
QCOMPARE(1.0, obj1.windowOpacity()); // 1.0 is the fullest opacity possible
// QWidget * QWidget::focusProxy()
// void QWidget::setFocusProxy(QWidget *)
QWidget *var9 = new QWidget();
obj1.setFocusProxy(var9);
QCOMPARE(var9, obj1.focusProxy());
obj1.setFocusProxy((QWidget *)0);
QCOMPARE((QWidget *)0, obj1.focusProxy());
delete var9;
// const QRect & QWidget::geometry()
// void QWidget::setGeometry(const QRect &)
qApp->processEvents();
QRect var10(10, 10, 100, 100);
obj1.setGeometry(var10);
qApp->processEvents();
qDebug() << obj1.geometry();
QCOMPARE(var10, obj1.geometry());
obj1.setGeometry(QRect(0,0,0,0));
qDebug() << obj1.geometry();
QCOMPARE(QRect(0,0,0,0), obj1.geometry());
// QLayout * QWidget::layout()
// void QWidget::setLayout(QLayout *)
QBoxLayout *var11 = new QBoxLayout(QBoxLayout::LeftToRight);
obj1.setLayout(var11);
QCOMPARE(static_cast<QLayout *>(var11), obj1.layout());
obj1.setLayout((QLayout *)0);
QCOMPARE(static_cast<QLayout *>(var11), obj1.layout()); // You cannot set a 0-pointer layout, that keeps the current
delete var11; // This will remove the layout from the widget
QCOMPARE((QLayout *)0, obj1.layout());
// bool QWidget::acceptDrops()
// void QWidget::setAcceptDrops(bool)
obj1.setAcceptDrops(false);
QCOMPARE(false, obj1.acceptDrops());
obj1.setAcceptDrops(true);
QCOMPARE(true, obj1.acceptDrops());
// QInputContext * QWidget::inputContext()
// void QWidget::setInputContext(QInputContext *)
MyInputContext *var13 = new MyInputContext;
obj1.setInputContext(var13);
QCOMPARE((QInputContext *)0, obj1.inputContext()); // The widget by default doesn't have the WA_InputMethodEnabled attribute
obj1.setAttribute(Qt::WA_InputMethodEnabled);
obj1.setInputContext(var13);
QCOMPARE(static_cast<QInputContext *>(var13), obj1.inputContext());
// QWidget takes ownership, so check parent
QCOMPARE(var13->parent(), static_cast<QObject *>(&obj1));
// Check self assignment
obj1.setInputContext(obj1.inputContext());
QCOMPARE(static_cast<QInputContext *>(var13), obj1.inputContext());
obj1.setInputContext((QInputContext *)0);
QCOMPARE(qApp->inputContext(), obj1.inputContext());
QVERIFY(qApp->inputContext() != var13);
// bool QWidget::autoFillBackground()
// void QWidget::setAutoFillBackground(bool)
obj1.setAutoFillBackground(false);
QCOMPARE(false, obj1.autoFillBackground());
obj1.setAutoFillBackground(true);
QCOMPARE(true, obj1.autoFillBackground());
delete var1;
#if defined (Q_WS_WIN) && !defined(Q_OS_WINCE)
obj1.setWindowFlags(Qt::FramelessWindowHint | Qt::WindowSystemMenuHint);
HWND handle = obj1.winId();
long flags = GetWindowLong(handle, GWL_STYLE);
QVERIFY(flags & WS_POPUP);
#endif
}
tst_QWidget::tst_QWidget()
{
QFont font;
font.setBold(true);
font.setPointSize(42);
qApp->setFont(font, "QPropagationTestWidget");
QPalette palette;
palette.setColor(QPalette::ToolTipBase, QColor(12, 13, 14));
palette.setColor(QPalette::Text, QColor(21, 22, 23));
qApp->setPalette(palette, "QPropagationTestWidget");
testWidget = 0;
}
tst_QWidget::~tst_QWidget()
{
}
class BezierViewer : public QWidget {
public:
BezierViewer( QWidget* parent=0, const char* name=0 );
void paintEvent( QPaintEvent* );
void setPoints( const QPolygonF& poly );
private:
QPolygonF points;
};
void tst_QWidget::initTestCase()
{
#ifdef Q_OS_WINCE //disable magic for WindowsCE
qApp->setAutoMaximizeThreshold(-1);
#endif
// Create the test class
testWidget = new BezierViewer( 0, "testObject");
testWidget->resize(200,200);
testWidget->show();
QTest::qWaitForWindowShown(testWidget);
QTest::qWait(50);
}
void tst_QWidget::cleanupTestCase()
{
delete testWidget;
testWidget = 0;
}
void tst_QWidget::init()
{
// TODO: Add initialization code here.
// This will be executed immediately before each test is run.
testWidget->setFont(QFont());
testWidget->setPalette(QPalette());
}
void tst_QWidget::cleanup()
{
}
// Helper class...
BezierViewer::BezierViewer( QWidget* parent, const char* name )
: QWidget( parent )
{
setObjectName(name);
QPalette pal;
pal.setColor(backgroundRole(), Qt::white);
setPalette(pal);
}
void BezierViewer::setPoints( const QPolygonF& a )
{
points = a;
}
#include "private/qbezier_p.h"
void BezierViewer::paintEvent( QPaintEvent* )
{
if ( points.size() != 4 ) {
#if defined(QT_CHECK_RANGE)
qWarning( "QPolygon::bezier: The array must have 4 control points" );
#endif
return;
}
/* Calculate Bezier curve */
QPolygonF bezier = QBezier::fromPoints(points.at(0),points.at(1),points.at(2),points.at(3)).toPolygon();
QPainter painter( this );
/* Calculate scale to fit in window */
QRectF br = bezier.boundingRect() | points.boundingRect();
QRectF pr = rect();
int scl = qMax( qMin(pr.width()/br.width(), pr.height()/br.height()), qreal(1.) );
int border = scl-1;
/* Scale Bezier curve vertices */
for ( QPolygonF::Iterator it = bezier.begin(); it != bezier.end(); ++it ) {
it->setX( (it->x()-br.x()) * scl + border );
it->setY( (it->y()-br.y()) * scl + border );
}
/* Draw grid */
painter.setPen( Qt::lightGray );
int i;
for ( i = border; i <= pr.width(); i += scl ) {
painter.drawLine( i, 0, i, pr.height() );
}
for ( int j = border; j <= pr.height(); j += scl ) {
painter.drawLine( 0, j, pr.width(), j );
}
/* Write number of vertices */
painter.setPen( Qt::red );
painter.setFont( QFont("Helvetica", 14, QFont::DemiBold, TRUE ) );
QString caption;
caption.setNum( bezier.size() );
caption += QString::fromLatin1( " vertices" );
painter.drawText( 10, pr.height()-10, caption );
/* Draw Bezier curve */
painter.setPen( Qt::black );
painter.drawPolyline( bezier );
/* Scale and draw control points */
painter.setPen( Qt::darkGreen );
for ( QPolygonF::Iterator p1 = points.begin(); p1 != points.end(); ++p1 ) {
int x = (p1->x()-br.x()) * scl + border;
int y = (p1->y()-br.y()) * scl + border;
painter.drawLine( x-4, y-4, x+4, y+4 );
painter.drawLine( x+4, y-4, x-4, y+4 );
}
/* Draw vertices */
painter.setPen( Qt::red );
painter.setBrush( Qt::red );
for ( QPolygonF::Iterator p2 = bezier.begin(); p2 != bezier.end(); ++p2 )
painter.drawEllipse( p2->x()-1, p2->y()-1, 3, 3 );
}
void tst_QWidget::fontPropagation()
{
QFont font = testWidget->font();
QWidget* childWidget = new QWidget( testWidget );
childWidget->show();
QCOMPARE( font, childWidget->font() );
font.setBold( TRUE );
testWidget->setFont( font );
QCOMPARE( font, testWidget->font() );
QCOMPARE( font, childWidget->font() );
QFont newFont = font;
newFont.setItalic( TRUE );
childWidget->setFont( newFont );
QWidget* grandChildWidget = new QWidget( childWidget );
QCOMPARE( font, testWidget->font() );
QCOMPARE( newFont, grandChildWidget->font() );
font.setUnderline( TRUE );
testWidget->setFont( font );
// the child and grand child should now have merged bold and
// underline
newFont.setUnderline( TRUE );
QCOMPARE( newFont, childWidget->font() );
QCOMPARE( newFont, grandChildWidget->font() );
// make sure font propagation continues working after reparenting
font = testWidget->font();
font.setPointSize(font.pointSize() + 2);
testWidget->setFont(font);
QWidget *one = new QWidget(testWidget);
QWidget *two = new QWidget(one);
QWidget *three = new QWidget(two);
QWidget *four = new QWidget(two);
four->setParent(three);
four->move(QPoint(0,0));
font.setPointSize(font.pointSize() + 2);
testWidget->setFont(font);
QCOMPARE(testWidget->font(), one->font());
QCOMPARE(one->font(), two->font());
QCOMPARE(two->font(), three->font());
QCOMPARE(three->font(), four->font());
QVERIFY(testWidget->testAttribute(Qt::WA_SetFont));
QVERIFY(! one->testAttribute(Qt::WA_SetFont));
QVERIFY(! two->testAttribute(Qt::WA_SetFont));
QVERIFY(! three->testAttribute(Qt::WA_SetFont));
QVERIFY(! four->testAttribute(Qt::WA_SetFont));
font.setPointSize(font.pointSize() + 2);
one->setFont(font);
QCOMPARE(one->font(), two->font());
QCOMPARE(two->font(), three->font());
QCOMPARE(three->font(), four->font());
QVERIFY(one->testAttribute(Qt::WA_SetFont));
QVERIFY(! two->testAttribute(Qt::WA_SetFont));
QVERIFY(! three->testAttribute(Qt::WA_SetFont));
QVERIFY(! four->testAttribute(Qt::WA_SetFont));
font.setPointSize(font.pointSize() + 2);
two->setFont(font);
QCOMPARE(two->font(), three->font());
QCOMPARE(three->font(), four->font());
QVERIFY(two->testAttribute(Qt::WA_SetFont));
QVERIFY(! three->testAttribute(Qt::WA_SetFont));
QVERIFY(! four->testAttribute(Qt::WA_SetFont));
font.setPointSize(font.pointSize() + 2);
three->setFont(font);
QCOMPARE(three->font(), four->font());
QVERIFY(three->testAttribute(Qt::WA_SetFont));
QVERIFY(! four->testAttribute(Qt::WA_SetFont));
font.setPointSize(font.pointSize() + 2);
four->setFont(font);
QVERIFY(four->testAttribute(Qt::WA_SetFont));
}
class QPropagationTestWidget : public QWidget
{
Q_OBJECT
public:
QPropagationTestWidget(QWidget *parent = 0)
: QWidget(parent)
{ }
};
void tst_QWidget::fontPropagation2()
{
// ! Note, the code below is executed in tst_QWidget's constructor.
// QFont font;
// font.setBold(true);
// font.setPointSize(42);
// qApp->setFont(font, "QPropagationTestWidget");
QWidget *root = new QWidget;
QWidget *child0 = new QWidget(root);
QWidget *child1 = new QWidget(child0);
QWidget *child2 = new QPropagationTestWidget(child1);
QWidget *child3 = new QWidget(child2);
QWidget *child4 = new QWidget(child3);
QWidget *child5 = new QWidget(child4);
root->show();
// Check that only the application fonts apply.
QCOMPARE(root->font(), QApplication::font());
QCOMPARE(child0->font(), QApplication::font());
QCOMPARE(child1->font(), QApplication::font());
QCOMPARE(child2->font().pointSize(), 42);
QVERIFY(child2->font().bold());
QCOMPARE(child3->font().pointSize(), 42);
QVERIFY(child3->font().bold());
QCOMPARE(child4->font().pointSize(), 42);
QVERIFY(child4->font().bold());
QCOMPARE(child5->font().pointSize(), 42);
QVERIFY(child5->font().bold());
// Set child0's font size to 15, and remove bold on child4.
QFont font;
font.setPointSize(15);
child0->setFont(font);
QFont unboldFont;
unboldFont.setBold(false);
child4->setFont(unboldFont);
// Check that the above settings propagate correctly.
QCOMPARE(root->font(), QApplication::font());
QCOMPARE(child0->font().pointSize(), 15);
QVERIFY(!child0->font().bold());
QCOMPARE(child1->font().pointSize(), 15);
QVERIFY(!child1->font().bold());
QCOMPARE(child2->font().pointSize(), 15);
QVERIFY(child2->font().bold());
QCOMPARE(child3->font().pointSize(), 15);
QVERIFY(child3->font().bold());
QCOMPARE(child4->font().pointSize(), 15);
QVERIFY(!child4->font().bold());
QCOMPARE(child5->font().pointSize(), 15);
QVERIFY(!child5->font().bold());
// Replace the app font for child2. Italic should propagate
// but the size should still be ignored. The previous bold
// setting is gone.
QFont italicSizeFont;
italicSizeFont.setItalic(true);
italicSizeFont.setPointSize(33);
qApp->setFont(italicSizeFont, "QPropagationTestWidget");
// Check that this propagates correctly.
QCOMPARE(root->font(), QApplication::font());
QCOMPARE(child0->font().pointSize(), 15);
QVERIFY(!child0->font().bold());
QVERIFY(!child0->font().italic());
QCOMPARE(child1->font().pointSize(), 15);
QVERIFY(!child1->font().bold());
QVERIFY(!child1->font().italic());
QCOMPARE(child2->font().pointSize(), 15);
QVERIFY(!child2->font().bold());
QVERIFY(child2->font().italic());
QCOMPARE(child3->font().pointSize(), 15);
QVERIFY(!child3->font().bold());
QVERIFY(child3->font().italic());
QCOMPARE(child4->font().pointSize(), 15);
QVERIFY(!child4->font().bold());
QVERIFY(child4->font().italic());
QCOMPARE(child5->font().pointSize(), 15);
QVERIFY(!child5->font().bold());
QVERIFY(child5->font().italic());
}
void tst_QWidget::palettePropagation()
{
QPalette palette = testWidget->palette();
QWidget* childWidget = new QWidget( testWidget );
childWidget->show();
QCOMPARE( palette, childWidget->palette() );
palette.setColor( QPalette::Base, Qt::red );
testWidget->setPalette( palette );
QCOMPARE( palette, testWidget->palette() );
QCOMPARE( palette, childWidget->palette() );
QPalette newPalette = palette;
newPalette.setColor( QPalette::Highlight, Qt::green );
childWidget->setPalette( newPalette );
QWidget* grandChildWidget = new QWidget( childWidget );
QCOMPARE( palette, testWidget->palette() );
QCOMPARE( newPalette, grandChildWidget->palette() );
palette.setColor( QPalette::Text, Qt::blue );
testWidget->setPalette( palette );
// the child and grand child should now have merged green
// highlight and blue text
newPalette.setColor( QPalette::Text, Qt::blue);
QCOMPARE( newPalette, childWidget->palette() );
QCOMPARE( newPalette, grandChildWidget->palette() );
}
void tst_QWidget::palettePropagation2()
{
// ! Note, the code below is executed in tst_QWidget's constructor.
// QPalette palette;
// font.setColor(QPalette::ToolTipBase, QColor(12, 13, 14));
// font.setColor(QPalette::Text, QColor(21, 22, 23));
// qApp->setPalette(palette, "QPropagationTestWidget");
QWidget *root = new QWidget;
QWidget *child0 = new QWidget(root);
QWidget *child1 = new QWidget(child0);
QWidget *child2 = new QPropagationTestWidget(child1);
QWidget *child3 = new QWidget(child2);
QWidget *child4 = new QWidget(child3);
QWidget *child5 = new QWidget(child4);
root->show();
QTest::qWait(100);
// These colors are unlikely to be imposed on the default palette of
// QWidget ;-).
QColor sysPalText(21, 22, 23);
QColor sysPalToolTipBase(12, 13, 14);
QColor overridePalText(42, 43, 44);
QColor overridePalToolTipBase(45, 46, 47);
QColor sysPalButton(99, 98, 97);
// Check that only the application fonts apply.
QPalette appPal = QApplication::palette();
QCOMPARE(root->palette(), appPal);
QCOMPARE(child0->palette(), appPal);
QCOMPARE(child1->palette(), appPal);
QCOMPARE(child2->palette().color(QPalette::ToolTipBase), sysPalToolTipBase);
QCOMPARE(child2->palette().color(QPalette::Text), sysPalText);
QCOMPARE(child2->palette().color(QPalette::ToolTipText), appPal.color(QPalette::ToolTipText));
QCOMPARE(child3->palette().color(QPalette::ToolTipBase), sysPalToolTipBase);
QCOMPARE(child3->palette().color(QPalette::Text), sysPalText);
QCOMPARE(child3->palette().color(QPalette::ToolTipText), appPal.color(QPalette::ToolTipText));
QCOMPARE(child4->palette().color(QPalette::ToolTipBase), sysPalToolTipBase);
QCOMPARE(child4->palette().color(QPalette::Text), sysPalText);
QCOMPARE(child4->palette().color(QPalette::ToolTipText), appPal.color(QPalette::ToolTipText));
QCOMPARE(child5->palette().color(QPalette::ToolTipBase), sysPalToolTipBase);
QCOMPARE(child5->palette().color(QPalette::Text), sysPalText);
QCOMPARE(child5->palette().color(QPalette::ToolTipText), appPal.color(QPalette::ToolTipText));
// Set child0's Text, and set ToolTipBase on child4.
QPalette textPalette;
textPalette.setColor(QPalette::Text, overridePalText);
child0->setPalette(textPalette);
QPalette toolTipPalette;
toolTipPalette.setColor(QPalette::ToolTipBase, overridePalToolTipBase);
child4->setPalette(toolTipPalette);
// Check that the above settings propagate correctly.
QCOMPARE(root->palette(), appPal);
QCOMPARE(child0->palette().color(QPalette::Text), overridePalText);
QCOMPARE(child0->palette().color(QPalette::ToolTipBase), appPal.color(QPalette::ToolTipBase));
QCOMPARE(child0->palette().color(QPalette::ToolTipText), appPal.color(QPalette::ToolTipText));
QCOMPARE(child1->palette().color(QPalette::Text), overridePalText);
QCOMPARE(child1->palette().color(QPalette::ToolTipBase), appPal.color(QPalette::ToolTipBase));
QCOMPARE(child1->palette().color(QPalette::ToolTipText), appPal.color(QPalette::ToolTipText));
QCOMPARE(child2->palette().color(QPalette::Text), overridePalText);
QCOMPARE(child2->palette().color(QPalette::ToolTipBase), sysPalToolTipBase);
QCOMPARE(child2->palette().color(QPalette::ToolTipText), appPal.color(QPalette::ToolTipText));
QCOMPARE(child3->palette().color(QPalette::Text), overridePalText);
QCOMPARE(child3->palette().color(QPalette::ToolTipBase), sysPalToolTipBase);
QCOMPARE(child3->palette().color(QPalette::ToolTipText), appPal.color(QPalette::ToolTipText));
QCOMPARE(child4->palette().color(QPalette::Text), overridePalText);
QCOMPARE(child4->palette().color(QPalette::ToolTipBase), overridePalToolTipBase);
QCOMPARE(child4->palette().color(QPalette::ToolTipText), appPal.color(QPalette::ToolTipText));
QCOMPARE(child5->palette().color(QPalette::Text), overridePalText);
QCOMPARE(child5->palette().color(QPalette::ToolTipBase), overridePalToolTipBase);
QCOMPARE(child5->palette().color(QPalette::ToolTipText), appPal.color(QPalette::ToolTipText));
// Replace the app palette for child2. Button should propagate but Text
// should still be ignored. The previous ToolTipBase setting is gone.
QPalette buttonPalette;
buttonPalette.setColor(QPalette::ToolTipText, sysPalButton);
qApp->setPalette(buttonPalette, "QPropagationTestWidget");
// Check that the above settings propagate correctly.
QCOMPARE(root->palette(), appPal);
QCOMPARE(child0->palette().color(QPalette::Text), overridePalText);
QCOMPARE(child0->palette().color(QPalette::ToolTipBase), appPal.color(QPalette::ToolTipBase));
QCOMPARE(child0->palette().color(QPalette::ToolTipText), appPal.color(QPalette::ToolTipText));
QCOMPARE(child1->palette().color(QPalette::Text), overridePalText);
QCOMPARE(child1->palette().color(QPalette::ToolTipBase), appPal.color(QPalette::ToolTipBase));
QCOMPARE(child1->palette().color(QPalette::ToolTipText), appPal.color(QPalette::ToolTipText));
QCOMPARE(child2->palette().color(QPalette::Text), overridePalText);
QCOMPARE(child2->palette().color(QPalette::ToolTipBase), appPal.color(QPalette::ToolTipBase));
QCOMPARE(child2->palette().color(QPalette::ToolTipText), sysPalButton);
QCOMPARE(child3->palette().color(QPalette::Text), overridePalText);
QCOMPARE(child3->palette().color(QPalette::ToolTipBase), appPal.color(QPalette::ToolTipBase));
QCOMPARE(child3->palette().color(QPalette::ToolTipText), sysPalButton);
QCOMPARE(child4->palette().color(QPalette::Text), overridePalText);
QCOMPARE(child4->palette().color(QPalette::ToolTipBase), overridePalToolTipBase);
QCOMPARE(child4->palette().color(QPalette::ToolTipText), sysPalButton);
QCOMPARE(child5->palette().color(QPalette::Text), overridePalText);
QCOMPARE(child5->palette().color(QPalette::ToolTipBase), overridePalToolTipBase);
QCOMPARE(child5->palette().color(QPalette::ToolTipText), sysPalButton);
}
void tst_QWidget::enabledPropagation()
{
QWidget* childWidget = new QWidget( testWidget );
childWidget->show();
QVERIFY( testWidget->isEnabled() );
QVERIFY( childWidget->isEnabled() );
testWidget->setEnabled( FALSE );
QVERIFY( !testWidget->isEnabled() );
QVERIFY( !childWidget->isEnabled() );
testWidget->setDisabled( FALSE );
QVERIFY( testWidget->isEnabled() );
QVERIFY( childWidget->isEnabled() );
QWidget* grandChildWidget = new QWidget( childWidget );
QVERIFY( grandChildWidget->isEnabled() );
testWidget->setDisabled( TRUE );
QVERIFY( !testWidget->isEnabled() );
QVERIFY( !childWidget->isEnabled() );
QVERIFY( !grandChildWidget->isEnabled() );
grandChildWidget->setEnabled( FALSE );
testWidget->setEnabled( TRUE );
QVERIFY( testWidget->isEnabled() );
QVERIFY( childWidget->isEnabled() );
QVERIFY( !grandChildWidget->isEnabled() );
grandChildWidget->setEnabled( TRUE );
testWidget->setEnabled( FALSE );
childWidget->setDisabled( TRUE );
testWidget->setEnabled( TRUE );
QVERIFY( testWidget->isEnabled() );
QVERIFY( !childWidget->isEnabled() );
QVERIFY( !grandChildWidget->isEnabled() );
}
void tst_QWidget::acceptDropsPropagation()
{
#ifdef QT_NO_DRAGANDDROP
QSKIP("Drag'n drop disabled in this build", SkipAll);
#else
QWidget *childWidget = new QWidget(testWidget);
childWidget->show();
QVERIFY(!testWidget->acceptDrops());
QVERIFY(!childWidget->acceptDrops());
testWidget->setAcceptDrops(true);
QVERIFY(testWidget->acceptDrops());
QVERIFY(!childWidget->acceptDrops());
QVERIFY(childWidget->testAttribute(Qt::WA_DropSiteRegistered));
testWidget->setAcceptDrops(false);
QVERIFY(!testWidget->acceptDrops());
QVERIFY(!childWidget->acceptDrops());
QVERIFY(!childWidget->testAttribute(Qt::WA_DropSiteRegistered));
QWidget *grandChildWidget = new QWidget(childWidget);
QVERIFY(!grandChildWidget->acceptDrops());
QVERIFY(!grandChildWidget->testAttribute(Qt::WA_DropSiteRegistered));
testWidget->setAcceptDrops(true);
QVERIFY(testWidget->acceptDrops());
QVERIFY(!childWidget->acceptDrops());
QVERIFY(childWidget->testAttribute(Qt::WA_DropSiteRegistered));
QVERIFY(!grandChildWidget->acceptDrops());
QVERIFY(grandChildWidget->testAttribute(Qt::WA_DropSiteRegistered));
grandChildWidget->setAcceptDrops(true);
testWidget->setAcceptDrops(false);
QVERIFY(!testWidget->acceptDrops());
QVERIFY(!childWidget->acceptDrops());
QVERIFY(grandChildWidget->acceptDrops());
QVERIFY(grandChildWidget->testAttribute(Qt::WA_DropSiteRegistered));
grandChildWidget->setAcceptDrops(false);
QVERIFY(!grandChildWidget->testAttribute(Qt::WA_DropSiteRegistered));
testWidget->setAcceptDrops(true);
childWidget->setAcceptDrops(true);
testWidget->setAcceptDrops(false);
QVERIFY(!testWidget->acceptDrops());
QVERIFY(childWidget->acceptDrops());
QVERIFY(!grandChildWidget->acceptDrops());
QVERIFY(grandChildWidget->testAttribute(Qt::WA_DropSiteRegistered));
#endif
}
void tst_QWidget::isEnabledTo()
{
QWidget* childWidget = new QWidget( testWidget );
QWidget* grandChildWidget = new QWidget( childWidget );
QVERIFY( childWidget->isEnabledTo( testWidget ) );
QVERIFY( grandChildWidget->isEnabledTo( testWidget ) );
childWidget->setEnabled( FALSE );
QVERIFY( !childWidget->isEnabledTo( testWidget ) );
QVERIFY( grandChildWidget->isEnabledTo( childWidget ) );
QVERIFY( !grandChildWidget->isEnabledTo( testWidget ) );
}
void tst_QWidget::visible()
{
// Ensure that the testWidget is hidden for this test at the
// start
testWidget->hide();
QVERIFY( !testWidget->isVisible() );
QWidget* childWidget = new QWidget( testWidget );
QVERIFY( !childWidget->isVisible() );
testWidget->show();
QVERIFY( testWidget->isVisible() );
QVERIFY( childWidget->isVisible() );
QWidget* grandChildWidget = new QWidget( childWidget );
QVERIFY( !grandChildWidget->isVisible() );
grandChildWidget->show();
QVERIFY( grandChildWidget->isVisible() );
grandChildWidget->hide();
testWidget->hide();
testWidget->show();
QVERIFY( !grandChildWidget->isVisible() );
QVERIFY( testWidget->isVisible() );
QVERIFY( childWidget->isVisible() );
grandChildWidget->show();
childWidget->hide();
testWidget->hide();
testWidget->show();
QVERIFY( testWidget->isVisible() );
QVERIFY( !childWidget->isVisible() );
QVERIFY( !grandChildWidget->isVisible() );
grandChildWidget->show();
QVERIFY( !grandChildWidget->isVisible() );
}
void tst_QWidget::setLocale()
{
QWidget w;
QCOMPARE(w.locale(), QLocale());
w.setLocale(QLocale::Italian);
QCOMPARE(w.locale(), QLocale(QLocale::Italian));
QWidget child1(&w);
QCOMPARE(child1.locale(), QLocale(QLocale::Italian));
w.unsetLocale();
QCOMPARE(w.locale(), QLocale());
QCOMPARE(child1.locale(), QLocale());
w.setLocale(QLocale::French);
QCOMPARE(w.locale(), QLocale(QLocale::French));
QCOMPARE(child1.locale(), QLocale(QLocale::French));
child1.setLocale(QLocale::Italian);
QCOMPARE(w.locale(), QLocale(QLocale::French));
QCOMPARE(child1.locale(), QLocale(QLocale::Italian));
child1.unsetLocale();
QCOMPARE(w.locale(), QLocale(QLocale::French));
QCOMPARE(child1.locale(), QLocale(QLocale::French));
QWidget child2;
QCOMPARE(child2.locale(), QLocale());
child2.setParent(&w);
QCOMPARE(child2.locale(), QLocale(QLocale::French));
}
void tst_QWidget::visible_setWindowOpacity()
{
testWidget->hide();
QVERIFY( !testWidget->isVisible() );
testWidget->setWindowOpacity(0.5);
#ifdef Q_OS_WIN
QVERIFY(::IsWindowVisible(testWidget->winId()) == FALSE);
#endif
testWidget->setWindowOpacity(1.0);
}
void tst_QWidget::isVisibleTo()
{
// Ensure that the testWidget is hidden for this test at the
// start
testWidget->hide();
QWidget* childWidget = new QWidget( testWidget );
QVERIFY( childWidget->isVisibleTo( testWidget ) );
childWidget->hide();
QVERIFY( !childWidget->isVisibleTo( testWidget ) );
QWidget* grandChildWidget = new QWidget( childWidget );
QVERIFY( !grandChildWidget->isVisibleTo( testWidget ) );
QVERIFY( grandChildWidget->isVisibleTo( childWidget ) );
testWidget->show();
childWidget->show();
QVERIFY( childWidget->isVisibleTo( testWidget ) );
grandChildWidget->hide();
QVERIFY( !grandChildWidget->isVisibleTo( childWidget ) );
QVERIFY( !grandChildWidget->isVisibleTo( testWidget ) );
}
void tst_QWidget::isHidden()
{
// Ensure that the testWidget is hidden for this test at the
// start
testWidget->hide();
QVERIFY( testWidget->isHidden() );
QWidget* childWidget = new QWidget( testWidget );
QVERIFY( !childWidget->isHidden() );
testWidget->show();
QVERIFY( !testWidget->isHidden() );
QVERIFY( !childWidget->isHidden() );
QWidget* grandChildWidget = new QWidget( childWidget );
QVERIFY( grandChildWidget->isHidden() );
grandChildWidget->show();
QVERIFY( !grandChildWidget->isHidden() );
grandChildWidget->hide();
testWidget->hide();
testWidget->show();
QVERIFY( grandChildWidget->isHidden() );
QVERIFY( !testWidget->isHidden() );
QVERIFY( !childWidget->isHidden() );
grandChildWidget->show();
childWidget->hide();
testWidget->hide();
testWidget->show();
QVERIFY( !testWidget->isHidden() );
QVERIFY( childWidget->isHidden() );
QVERIFY( !grandChildWidget->isHidden() );
grandChildWidget->show();
QVERIFY( !grandChildWidget->isHidden() );
}
void tst_QWidget::fonts()
{
// Tests setFont(), ownFont() and unsetFont()
QWidget* cleanTestWidget = new QWidget( testWidget );
QFont originalFont = cleanTestWidget->font();
QVERIFY( !cleanTestWidget->testAttribute(Qt::WA_SetFont) );
cleanTestWidget->setFont(QFont());
QVERIFY( !cleanTestWidget->testAttribute(Qt::WA_SetFont) );
QFont newFont( "times", 18 );
cleanTestWidget->setFont( newFont );
newFont = newFont.resolve( testWidget->font() );
QVERIFY( cleanTestWidget->testAttribute(Qt::WA_SetFont) );
QVERIFY( cleanTestWidget->font() == newFont );
cleanTestWidget->setFont(QFont());
QVERIFY( !cleanTestWidget->testAttribute(Qt::WA_SetFont) );
QVERIFY( cleanTestWidget->font() == originalFont );
}
void tst_QWidget::mapFromAndTo_data()
{
QTest::addColumn<bool>("windowHidden");
QTest::addColumn<bool>("subWindow1Hidden");
QTest::addColumn<bool>("subWindow2Hidden");
QTest::addColumn<bool>("subSubWindowHidden");
QTest::addColumn<bool>("windowMinimized");
QTest::addColumn<bool>("subWindow1Minimized");
QTest::newRow("window 1 sub1 1 sub2 1 subsub 1") << false << false << false << false << false << false;
QTest::newRow("window 0 sub1 1 sub2 1 subsub 1") << true << false << false << false << false << false;
QTest::newRow("window 1 sub1 0 sub2 1 subsub 1") << false << true << false << false << false << false;
QTest::newRow("window 0 sub1 0 sub2 1 subsub 1") << true << true << false << false << false << false;
QTest::newRow("window 1 sub1 1 sub2 0 subsub 1") << false << false << true << false << false << false;
QTest::newRow("window 0 sub1 1 sub2 0 subsub 1") << true << false << true << false << false << false;
QTest::newRow("window 1 sub1 0 sub2 0 subsub 1") << false << true << true << false << false << false;
QTest::newRow("window 0 sub1 0 sub2 0 subsub 1") << true << true << true << false << false << false;
QTest::newRow("window 1 sub1 1 sub2 1 subsub 0") << false << false << false << true << false << false;
QTest::newRow("window 0 sub1 1 sub2 1 subsub 0") << true << false << false << true << false << false;
QTest::newRow("window 1 sub1 0 sub2 1 subsub 0") << false << true << false << true << false << false;
QTest::newRow("window 0 sub1 0 sub2 1 subsub 0") << true << true << false << true << false << false;
QTest::newRow("window 1 sub1 1 sub2 0 subsub 0") << false << false << true << true << false << false;
QTest::newRow("window 0 sub1 1 sub2 0 subsub 0") << true << false << true << true << false << false;
QTest::newRow("window 1 sub1 0 sub2 0 subsub 0") << false << true << true << true << false << false;
QTest::newRow("window 0 sub1 0 sub2 0 subsub 0") << true << true << true << true << false << false;
QTest::newRow("window 1 sub1 1 sub2 1 subsub 1 windowMinimized") << false << false << false << false << true << false;
QTest::newRow("window 0 sub1 1 sub2 1 subsub 1 windowMinimized") << true << false << false << false << true << false;
QTest::newRow("window 1 sub1 0 sub2 1 subsub 1 windowMinimized") << false << true << false << false << true << false;
QTest::newRow("window 0 sub1 0 sub2 1 subsub 1 windowMinimized") << true << true << false << false << true << false;
QTest::newRow("window 1 sub1 1 sub2 0 subsub 1 windowMinimized") << false << false << true << false << true << false;
QTest::newRow("window 0 sub1 1 sub2 0 subsub 1 windowMinimized") << true << false << true << false << true << false;
QTest::newRow("window 1 sub1 0 sub2 0 subsub 1 windowMinimized") << false << true << true << false << true << false;
QTest::newRow("window 0 sub1 0 sub2 0 subsub 1 windowMinimized") << true << true << true << false << true << false;
QTest::newRow("window 1 sub1 1 sub2 1 subsub 0 windowMinimized") << false << false << false << true << true << false;
QTest::newRow("window 0 sub1 1 sub2 1 subsub 0 windowMinimized") << true << false << false << true << true << false;
QTest::newRow("window 1 sub1 0 sub2 1 subsub 0 windowMinimized") << false << true << false << true << true << false;
QTest::newRow("window 0 sub1 0 sub2 1 subsub 0 windowMinimized") << true << true << false << true << true << false;
QTest::newRow("window 1 sub1 1 sub2 0 subsub 0 windowMinimized") << false << false << true << true << true << false;
QTest::newRow("window 0 sub1 1 sub2 0 subsub 0 windowMinimized") << true << false << true << true << true << false;
QTest::newRow("window 1 sub1 0 sub2 0 subsub 0 windowMinimized") << false << true << true << true << true << false;
QTest::newRow("window 0 sub1 0 sub2 0 subsub 0 windowMinimized") << true << true << true << true << true << false;
QTest::newRow("window 1 sub1 1 sub2 1 subsub 1 subWindow1Minimized") << false << false << false << false << false << true;
QTest::newRow("window 0 sub1 1 sub2 1 subsub 1 subWindow1Minimized") << true << false << false << false << false << true;
QTest::newRow("window 1 sub1 0 sub2 1 subsub 1 subWindow1Minimized") << false << true << false << false << false << true;
QTest::newRow("window 0 sub1 0 sub2 1 subsub 1 subWindow1Minimized") << true << true << false << false << false << true;
QTest::newRow("window 1 sub1 1 sub2 0 subsub 1 subWindow1Minimized") << false << false << true << false << false << true;
QTest::newRow("window 0 sub1 1 sub2 0 subsub 1 subWindow1Minimized") << true << false << true << false << false << true;
QTest::newRow("window 1 sub1 0 sub2 0 subsub 1 subWindow1Minimized") << false << true << true << false << false << true;
QTest::newRow("window 0 sub1 0 sub2 0 subsub 1 subWindow1Minimized") << true << true << true << false << false << true;
QTest::newRow("window 1 sub1 1 sub2 1 subsub 0 subWindow1Minimized") << false << false << false << true << false << true;
QTest::newRow("window 0 sub1 1 sub2 1 subsub 0 subWindow1Minimized") << true << false << false << true << false << true;
QTest::newRow("window 1 sub1 0 sub2 1 subsub 0 subWindow1Minimized") << false << true << false << true << false << true;
QTest::newRow("window 0 sub1 0 sub2 1 subsub 0 subWindow1Minimized") << true << true << false << true << false << true;
QTest::newRow("window 1 sub1 1 sub2 0 subsub 0 subWindow1Minimized") << false << false << true << true << false << true;
QTest::newRow("window 0 sub1 1 sub2 0 subsub 0 subWindow1Minimized") << true << false << true << true << false << true;
QTest::newRow("window 1 sub1 0 sub2 0 subsub 0 subWindow1Minimized") << false << true << true << true << false << true;
QTest::newRow("window 0 sub1 0 sub2 0 subsub 0 subWindow1Minimized") << true << true << true << true << false << true;
}
void tst_QWidget::mapFromAndTo()
{
QFETCH(bool, windowHidden);
QFETCH(bool, subWindow1Hidden);
QFETCH(bool, subWindow2Hidden);
QFETCH(bool, subSubWindowHidden);
QFETCH(bool, windowMinimized);
QFETCH(bool, subWindow1Minimized);
// create a toplevel and two overlapping siblings
QWidget window;
window.setWindowFlags(window.windowFlags() | Qt::X11BypassWindowManagerHint);
QWidget *subWindow1 = new QWidget(&window);
QWidget *subWindow2 = new QWidget(&window);
QWidget *subSubWindow = new QWidget(subWindow1);
// set their geometries
window.setGeometry(100, 100, 100, 100);
subWindow1->setGeometry(50, 50, 100, 100);
subWindow2->setGeometry(75, 75, 100, 100);
subSubWindow->setGeometry(10, 10, 10, 10);
#if !defined (Q_OS_WINCE) && !defined(Q_OS_SYMBIAN) //still no proper minimizing
//update visibility
if (windowMinimized) {
if (!windowHidden) {
window.showMinimized();
QVERIFY(window.isMinimized());
}
} else {
window.setVisible(!windowHidden);
}
if (subWindow1Minimized) {
subWindow1->hide();
subWindow1->showMinimized();
QVERIFY(subWindow1->isMinimized());
} else {
subWindow1->setVisible(!subWindow1Hidden);
}
#else
Q_UNUSED(windowHidden);
Q_UNUSED(subWindow1Hidden);
Q_UNUSED(windowMinimized);
Q_UNUSED(subWindow1Minimized);
#endif
subWindow2->setVisible(!subWindow2Hidden);
subSubWindow->setVisible(!subSubWindowHidden);
// window
QCOMPARE(window.mapToGlobal(QPoint(0, 0)), QPoint(100, 100));
QCOMPARE(window.mapToGlobal(QPoint(10, 0)), QPoint(110, 100));
QCOMPARE(window.mapToGlobal(QPoint(0, 10)), QPoint(100, 110));
QCOMPARE(window.mapToGlobal(QPoint(-10, 0)), QPoint(90, 100));
QCOMPARE(window.mapToGlobal(QPoint(0, -10)), QPoint(100, 90));
QCOMPARE(window.mapToGlobal(QPoint(100, 100)), QPoint(200, 200));
QCOMPARE(window.mapToGlobal(QPoint(110, 100)), QPoint(210, 200));
QCOMPARE(window.mapToGlobal(QPoint(100, 110)), QPoint(200, 210));
QCOMPARE(window.mapFromGlobal(QPoint(100, 100)), QPoint(0, 0));
QCOMPARE(window.mapFromGlobal(QPoint(110, 100)), QPoint(10, 0));
QCOMPARE(window.mapFromGlobal(QPoint(100, 110)), QPoint(0, 10));
QCOMPARE(window.mapFromGlobal(QPoint(90, 100)), QPoint(-10, 0));
QCOMPARE(window.mapFromGlobal(QPoint(100, 90)), QPoint(0, -10));
QCOMPARE(window.mapFromGlobal(QPoint(200, 200)), QPoint(100, 100));
QCOMPARE(window.mapFromGlobal(QPoint(210, 200)), QPoint(110, 100));
QCOMPARE(window.mapFromGlobal(QPoint(200, 210)), QPoint(100, 110));
QCOMPARE(window.mapToParent(QPoint(0, 0)), QPoint(100, 100));
QCOMPARE(window.mapToParent(QPoint(10, 0)), QPoint(110, 100));
QCOMPARE(window.mapToParent(QPoint(0, 10)), QPoint(100, 110));
QCOMPARE(window.mapToParent(QPoint(-10, 0)), QPoint(90, 100));
QCOMPARE(window.mapToParent(QPoint(0, -10)), QPoint(100, 90));
QCOMPARE(window.mapToParent(QPoint(100, 100)), QPoint(200, 200));
QCOMPARE(window.mapToParent(QPoint(110, 100)), QPoint(210, 200));
QCOMPARE(window.mapToParent(QPoint(100, 110)), QPoint(200, 210));
QCOMPARE(window.mapFromParent(QPoint(100, 100)), QPoint(0, 0));
QCOMPARE(window.mapFromParent(QPoint(110, 100)), QPoint(10, 0));
QCOMPARE(window.mapFromParent(QPoint(100, 110)), QPoint(0, 10));
QCOMPARE(window.mapFromParent(QPoint(90, 100)), QPoint(-10, 0));
QCOMPARE(window.mapFromParent(QPoint(100, 90)), QPoint(0, -10));
QCOMPARE(window.mapFromParent(QPoint(200, 200)), QPoint(100, 100));
QCOMPARE(window.mapFromParent(QPoint(210, 200)), QPoint(110, 100));
QCOMPARE(window.mapFromParent(QPoint(200, 210)), QPoint(100, 110));
// first subwindow
QCOMPARE(subWindow1->mapToGlobal(QPoint(0, 0)), QPoint(150, 150));
QCOMPARE(subWindow1->mapToGlobal(QPoint(10, 0)), QPoint(160, 150));
QCOMPARE(subWindow1->mapToGlobal(QPoint(0, 10)), QPoint(150, 160));
QCOMPARE(subWindow1->mapToGlobal(QPoint(-10, 0)), QPoint(140, 150));
QCOMPARE(subWindow1->mapToGlobal(QPoint(0, -10)), QPoint(150, 140));
QCOMPARE(subWindow1->mapToGlobal(QPoint(100, 100)), QPoint(250, 250));
QCOMPARE(subWindow1->mapToGlobal(QPoint(110, 100)), QPoint(260, 250));
QCOMPARE(subWindow1->mapToGlobal(QPoint(100, 110)), QPoint(250, 260));
QCOMPARE(subWindow1->mapFromGlobal(QPoint(150, 150)), QPoint(0, 0));
QCOMPARE(subWindow1->mapFromGlobal(QPoint(160, 150)), QPoint(10, 0));
QCOMPARE(subWindow1->mapFromGlobal(QPoint(150, 160)), QPoint(0, 10));
QCOMPARE(subWindow1->mapFromGlobal(QPoint(140, 150)), QPoint(-10, 0));
QCOMPARE(subWindow1->mapFromGlobal(QPoint(150, 140)), QPoint(0, -10));
QCOMPARE(subWindow1->mapFromGlobal(QPoint(250, 250)), QPoint(100, 100));
QCOMPARE(subWindow1->mapFromGlobal(QPoint(260, 250)), QPoint(110, 100));
QCOMPARE(subWindow1->mapFromGlobal(QPoint(250, 260)), QPoint(100, 110));
QCOMPARE(subWindow1->mapToParent(QPoint(0, 0)), QPoint(50, 50));
QCOMPARE(subWindow1->mapToParent(QPoint(10, 0)), QPoint(60, 50));
QCOMPARE(subWindow1->mapToParent(QPoint(0, 10)), QPoint(50, 60));
QCOMPARE(subWindow1->mapToParent(QPoint(-10, 0)), QPoint(40, 50));
QCOMPARE(subWindow1->mapToParent(QPoint(0, -10)), QPoint(50, 40));
QCOMPARE(subWindow1->mapToParent(QPoint(100, 100)), QPoint(150, 150));
QCOMPARE(subWindow1->mapToParent(QPoint(110, 100)), QPoint(160, 150));
QCOMPARE(subWindow1->mapToParent(QPoint(100, 110)), QPoint(150, 160));
QCOMPARE(subWindow1->mapFromParent(QPoint(50, 50)), QPoint(0, 0));
QCOMPARE(subWindow1->mapFromParent(QPoint(60, 50)), QPoint(10, 0));
QCOMPARE(subWindow1->mapFromParent(QPoint(50, 60)), QPoint(0, 10));
QCOMPARE(subWindow1->mapFromParent(QPoint(40, 50)), QPoint(-10, 0));
QCOMPARE(subWindow1->mapFromParent(QPoint(50, 40)), QPoint(0, -10));
QCOMPARE(subWindow1->mapFromParent(QPoint(150, 150)), QPoint(100, 100));
QCOMPARE(subWindow1->mapFromParent(QPoint(160, 150)), QPoint(110, 100));
QCOMPARE(subWindow1->mapFromParent(QPoint(150, 160)), QPoint(100, 110));
// subsubwindow
QCOMPARE(subSubWindow->mapToGlobal(QPoint(0, 0)), QPoint(160, 160));
QCOMPARE(subSubWindow->mapToGlobal(QPoint(10, 0)), QPoint(170, 160));
QCOMPARE(subSubWindow->mapToGlobal(QPoint(0, 10)), QPoint(160, 170));
QCOMPARE(subSubWindow->mapToGlobal(QPoint(-10, 0)), QPoint(150, 160));
QCOMPARE(subSubWindow->mapToGlobal(QPoint(0, -10)), QPoint(160, 150));
QCOMPARE(subSubWindow->mapToGlobal(QPoint(100, 100)), QPoint(260, 260));
QCOMPARE(subSubWindow->mapToGlobal(QPoint(110, 100)), QPoint(270, 260));
QCOMPARE(subSubWindow->mapToGlobal(QPoint(100, 110)), QPoint(260, 270));
QCOMPARE(subSubWindow->mapFromGlobal(QPoint(160, 160)), QPoint(0, 0));
QCOMPARE(subSubWindow->mapFromGlobal(QPoint(170, 160)), QPoint(10, 0));
QCOMPARE(subSubWindow->mapFromGlobal(QPoint(160, 170)), QPoint(0, 10));
QCOMPARE(subSubWindow->mapFromGlobal(QPoint(150, 160)), QPoint(-10, 0));
QCOMPARE(subSubWindow->mapFromGlobal(QPoint(160, 150)), QPoint(0, -10));
QCOMPARE(subSubWindow->mapFromGlobal(QPoint(260, 260)), QPoint(100, 100));
QCOMPARE(subSubWindow->mapFromGlobal(QPoint(270, 260)), QPoint(110, 100));
QCOMPARE(subSubWindow->mapFromGlobal(QPoint(260, 270)), QPoint(100, 110));
QCOMPARE(subSubWindow->mapToParent(QPoint(0, 0)), QPoint(10, 10));
QCOMPARE(subSubWindow->mapToParent(QPoint(10, 0)), QPoint(20, 10));
QCOMPARE(subSubWindow->mapToParent(QPoint(0, 10)), QPoint(10, 20));
QCOMPARE(subSubWindow->mapToParent(QPoint(-10, 0)), QPoint(0, 10));
QCOMPARE(subSubWindow->mapToParent(QPoint(0, -10)), QPoint(10, 0));
QCOMPARE(subSubWindow->mapToParent(QPoint(100, 100)), QPoint(110, 110));
QCOMPARE(subSubWindow->mapToParent(QPoint(110, 100)), QPoint(120, 110));
QCOMPARE(subSubWindow->mapToParent(QPoint(100, 110)), QPoint(110, 120));
QCOMPARE(subSubWindow->mapFromParent(QPoint(10, 10)), QPoint(0, 0));
QCOMPARE(subSubWindow->mapFromParent(QPoint(20, 10)), QPoint(10, 0));
QCOMPARE(subSubWindow->mapFromParent(QPoint(10, 20)), QPoint(0, 10));
QCOMPARE(subSubWindow->mapFromParent(QPoint(0, 10)), QPoint(-10, 0));
QCOMPARE(subSubWindow->mapFromParent(QPoint(10, 0)), QPoint(0, -10));
QCOMPARE(subSubWindow->mapFromParent(QPoint(110, 110)), QPoint(100, 100));
QCOMPARE(subSubWindow->mapFromParent(QPoint(120, 110)), QPoint(110, 100));
QCOMPARE(subSubWindow->mapFromParent(QPoint(110, 120)), QPoint(100, 110));
}
void tst_QWidget::focusChainOnReparent()
{
QWidget window;
QWidget *child1 = new QWidget(&window);
QWidget *child2 = new QWidget(&window);
QWidget *child3 = new QWidget(&window);
QWidget *child21 = new QWidget(child2);
QWidget *child22 = new QWidget(child2);
QWidget *child4 = new QWidget(&window);
QWidget *expectedOriginalChain[8] = {&window, child1, child2, child3, child21, child22, child4, &window};
QWidget *w = &window;
for (int i = 0; i <8; ++i) {
QCOMPARE(w, expectedOriginalChain[i]);
w = w->nextInFocusChain();
}
for (int i = 7; i >= 0; --i) {
w = w->previousInFocusChain();
QCOMPARE(w, expectedOriginalChain[i]);
}
QWidget window2;
child2->setParent(&window2);
QWidget *expectedNewChain[5] = {&window2, child2, child21, child22, &window2};
w = &window2;
for (int i = 0; i <5; ++i) {
QCOMPARE(w, expectedNewChain[i]);
w = w->nextInFocusChain();
}
for (int i = 4; i >= 0; --i) {
w = w->previousInFocusChain();
QCOMPARE(w, expectedNewChain[i]);
}
QWidget *expectedOldChain[5] = {&window, child1, child3, child4, &window};
w = &window;
for (int i = 0; i <5; ++i) {
QCOMPARE(w, expectedOldChain[i]);
w = w->nextInFocusChain();
}
for (int i = 4; i >= 0; --i) {
w = w->previousInFocusChain();
QCOMPARE(w, expectedOldChain[i]);
}
}
void tst_QWidget::focusChainOnHide()
{
testWidget->hide(); // We do not want to get disturbed by other widgets
// focus should move to the next widget in the focus chain when we hide it.
QWidget *parent = new QWidget();
parent->setObjectName(QLatin1String("Parent"));
parent->setFocusPolicy(Qt::StrongFocus);
QWidget *child = new QWidget(parent);
child->setObjectName(QLatin1String("child"));
child->setFocusPolicy(Qt::StrongFocus);
QWidget::setTabOrder(child, parent);
parent->show();
qApp->setActiveWindow(parent->window());
child->activateWindow();
child->setFocus();
qApp->processEvents();
QTRY_COMPARE(child->hasFocus(), true);
child->hide();
qApp->processEvents();
QTRY_COMPARE(parent->hasFocus(), true);
QCOMPARE(parent, qApp->focusWidget());
delete parent;
testWidget->show(); //don't disturb later tests
}
class Container : public QWidget
{
public:
QVBoxLayout* box;
Container()
{
box = new QVBoxLayout(this);
//(new QVBoxLayout(this))->setAutoAdd(true);
}
void tab()
{
focusNextPrevChild(TRUE);
}
void backTab()
{
focusNextPrevChild(FALSE);
}
};
class Composite : public QFrame
{
public:
Composite(QWidget* parent = 0, const char* name = 0)
: QFrame(parent)
{
setObjectName(name);
//QHBoxLayout* hbox = new QHBoxLayout(this, 2, 0);
//hbox->setAutoAdd(true);
QHBoxLayout* hbox = new QHBoxLayout(this);
lineEdit = new QLineEdit(this);
hbox->addWidget(lineEdit);
button = new QPushButton(this);
hbox->addWidget(button);
button->setFocusPolicy( Qt::NoFocus );
setFocusProxy( lineEdit );
setFocusPolicy( Qt::StrongFocus );
setTabOrder(lineEdit, button);
}
private:
QLineEdit* lineEdit;
QPushButton* button;
};
#define NUM_WIDGETS 4
void tst_QWidget::setTabOrder()
{
QTest::qWait(100);
Container container;
Composite* comp[NUM_WIDGETS];
QLineEdit *firstEdit = new QLineEdit(&container);
container.box->addWidget(firstEdit);
int i = 0;
for(i = 0; i < NUM_WIDGETS; i++) {
comp[i] = new Composite(&container);
container.box->addWidget(comp[i]);
}
QLineEdit *lastEdit = new QLineEdit(&container);
container.box->addWidget(lastEdit);
container.setTabOrder(lastEdit, comp[NUM_WIDGETS-1]);
for(i = NUM_WIDGETS-1; i > 0; i--) {
container.setTabOrder(comp[i], comp[i-1]);
}
container.setTabOrder(comp[0], firstEdit);
int current = NUM_WIDGETS-1;
lastEdit->setFocus();
container.show();
container.activateWindow();
qApp->setActiveWindow(&container);
#ifdef Q_WS_X11
QTest::qWaitForWindowShown(&container);
QTest::qWait(50);
#endif
QTest::qWait(100);
QTRY_VERIFY(lastEdit->hasFocus());
container.tab();
do {
QVERIFY(comp[current]->focusProxy()->hasFocus());
container.tab();
current--;
} while (current >= 0);
QVERIFY(firstEdit->hasFocus());
}
void tst_QWidget::activation()
{
#if !defined(Q_WS_WIN)
QSKIP("This test is Windows-only.", SkipAll);
#endif
Q_CHECK_PAINTEVENTS
#if defined(Q_OS_WINCE)
int waitTime = 1000;
#else
int waitTime = 100;
#endif
#ifdef Q_OS_WINCE
qApp->processEvents();
#endif
QWidget widget1;
widget1.setWindowTitle("Widget1");
QWidget widget2;
widget2.setWindowTitle("Widget2");
widget1.show();
widget2.show();
QTest::qWait(waitTime);
QVERIFY(qApp->activeWindow() == &widget2);
widget2.showMinimized();
QTest::qWait(waitTime);
QVERIFY(qApp->activeWindow() == &widget1);
widget2.showMaximized();
QTest::qWait(waitTime);
QVERIFY(qApp->activeWindow() == &widget2);
widget2.showMinimized();
QTest::qWait(waitTime);
QVERIFY(qApp->activeWindow() == &widget1);
widget2.showNormal();
QTest::qWait(waitTime);
#if defined(Q_WS_WIN) && !defined(Q_OS_WINCE)
if (QSysInfo::WindowsVersion >= QSysInfo::WV_VISTA)
QEXPECT_FAIL("", "MS introduced new behavior after XP", Continue);
#endif
QTest::qWait(waitTime);
QVERIFY(qApp->activeWindow() == &widget2);
widget2.hide();
QTest::qWait(waitTime);
QVERIFY(qApp->activeWindow() == &widget1);
}
void tst_QWidget::windowState()
{
#ifdef Q_WS_X11
QSKIP("Many window managers do not support window state properly, which causes this "
"test to fail.", SkipAll);
#else
#ifdef Q_OS_WINCE_WM
QPoint pos(500, 500);
QSize size(200, 200);
if (qt_wince_is_smartphone()) { //small screen
pos = QPoint(10,10);
size = QSize(100,100);
}
#elif defined(Q_WS_S60)
QPoint pos = QPoint(10,10);
QSize size = QSize(100,100);
#else
const QPoint pos(500, 500);
const QSize size(200, 200);
#endif
QWidget widget1;
widget1.move(pos);
widget1.resize(size);
QCOMPARE(widget1.pos(), pos);
QCOMPARE(widget1.size(), size);
QTest::qWait(100);
widget1.setWindowTitle("Widget1");
QCOMPARE(widget1.pos(), pos);
QCOMPARE(widget1.size(), size);
#define VERIFY_STATE(s) QCOMPARE(int(widget1.windowState() & stateMask), int(s))
const int stateMask = Qt::WindowMaximized|Qt::WindowMinimized|Qt::WindowFullScreen;
widget1.setWindowState(Qt::WindowMaximized);
QTest::qWait(100);
VERIFY_STATE(Qt::WindowMaximized);
widget1.show();
QTest::qWait(100);
VERIFY_STATE(Qt::WindowMaximized);
widget1.setWindowState(widget1.windowState() ^ Qt::WindowMaximized);
QTest::qWait(100);
QVERIFY(!(widget1.windowState() & Qt::WindowMaximized));
QCOMPARE(widget1.pos(), pos);
widget1.setWindowState(Qt::WindowMinimized);
QTest::qWait(100);
VERIFY_STATE(Qt::WindowMinimized);
widget1.setWindowState(widget1.windowState() | Qt::WindowMaximized);
QTest::qWait(100);
VERIFY_STATE((Qt::WindowMinimized|Qt::WindowMaximized));
widget1.setWindowState(widget1.windowState() ^ Qt::WindowMinimized);
QTest::qWait(100);
VERIFY_STATE(Qt::WindowMaximized);
widget1.setWindowState(widget1.windowState() ^ Qt::WindowMaximized);
QTest::qWait(100);
QVERIFY(!(widget1.windowState() & (Qt::WindowMinimized|Qt::WindowMaximized)));
QCOMPARE(widget1.pos(), pos);
widget1.setWindowState(Qt::WindowFullScreen);
QTest::qWait(100);
VERIFY_STATE(Qt::WindowFullScreen);
widget1.setWindowState(widget1.windowState() ^ Qt::WindowMinimized);
QTest::qWait(100);
VERIFY_STATE((Qt::WindowFullScreen|Qt::WindowMinimized));
widget1.setWindowState(widget1.windowState() ^ Qt::WindowMinimized);
QTest::qWait(100);
VERIFY_STATE(Qt::WindowFullScreen);
widget1.setWindowState(widget1.windowState() ^ Qt::WindowMaximized);
QTest::qWait(100);
VERIFY_STATE((Qt::WindowFullScreen|Qt::WindowMaximized));
widget1.setWindowState(widget1.windowState() ^ Qt::WindowMinimized);
QTest::qWait(100);
VERIFY_STATE((Qt::WindowFullScreen|Qt::WindowMaximized|Qt::WindowMinimized));
widget1.setWindowState(widget1.windowState() ^ Qt::WindowMinimized);
QTest::qWait(100);
VERIFY_STATE((Qt::WindowFullScreen|Qt::WindowMaximized));
widget1.setWindowState(widget1.windowState() ^ Qt::WindowFullScreen);
QTest::qWait(100);
VERIFY_STATE(Qt::WindowMaximized);
widget1.setWindowState(widget1.windowState() ^ Qt::WindowMaximized);
QTest::qWait(100);
QVERIFY(!(widget1.windowState() & stateMask));
QCOMPARE(widget1.pos(), pos);
QCOMPARE(widget1.size(), size);
#endif
}
void tst_QWidget::showMaximized()
{
QWidget plain;
QHBoxLayout *layout;
layout = new QHBoxLayout;
QWidget layouted;
QLineEdit le;
QLineEdit le2;
QLineEdit le3;
layout->addWidget(&le);
layout->addWidget(&le2);
layout->addWidget(&le3);
layouted.setLayout(layout);
plain.showMaximized();
QVERIFY(plain.windowState() & Qt::WindowMaximized);
plain.showNormal();
QVERIFY(!(plain.windowState() & Qt::WindowMaximized));
layouted.showMaximized();
QVERIFY(layouted.windowState() & Qt::WindowMaximized);
layouted.showNormal();
QVERIFY(!(layouted.windowState() & Qt::WindowMaximized));
#if !defined(Q_WS_QWS) && !defined(Q_OS_WINCE) && !defined(Q_WS_S60) && !defined(Q_WS_QPA)
//embedded may choose a different size to fit on the screen.
QCOMPARE(layouted.size(), layouted.sizeHint());
#endif
layouted.showMaximized();
QVERIFY(layouted.isMaximized());
QVERIFY(layouted.isVisible());
layouted.hide();
QVERIFY(layouted.isMaximized());
QVERIFY(!layouted.isVisible());
layouted.showMaximized();
QVERIFY(layouted.isMaximized());
QVERIFY(layouted.isVisible());
layouted.showMinimized();
QVERIFY(layouted.isMinimized());
QVERIFY(layouted.isMaximized());
layouted.showMaximized();
QVERIFY(!layouted.isMinimized());
QVERIFY(layouted.isMaximized());
QVERIFY(layouted.isVisible());
layouted.showMinimized();
QVERIFY(layouted.isMinimized());
QVERIFY(layouted.isMaximized());
layouted.showMaximized();
QVERIFY(!layouted.isMinimized());
QVERIFY(layouted.isMaximized());
QVERIFY(layouted.isVisible());
{
QWidget frame;
QWidget widget(&frame);
widget.showMaximized();
QVERIFY(widget.isMaximized());
}
{
QWidget widget;
widget.setGeometry(0, 0, 10, 10);
widget.showMaximized();
QTRY_VERIFY(widget.size().width() > 20 && widget.size().height() > 20);
}
}
void tst_QWidget::showFullScreen()
{
QWidget plain;
QHBoxLayout *layout;
QWidget layouted;
QLineEdit le;
QLineEdit le2;
QLineEdit le3;
layout = new QHBoxLayout;
layout->addWidget(&le);
layout->addWidget(&le2);
layout->addWidget(&le3);
layouted.setLayout(layout);
plain.showFullScreen();
QVERIFY(plain.windowState() & Qt::WindowFullScreen);
plain.showNormal();
QVERIFY(!(plain.windowState() & Qt::WindowFullScreen));
layouted.showFullScreen();
QVERIFY(layouted.windowState() & Qt::WindowFullScreen);
layouted.showNormal();
QVERIFY(!(layouted.windowState() & Qt::WindowFullScreen));
#if !defined(Q_WS_QWS) && !defined(Q_OS_WINCE) && !defined (Q_WS_S60) && !defined(Q_WS_QPA)
//embedded may choose a different size to fit on the screen.
QCOMPARE(layouted.size(), layouted.sizeHint());
#endif
layouted.showFullScreen();
QVERIFY(layouted.isFullScreen());
QVERIFY(layouted.isVisible());
layouted.hide();
QVERIFY(layouted.isFullScreen());
QVERIFY(!layouted.isVisible());
layouted.showFullScreen();
QVERIFY(layouted.isFullScreen());
QVERIFY(layouted.isVisible());
layouted.showMinimized();
QVERIFY(layouted.isMinimized());
QVERIFY(layouted.isFullScreen());
layouted.showFullScreen();
QVERIFY(!layouted.isMinimized());
QVERIFY(layouted.isFullScreen());
QVERIFY(layouted.isVisible());
layouted.showMinimized();
QVERIFY(layouted.isMinimized());
QVERIFY(layouted.isFullScreen());
layouted.showFullScreen();
QVERIFY(!layouted.isMinimized());
QVERIFY(layouted.isFullScreen());
QVERIFY(layouted.isVisible());
{
QWidget frame;
QWidget widget(&frame);
widget.showFullScreen();
QVERIFY(widget.isFullScreen());
}
}
class ResizeWidget : public QWidget {
public:
ResizeWidget(QWidget *p = 0) : QWidget(p)
{
m_resizeEventCount = 0;
}
protected:
void resizeEvent(QResizeEvent *e){
QCOMPARE(size(), e->size());
++m_resizeEventCount;
}
public:
int m_resizeEventCount;
};
void tst_QWidget::resizeEvent()
{
{
QWidget wParent;
ResizeWidget wChild(&wParent);
wParent.show();
QCOMPARE (wChild.m_resizeEventCount, 1); // initial resize event before paint
wParent.hide();
QSize safeSize(640,480);
if (wChild.size() == safeSize)
safeSize.setWidth(639);
wChild.resize(safeSize);
QCOMPARE (wChild.m_resizeEventCount, 1);
wParent.show();
QCOMPARE (wChild.m_resizeEventCount, 2);
}
{
ResizeWidget wTopLevel;
wTopLevel.show();
QCOMPARE (wTopLevel.m_resizeEventCount, 1); // initial resize event before paint for toplevels
wTopLevel.hide();
QSize safeSize(640,480);
if (wTopLevel.size() == safeSize)
safeSize.setWidth(639);
wTopLevel.resize(safeSize);
QCOMPARE (wTopLevel.m_resizeEventCount, 1);
wTopLevel.show();
QCOMPARE (wTopLevel.m_resizeEventCount, 2);
}
}
void tst_QWidget::showMinimized()
{
QWidget plain;
plain.move(100, 100);
plain.resize(200, 200);
QPoint pos = plain.pos();
plain.showMinimized();
QVERIFY(plain.isMinimized());
QVERIFY(plain.isVisible());
QCOMPARE(plain.pos(), pos);
plain.showNormal();
QVERIFY(!plain.isMinimized());
QVERIFY(plain.isVisible());
QCOMPARE(plain.pos(), pos);
plain.showMinimized();
QVERIFY(plain.isMinimized());
QVERIFY(plain.isVisible());
QCOMPARE(plain.pos(), pos);
plain.hide();
QVERIFY(plain.isMinimized());
QVERIFY(!plain.isVisible());
plain.showMinimized();
QVERIFY(plain.isMinimized());
QVERIFY(plain.isVisible());
plain.setGeometry(200, 200, 300, 300);
plain.showNormal();
QCOMPARE(plain.geometry(), QRect(200, 200, 300, 300));
{
QWidget frame;
QWidget widget(&frame);
widget.showMinimized();
QVERIFY(widget.isMinimized());
}
}
void tst_QWidget::showMinimizedKeepsFocus()
{
//here we test that minimizing a widget and restoring it doesn't change the focus inside of it
{
QWidget window;
QWidget child1(&window), child2(&window);
child1.setFocusPolicy(Qt::StrongFocus);
child2.setFocusPolicy(Qt::StrongFocus);
window.show();
qApp->setActiveWindow(&window);
QTest::qWaitForWindowShown(&window);
child2.setFocus();
QTest::qWait(50);
QTRY_COMPARE(window.focusWidget(), &child2);
QTRY_COMPARE(qApp->focusWidget(), &child2);
window.showMinimized();
QTest::qWait(10);
QTRY_VERIFY(window.isMinimized());
QTRY_COMPARE(window.focusWidget(), &child2);
window.showNormal();
QTest::qWait(10);
QTRY_COMPARE(window.focusWidget(), &child2);
}
//testing deletion of the focusWidget
{
QWidget window;
QWidget *child = new QWidget(&window);
child->setFocusPolicy(Qt::StrongFocus);
window.show();
qApp->setActiveWindow(&window);
QTest::qWaitForWindowShown(&window);
child->setFocus();
QTest::qWait(50);
QTRY_COMPARE(window.focusWidget(), child);
QTRY_COMPARE(qApp->focusWidget(), child);
delete child;
QCOMPARE(window.focusWidget(), static_cast<QWidget*>(0));
QCOMPARE(qApp->focusWidget(), static_cast<QWidget*>(0));
}
//testing reparenting the focus widget
{
QWidget window;
QWidget *child = new QWidget(&window);
child->setFocusPolicy(Qt::StrongFocus);
window.show();
qApp->setActiveWindow(&window);
QTest::qWaitForWindowShown(&window);
child->setFocus();
QTest::qWait(50);
QTRY_COMPARE(window.focusWidget(), child);
QTRY_COMPARE(qApp->focusWidget(), child);
child->setParent(0);
QCOMPARE(window.focusWidget(), static_cast<QWidget*>(0));
QCOMPARE(qApp->focusWidget(), static_cast<QWidget*>(0));
}
//testing setEnabled(false)
{
QWidget window;
QWidget *child = new QWidget(&window);
child->setFocusPolicy(Qt::StrongFocus);
window.show();
qApp->setActiveWindow(&window);
QTest::qWaitForWindowShown(&window);
child->setFocus();
QTest::qWait(10);
QTRY_COMPARE(window.focusWidget(), child);
QTRY_COMPARE(qApp->focusWidget(), child);
child->setEnabled(false);
QCOMPARE(window.focusWidget(), static_cast<QWidget*>(0));
QCOMPARE(qApp->focusWidget(), static_cast<QWidget*>(0));
}
//testing clearFocus
{
QWidget window;
QWidget *firstchild = new QWidget(&window);
firstchild->setFocusPolicy(Qt::StrongFocus);
QWidget *child = new QWidget(&window);
child->setFocusPolicy(Qt::StrongFocus);
window.show();
qApp->setActiveWindow(&window);
QTest::qWaitForWindowShown(&window);
child->setFocus();
QTest::qWait(10);
QTRY_COMPARE(window.focusWidget(), child);
QTRY_COMPARE(qApp->focusWidget(), child);
child->clearFocus();
QCOMPARE(window.focusWidget(), static_cast<QWidget*>(0));
QCOMPARE(qApp->focusWidget(), static_cast<QWidget*>(0));
window.showMinimized();
QTest::qWait(30);
QTRY_VERIFY(window.isMinimized());
#ifdef Q_WS_QWS
QEXPECT_FAIL("", "QWS does not implement showMinimized()", Continue);
#endif
QCOMPARE(window.focusWidget(), static_cast<QWidget*>(0));
#ifdef Q_WS_QWS
QEXPECT_FAIL("", "QWS does not implement showMinimized()", Continue);
#endif
QTRY_COMPARE(qApp->focusWidget(), static_cast<QWidget*>(0));
window.showNormal();
qApp->setActiveWindow(&window);
QTest::qWaitForWindowShown(&window);
QTest::qWait(30);
#ifdef Q_WS_MAC
if (!macHasAccessToWindowsServer())
QEXPECT_FAIL("", "When not having WindowServer access, we lose focus.", Continue);
#endif
QTRY_COMPARE(window.focusWidget(), firstchild);
#ifdef Q_WS_MAC
if (!macHasAccessToWindowsServer())
QEXPECT_FAIL("", "When not having WindowServer access, we lose focus.", Continue);
#endif
QTRY_COMPARE(qApp->focusWidget(), firstchild);
}
}
void tst_QWidget::reparent()
{
QWidget parent;
parent.setWindowTitle("Toplevel");
parent.setGeometry(300, 300, 200, 150);
QWidget child(0);
child.setObjectName("child");
child.setGeometry(10, 10, 180, 130);
QPalette pal1;
pal1.setColor(child.backgroundRole(), Qt::white);
child.setPalette(pal1);
QWidget childTLW(&child, Qt::Window);
childTLW.setObjectName("childTLW");
childTLW.setGeometry(100, 100, 50, 50);
QPalette pal2;
pal2.setColor(childTLW.backgroundRole(), Qt::yellow);
childTLW.setPalette(pal2);
parent.show();
childTLW.show();
QTest::qWaitForWindowShown(&parent);
#ifdef Q_OS_WINCE
parent.move(50, 50);
#else
parent.move(300, 300);
#endif
QPoint childPos = parent.mapToGlobal(child.pos());
QPoint tlwPos = childTLW.pos();
child.setParent(0, child.windowFlags() & ~Qt::WindowType_Mask);
child.setGeometry(childPos.x(), childPos.y(), child.width(), child.height());
child.show();
#ifdef Q_WS_X11
// On X11, the window manager will apply NorthWestGravity rules to 'child', which
// means the top-left corner of the window frame will be placed at 'childPos',
// causing this test to fail
#else
QCOMPARE(child.geometry().topLeft(), childPos);
#endif
QTRY_COMPARE(childTLW.pos(), tlwPos);
#ifdef Q_WS_WIN
QWidget childTLWChild(&childTLW);
childTLWChild.setObjectName("childTLWChild");
QWidget grandChild(&child);
grandChild.setObjectName("grandChild");
grandChild.setGeometry(10, 10, 160, 110);
QPalette pal3;
pal3.setColor(grandChild.backgroundRole(), Qt::red);
grandChild.setPalette(pal3);
//grandChild.setPaletteBackgroundColor(Qt::red);
QWidget grandChildTLW(&grandChild, Qt::Window);
grandChildTLW.setObjectName("grandChildTLW");
grandChildTLW.setGeometry(200, 200, 50, 50);
QPalette pal4;
pal4.setColor(grandChildTLW.backgroundRole(), Qt::yellow);
grandChildTLW.setPalette(pal4);
//grandChildTLW.setPaletteBackgroundColor(Qt::yellow);
QWidget grandChildTLWChild(&grandChildTLW);
grandChildTLWChild.setObjectName("grandChildTLWChild");
QVERIFY(IsWindow(childTLW.winId()));
QVERIFY(IsWindow(childTLWChild.winId()));
QVERIFY(IsWindow(grandChildTLW.winId()));
QVERIFY(IsWindow(grandChildTLWChild.winId()));
parent.show();
QVERIFY(IsWindow(childTLW.winId()));
QVERIFY(IsWindow(childTLWChild.winId()));
QVERIFY(IsWindow(grandChildTLW.winId()));
QVERIFY(IsWindow(grandChildTLWChild.winId()));
child.setParent(&parent);
child.move(10,10);
child.show();
// this appears to stabelize results
qApp->processEvents();
QVERIFY(IsWindow(childTLW.winId()));
QVERIFY(IsWindow(childTLWChild.winId()));
QVERIFY(IsWindow(grandChildTLW.winId()));
QVERIFY(IsWindow(grandChildTLWChild.winId()));
#else
QSKIP("This test makes only sense on Windows", SkipAll);
#endif
}
void tst_QWidget::icon()
{
#if defined(Q_WS_QWS)
QSKIP("Qt/Embedded does it differently", SkipAll);
#else
QPixmap p(20,20);
p.fill(Qt::red);
testWidget->setWindowIcon(p);
QVERIFY(!testWidget->windowIcon().isNull());
testWidget->show();
QVERIFY(!testWidget->windowIcon().isNull());
testWidget->showFullScreen();
QVERIFY(!testWidget->windowIcon().isNull());
testWidget->showNormal();
QVERIFY(!testWidget->windowIcon().isNull());
#endif
}
void tst_QWidget::hideWhenFocusWidgetIsChild()
{
testWidget->activateWindow();
QWidget *parentWidget = new QWidget(testWidget);
parentWidget->setObjectName("parentWidget");
parentWidget->setGeometry(0, 0, 100, 100);
QLineEdit *edit = new QLineEdit(parentWidget);
edit->setObjectName("edit1");
QLineEdit *edit3 = new QLineEdit(parentWidget);
edit3->setObjectName("edit3");
edit3->move(0,50);
parentWidget->show();
QLineEdit *edit2 = new QLineEdit(testWidget);
edit2->setObjectName("edit2");
edit2->show();
edit2->move(110, 100);
edit->setFocus();
qApp->processEvents();
QString actualFocusWidget, expectedFocusWidget;
#ifdef Q_WS_X11
if (!qApp->focusWidget())
QSKIP("Your window manager is too broken for this test", SkipAll);
#endif
QVERIFY(qApp->focusWidget());
actualFocusWidget.sprintf("%p %s %s", qApp->focusWidget(), qApp->focusWidget()->objectName().toLatin1().constData(), qApp->focusWidget()->metaObject()->className());
expectedFocusWidget.sprintf("%p %s %s", edit, edit->objectName().toLatin1().constData(), edit->metaObject()->className());
QCOMPARE(actualFocusWidget, expectedFocusWidget);
parentWidget->hide();
qApp->processEvents();
actualFocusWidget.sprintf("%p %s %s", qApp->focusWidget(), qApp->focusWidget()->objectName().toLatin1().constData(), qApp->focusWidget()->metaObject()->className());
expectedFocusWidget.sprintf("%p %s %s", edit2, edit2->objectName().toLatin1().constData(), edit2->metaObject()->className());
QCOMPARE(actualFocusWidget, expectedFocusWidget);
delete edit2;
delete parentWidget;
}
void tst_QWidget::normalGeometry()
{
#ifdef Q_OS_IRIX
QSKIP("4DWM issues on IRIX makes this test fail", SkipAll);
#endif
QWidget parent;
parent.setWindowTitle("NormalGeometry parent");
QWidget *child = new QWidget(&parent);
QCOMPARE(parent.normalGeometry(), parent.geometry());
QCOMPARE(child->normalGeometry(), QRect());
parent.setGeometry(100, 100, 200, 200);
parent.show();
QTest::qWaitForWindowShown(&parent);
QApplication::processEvents();
QRect geom = parent.geometry();
// ### the window manager places the top-left corner at
// ### 100,100... making geom something like 102,124 (offset by
// ### the frame/frame)... this indicates a rather large different
// ### between how X11 and Windows works
// QCOMPARE(geom, QRect(100, 100, 200, 200));
QCOMPARE(parent.normalGeometry(), geom);
parent.setWindowState(parent.windowState() ^ Qt::WindowMaximized);
QTest::qWait(10);
QTRY_VERIFY(parent.windowState() & Qt::WindowMaximized);
QTRY_VERIFY(parent.geometry() != geom);
QTRY_COMPARE(parent.normalGeometry(), geom);
parent.setWindowState(parent.windowState() ^ Qt::WindowMaximized);
QTest::qWait(10);
QTRY_VERIFY(!(parent.windowState() & Qt::WindowMaximized));
QTRY_COMPARE(parent.geometry(), geom);
QTRY_COMPARE(parent.normalGeometry(), geom);
parent.showMaximized();
QTest::qWait(10);
QTRY_VERIFY(parent.windowState() & Qt::WindowMaximized);
QTRY_VERIFY(parent.geometry() != geom);
QCOMPARE(parent.normalGeometry(), geom);
parent.showNormal();
QTest::qWait(10);
QTRY_VERIFY(!(parent.windowState() & Qt::WindowMaximized));
QTRY_COMPARE(parent.geometry(), geom);
QCOMPARE(parent.normalGeometry(), geom);
parent.setWindowState(parent.windowState() ^ Qt::WindowMinimized);
QTest::qWait(10);
parent.setWindowState(parent.windowState() ^ Qt::WindowMaximized);
QTest::qWait(10);
QTRY_VERIFY(parent.windowState() & (Qt::WindowMinimized|Qt::WindowMaximized));
// ### when minimized and maximized at the same time, the geometry
// ### does *NOT* have to be the normal geometry, it could be the
// ### maximized geometry.
// QCOMPARE(parent.geometry(), geom);
QTRY_COMPARE(parent.normalGeometry(), geom);
parent.setWindowState(parent.windowState() ^ Qt::WindowMinimized);
QTest::qWait(10);
QTRY_VERIFY(!(parent.windowState() & Qt::WindowMinimized));
QTRY_VERIFY(parent.windowState() & Qt::WindowMaximized);
QTRY_VERIFY(parent.geometry() != geom);
QTRY_COMPARE(parent.normalGeometry(), geom);
parent.setWindowState(parent.windowState() ^ Qt::WindowMaximized);
QTest::qWait(10);
QTRY_VERIFY(!(parent.windowState() & Qt::WindowMaximized));
QTRY_COMPARE(parent.geometry(), geom);
QTRY_COMPARE(parent.normalGeometry(), geom);
parent.setWindowState(parent.windowState() ^ Qt::WindowFullScreen);
QTest::qWait(10);
QTRY_VERIFY(parent.windowState() & Qt::WindowFullScreen);
QTRY_VERIFY(parent.geometry() != geom);
QTRY_COMPARE(parent.normalGeometry(), geom);
parent.setWindowState(parent.windowState() ^ Qt::WindowFullScreen);
QTest::qWait(10);
QVERIFY(!(parent.windowState() & Qt::WindowFullScreen));
QTRY_COMPARE(parent.geometry(), geom);
QTRY_COMPARE(parent.normalGeometry(), geom);
parent.showFullScreen();
QTest::qWait(10);
QTRY_VERIFY(parent.windowState() & Qt::WindowFullScreen);
QTRY_VERIFY(parent.geometry() != geom);
QTRY_COMPARE(parent.normalGeometry(), geom);
parent.showNormal();
QTest::qWait(10);
QTRY_VERIFY(!(parent.windowState() & Qt::WindowFullScreen));
QTRY_COMPARE(parent.geometry(), geom);
QTRY_COMPARE(parent.normalGeometry(), geom);
parent.showNormal();
parent.setWindowState(Qt:: WindowFullScreen | Qt::WindowMaximized);
parent.setWindowState(Qt::WindowMinimized | Qt:: WindowFullScreen | Qt::WindowMaximized);
parent.setWindowState(Qt:: WindowFullScreen | Qt::WindowMaximized);
QTest::qWait(10);
QTRY_COMPARE(parent.normalGeometry(), geom);
}
void tst_QWidget::setGeometry()
{
QWidget tlw;
QWidget child(&tlw);
QRect tr(100,100,200,200);
QRect cr(50,50,50,50);
tlw.setGeometry(tr);
child.setGeometry(cr);
tlw.show();
QTest::qWait(50);
QCOMPARE(tlw.geometry().size(), tr.size());
QCOMPARE(child.geometry(), cr);
tlw.setParent(0, Qt::Window|Qt::FramelessWindowHint);
tr = QRect(0,0,100,100);
tr.moveTopLeft(QApplication::desktop()->availableGeometry().topLeft());
tlw.setGeometry(tr);
QCOMPARE(tlw.geometry(), tr);
tlw.show();
QTest::qWait(50);
if (tlw.frameGeometry() != tlw.geometry())
QSKIP("Your window manager is too broken for this test", SkipAll);
QCOMPARE(tlw.geometry(), tr);
}
void tst_QWidget::windowOpacity()
{
#ifdef Q_OS_WINCE
QSKIP( "Windows CE does not support windowOpacity", SkipAll);
#endif
QWidget widget;
QWidget child(&widget);
// Initial value should be 1.0
QCOMPARE(widget.windowOpacity(), 1.0);
// children should always return 1.0
QCOMPARE(child.windowOpacity(), 1.0);
widget.setWindowOpacity(0.0);
QCOMPARE(widget.windowOpacity(), 0.0);
child.setWindowOpacity(0.0);
QCOMPARE(child.windowOpacity(), 1.0);
widget.setWindowOpacity(1.0);
QCOMPARE(widget.windowOpacity(), 1.0);
child.setWindowOpacity(1.0);
QCOMPARE(child.windowOpacity(), 1.0);
widget.setWindowOpacity(2.0);
QCOMPARE(widget.windowOpacity(), 1.0);
child.setWindowOpacity(2.0);
QCOMPARE(child.windowOpacity(), 1.0);
widget.setWindowOpacity(-1.0);
QCOMPARE(widget.windowOpacity(), 0.0);
child.setWindowOpacity(-1.0);
QCOMPARE(child.windowOpacity(), 1.0);
}
class UpdateWidget : public QWidget
{
public:
UpdateWidget(QWidget *parent = 0) : QWidget(parent) {
reset();
}
void paintEvent(QPaintEvent *e) {
paintedRegion += e->region();
++numPaintEvents;
if (resizeInPaintEvent) {
resizeInPaintEvent = false;
resize(size() + QSize(2, 2));
}
}
bool event(QEvent *event)
{
switch (event->type()) {
case QEvent::ZOrderChange:
++numZOrderChangeEvents;
break;
case QEvent::UpdateRequest:
++numUpdateRequestEvents;
break;
case QEvent::ActivationChange:
case QEvent::FocusIn:
case QEvent::FocusOut:
case QEvent::WindowActivate:
case QEvent::WindowDeactivate:
if (!updateOnActivationChangeAndFocusIn)
return true; // Filter out to avoid update() calls in QWidget.
break;
default:
break;
}
return QWidget::event(event);
}
void reset() {
numPaintEvents = 0;
numZOrderChangeEvents = 0;
numUpdateRequestEvents = 0;
updateOnActivationChangeAndFocusIn = false;
resizeInPaintEvent = false;
paintedRegion = QRegion();
}
int numPaintEvents;
int numZOrderChangeEvents;
int numUpdateRequestEvents;
bool updateOnActivationChangeAndFocusIn;
bool resizeInPaintEvent;
QRegion paintedRegion;
};
void tst_QWidget::lostUpdatesOnHide()
{
#ifndef Q_WS_MAC
UpdateWidget widget;
widget.setAttribute(Qt::WA_DontShowOnScreen);
widget.show();
widget.hide();
QTest::qWait(50);
widget.show();
QTest::qWait(50);
QCOMPARE(widget.numPaintEvents, 1);
#endif
}
void tst_QWidget::raise()
{
QTest::qWait(10);
QWidget *parent = new QWidget(0);
QList<UpdateWidget *> allChildren;
UpdateWidget *child1 = new UpdateWidget(parent);
child1->setAutoFillBackground(true);
allChildren.append(child1);
UpdateWidget *child2 = new UpdateWidget(parent);
child2->setAutoFillBackground(true);
allChildren.append(child2);
UpdateWidget *child3 = new UpdateWidget(parent);
child3->setAutoFillBackground(true);
allChildren.append(child3);
UpdateWidget *child4 = new UpdateWidget(parent);
child4->setAutoFillBackground(true);
allChildren.append(child4);
parent->show();
QTest::qWaitForWindowShown(parent);
QTest::qWait(10);
#ifdef QT_MAC_USE_COCOA
if (child1->internalWinId()) {
QSKIP("Cocoa has no Z-Order for views, we hack it, but it results in paint events.", SkipAll);
}
#endif
QList<QObject *> list1;
list1 << child1 << child2 << child3 << child4;
QVERIFY(parent->children() == list1);
QCOMPARE(allChildren.count(), list1.count());
foreach (UpdateWidget *child, allChildren) {
int expectedPaintEvents = child == child4 ? 1 : 0;
if (expectedPaintEvents == 0) {
QVERIFY(child->numPaintEvents == 0);
} else {
// show() issues multiple paint events on some window managers
QTRY_VERIFY(child->numPaintEvents >= expectedPaintEvents);
}
QCOMPARE(child->numZOrderChangeEvents, 0);
child->reset();
}
for (int i = 0; i < 5; ++i)
child2->raise();
QTest::qWait(50);
foreach (UpdateWidget *child, allChildren) {
int expectedPaintEvents = child == child2 ? 1 : 0;
int expectedZOrderChangeEvents = child == child2 ? 1 : 0;
#ifdef QT_MAC_USE_COCOA
QSKIP("Not yet sure why this fails.", SkipSingle);
#endif
QTRY_COMPARE(child->numPaintEvents, expectedPaintEvents);
QCOMPARE(child->numZOrderChangeEvents, expectedZOrderChangeEvents);
child->reset();
}
QList<QObject *> list2;
list2 << child1 << child3 << child4 << child2;
QVERIFY(parent->children() == list2);
// Creates a widget on top of all the children and checks that raising one of
// the children underneath doesn't trigger a repaint on the covering widget.
QWidget topLevel;
parent->setParent(&topLevel);
topLevel.show();
QTest::qWaitForWindowShown(&topLevel);
QTest::qWait(50);
UpdateWidget *onTop = new UpdateWidget(&topLevel);
onTop->reset();
onTop->resize(topLevel.size());
onTop->setAutoFillBackground(true);
onTop->show();
QTest::qWait(50);
QTRY_VERIFY(onTop->numPaintEvents > 0);
onTop->reset();
// Reset all the children.
foreach (UpdateWidget *child, allChildren)
child->reset();
for (int i = 0; i < 5; ++i)
child3->raise();
QTest::qWait(50);
QCOMPARE(onTop->numPaintEvents, 0);
QCOMPARE(onTop->numZOrderChangeEvents, 0);
QList<QObject *> list3;
list3 << child1 << child4 << child2 << child3;
QVERIFY(parent->children() == list3);
foreach (UpdateWidget *child, allChildren) {
int expectedPaintEvents = 0;
int expectedZOrderChangeEvents = child == child3 ? 1 : 0;
QTRY_COMPARE(child->numPaintEvents, expectedPaintEvents);
QCOMPARE(child->numZOrderChangeEvents, expectedZOrderChangeEvents);
child->reset();
}
}
void tst_QWidget::lower()
{
#ifdef QT_MAC_USE_COCOA
QSKIP("Cocoa has no Z-Order for views, we hack it, but it results in paint events.", SkipAll);
#endif
QWidget *parent = new QWidget(0);
QList<UpdateWidget *> allChildren;
UpdateWidget *child1 = new UpdateWidget(parent);
child1->setAutoFillBackground(true);
allChildren.append(child1);
UpdateWidget *child2 = new UpdateWidget(parent);
child2->setAutoFillBackground(true);
allChildren.append(child2);
UpdateWidget *child3 = new UpdateWidget(parent);
child3->setAutoFillBackground(true);
allChildren.append(child3);
UpdateWidget *child4 = new UpdateWidget(parent);
child4->setAutoFillBackground(true);
allChildren.append(child4);
parent->show();
QTest::qWaitForWindowShown(parent);
QTest::qWait(100);
QList<QObject *> list1;
list1 << child1 << child2 << child3 << child4;
QVERIFY(parent->children() == list1);
QCOMPARE(allChildren.count(), list1.count());
foreach (UpdateWidget *child, allChildren) {
int expectedPaintEvents = child == child4 ? 1 : 0;
if (expectedPaintEvents == 0) {
QVERIFY(child->numPaintEvents == 0);
} else {
// show() issues multiple paint events on some window managers
QTRY_VERIFY(child->numPaintEvents >= expectedPaintEvents);
}
QCOMPARE(child->numZOrderChangeEvents, 0);
child->reset();
}
for (int i = 0; i < 5; ++i)
child4->lower();
QTest::qWait(100);
foreach (UpdateWidget *child, allChildren) {
int expectedPaintEvents = child == child3 ? 1 : 0;
int expectedZOrderChangeEvents = child == child4 ? 1 : 0;
QTRY_COMPARE(child->numZOrderChangeEvents, expectedZOrderChangeEvents);
QTRY_COMPARE(child->numPaintEvents, expectedPaintEvents);
child->reset();
}
QList<QObject *> list2;
list2 << child4 << child1 << child2 << child3;
QVERIFY(parent->children() == list2);
delete parent;
}
void tst_QWidget::stackUnder()
{
#ifdef QT_MAC_USE_COCOA
QSKIP("Cocoa has no Z-Order for views, we hack it, but it results in paint events.", SkipAll);
#endif
QTest::qWait(10);
QWidget *parent = new QWidget(0);
QList<UpdateWidget *> allChildren;
UpdateWidget *child1 = new UpdateWidget(parent);
child1->setAutoFillBackground(true);
allChildren.append(child1);
UpdateWidget *child2 = new UpdateWidget(parent);
child2->setAutoFillBackground(true);
allChildren.append(child2);
UpdateWidget *child3 = new UpdateWidget(parent);
child3->setAutoFillBackground(true);
allChildren.append(child3);
UpdateWidget *child4 = new UpdateWidget(parent);
child4->setAutoFillBackground(true);
allChildren.append(child4);
parent->show();
QTest::qWaitForWindowShown(parent);
QTest::qWait(10);
#ifdef Q_WS_QWS
QApplication::sendPostedEvents(); //glib workaround
#endif
QList<QObject *> list1;
list1 << child1 << child2 << child3 << child4;
QVERIFY(parent->children() == list1);
foreach (UpdateWidget *child, allChildren) {
int expectedPaintEvents = child == child4 ? 1 : 0;
#if defined(Q_WS_WIN) || defined(Q_WS_MAC)
if (expectedPaintEvents == 1 && child->numPaintEvents == 2)
QEXPECT_FAIL(0, "Mac and Windows issues double repaints for Z-Order change", Continue);
#endif
QTRY_COMPARE(child->numPaintEvents, expectedPaintEvents);
QCOMPARE(child->numZOrderChangeEvents, 0);
child->reset();
}
for (int i = 0; i < 5; ++i)
child4->stackUnder(child2);
QTest::qWait(10);
QList<QObject *> list2;
list2 << child1 << child4 << child2 << child3;
QVERIFY(parent->children() == list2);
foreach (UpdateWidget *child, allChildren) {
int expectedPaintEvents = child == child3 ? 1 : 0;
int expectedZOrderChangeEvents = child == child4 ? 1 : 0;
QTRY_COMPARE(child->numPaintEvents, expectedPaintEvents);
QTRY_COMPARE(child->numZOrderChangeEvents, expectedZOrderChangeEvents);
child->reset();
}
for (int i = 0; i < 5; ++i)
child1->stackUnder(child3);
QTest::qWait(10);
QList<QObject *> list3;
list3 << child4 << child2 << child1 << child3;
QVERIFY(parent->children() == list3);
foreach (UpdateWidget *child, allChildren) {
int expectedZOrderChangeEvents = child == child1 ? 1 : 0;
if (child == child3) {
#ifdef Q_OS_WINCE
qApp->processEvents();
#endif
#ifndef Q_WS_MAC
QEXPECT_FAIL(0, "See QTBUG-493", Continue);
#endif
QCOMPARE(child->numPaintEvents, 0);
} else {
QCOMPARE(child->numPaintEvents, 0);
}
QTRY_COMPARE(child->numZOrderChangeEvents, expectedZOrderChangeEvents);
child->reset();
}
delete parent;
}
void drawPolygon(QPaintDevice *dev, int w, int h)
{
QPainter p(dev);
p.fillRect(0, 0, w, h, Qt::white);
QPolygon a;
a << QPoint(0, 0) << QPoint(w/2, h/2) << QPoint(w, 0)
<< QPoint(w/2, h) << QPoint(0, 0);
p.setPen(QPen(Qt::black, 1));
p.setBrush(Qt::DiagCrossPattern);
p.drawPolygon(a);
}
class ContentsPropagationWidget : public QWidget
{
Q_OBJECT
public:
ContentsPropagationWidget(QWidget *parent = 0) : QWidget(parent)
{
QWidget *child = this;
for (int i=0; i<32; ++i) {
child = new QWidget(child);
child->setGeometry(i, i, 400 - i*2, 400 - i*2);
}
}
void setContentsPropagation(bool enable) {
foreach (QObject *child, children())
qobject_cast<QWidget *>(child)->setAutoFillBackground(!enable);
}
protected:
void paintEvent(QPaintEvent *)
{
int w = width(), h = height();
drawPolygon(this, w, h);
}
QSize sizeHint() const { return QSize(500, 500); }
};
void tst_QWidget::testContentsPropagation()
{
ContentsPropagationWidget widget;
#ifdef Q_WS_QWS
widget.resize(500,500);
#else
widget.setFixedSize(500, 500);
#endif
widget.setContentsPropagation(false);
QPixmap widgetSnapshot = QPixmap::grabWidget(&widget);
QPixmap correct(500, 500);
drawPolygon(&correct, 500, 500);
//correct.save("correct.png", "PNG");
//widgetSnapshot.save("snap1.png", "PNG");
QVERIFY(widgetSnapshot.toImage() != correct.toImage());
widget.setContentsPropagation(true);
widgetSnapshot = QPixmap::grabWidget(&widget);
//widgetSnapshot.save("snap2.png", "PNG");
QCOMPARE(widgetSnapshot, correct);
}
/*
Test that saving and restoring window geometry with
saveGeometry() and restoreGeometry() works.
*/
void tst_QWidget::saveRestoreGeometry()
{
#ifdef Q_OS_IRIX
QSKIP("4DWM issues on IRIX makes this test fail", SkipAll);
#endif
const QPoint position(100, 100);
const QSize size(200, 200);
QByteArray savedGeometry;
{
QWidget widget;
widget.move(position);
widget.resize(size);
widget.show();
QTest::qWaitForWindowShown(&widget);
QApplication::processEvents();
QTRY_COMPARE(widget.pos(), position);
QCOMPARE(widget.size(), size);
savedGeometry = widget.saveGeometry();
}
{
QWidget widget;
const QByteArray empty;
const QByteArray one("a");
const QByteArray two("ab");
const QByteArray three("abc");
const QByteArray four("abca");
const QByteArray garbage("abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc");
QVERIFY(widget.restoreGeometry(empty) == false);
QVERIFY(widget.restoreGeometry(one) == false);
QVERIFY(widget.restoreGeometry(two) == false);
QVERIFY(widget.restoreGeometry(three) == false);
QVERIFY(widget.restoreGeometry(four) == false);
QVERIFY(widget.restoreGeometry(garbage) == false);
QVERIFY(widget.restoreGeometry(savedGeometry));
widget.show();
QTest::qWaitForWindowShown(&widget);
QApplication::processEvents();
QTRY_COMPARE(widget.pos(), position);
QCOMPARE(widget.size(), size);
widget.show();
QCOMPARE(widget.pos(), position);
QCOMPARE(widget.size(), size);
}
{
QWidget widget;
widget.move(position);
widget.resize(size);
widget.show();
QTest::qWaitForWindowShown(&widget);
QTest::qWait(500);
QTRY_COMPARE(widget.geometry().size(), size);
QRect geom;
//Restore from Full screen
savedGeometry = widget.saveGeometry();
geom = widget.geometry();
widget.setWindowState(widget.windowState() | Qt::WindowFullScreen);
QTRY_VERIFY((widget.windowState() & Qt::WindowFullScreen));
QTest::qWait(500);
QVERIFY(widget.restoreGeometry(savedGeometry));
QTest::qWait(120);
QTRY_VERIFY(!(widget.windowState() & Qt::WindowFullScreen));
QTRY_COMPARE(widget.geometry(), geom);
//Restore to full screen
widget.setWindowState(widget.windowState() | Qt::WindowFullScreen);
QTest::qWait(120);
QTRY_VERIFY((widget.windowState() & Qt::WindowFullScreen));
QTest::qWait(500);
savedGeometry = widget.saveGeometry();
geom = widget.geometry();
widget.setWindowState(widget.windowState() ^ Qt::WindowFullScreen);
QTest::qWait(120);
QTRY_VERIFY(!(widget.windowState() & Qt::WindowFullScreen));
QTest::qWait(400);
QVERIFY(widget.restoreGeometry(savedGeometry));
QTest::qWait(120);
QTRY_VERIFY((widget.windowState() & Qt::WindowFullScreen));
QTRY_COMPARE(widget.geometry(), geom);
QVERIFY((widget.windowState() & Qt::WindowFullScreen));
widget.setWindowState(widget.windowState() ^ Qt::WindowFullScreen);
QTest::qWait(120);
QTRY_VERIFY(!(widget.windowState() & Qt::WindowFullScreen));
QTest::qWait(120);
//Restore from Maximised
widget.move(position);
widget.resize(size);
QTest::qWait(10);
QTRY_COMPARE(widget.size(), size);
QTest::qWait(500);
savedGeometry = widget.saveGeometry();
geom = widget.geometry();
widget.setWindowState(widget.windowState() | Qt::WindowMaximized);
QTest::qWait(120);
QTRY_VERIFY((widget.windowState() & Qt::WindowMaximized));
QTRY_VERIFY(widget.geometry() != geom);
QTest::qWait(500);
QVERIFY(widget.restoreGeometry(savedGeometry));
QTest::qWait(120);
QTRY_COMPARE(widget.geometry(), geom);
QVERIFY(!(widget.windowState() & Qt::WindowMaximized));
//Restore to maximised
widget.setWindowState(widget.windowState() | Qt::WindowMaximized);
QTest::qWait(120);
QTRY_VERIFY((widget.windowState() & Qt::WindowMaximized));
QTest::qWait(500);
geom = widget.geometry();
savedGeometry = widget.saveGeometry();
widget.setWindowState(widget.windowState() ^ Qt::WindowMaximized);
QTest::qWait(120);
QTRY_VERIFY(!(widget.windowState() & Qt::WindowMaximized));
QTest::qWait(500);
QVERIFY(widget.restoreGeometry(savedGeometry));
QTest::qWait(120);
QTRY_VERIFY((widget.windowState() & Qt::WindowMaximized));
QTRY_COMPARE(widget.geometry(), geom);
}
}
void tst_QWidget::restoreVersion1Geometry_data()
{
QTest::addColumn<QString>("fileName");
QTest::addColumn<uint>("expectedWindowState");
QTest::addColumn<QPoint>("expectedPosition");
QTest::addColumn<QSize>("expectedSize");
QTest::addColumn<QRect>("expectedNormalGeometry");
const QPoint position(100, 100);
const QSize size(200, 200);
const QRect normalGeometry(102, 124, 200, 200);
QTest::newRow("geometry.dat") << ":geometry.dat" << uint(Qt::WindowNoState) << position << size << normalGeometry;
QTest::newRow("geometry-maximized.dat") << ":geometry-maximized.dat" << uint(Qt::WindowMaximized) << position << size << normalGeometry;
QTest::newRow("geometry-fullscreen.dat") << ":geometry-fullscreen.dat" << uint(Qt::WindowFullScreen) << position << size << normalGeometry;
}
/*
Test that the current version of restoreGeometry() can restore geometry
saved width saveGeometry() version 1.0.
*/
void tst_QWidget::restoreVersion1Geometry()
{
#ifdef Q_OS_IRIX
QSKIP("4DWM issues on IRIX makes this test fail", SkipAll);
#endif
QFETCH(QString, fileName);
QFETCH(uint, expectedWindowState);
QFETCH(QPoint, expectedPosition);
QFETCH(QSize, expectedSize);
QFETCH(QRect, expectedNormalGeometry);
// WindowActive is uninteresting for this test
const uint WindowStateMask = Qt::WindowFullScreen | Qt::WindowMaximized | Qt::WindowMinimized;
QFile f(fileName);
QVERIFY(f.exists());
f.open(QIODevice::ReadOnly);
const QByteArray savedGeometry = f.readAll();
QCOMPARE(savedGeometry.count(), 46);
f.close();
QWidget widget;
QVERIFY(widget.restoreGeometry(savedGeometry));
QCOMPARE(uint(widget.windowState() & WindowStateMask), expectedWindowState);
if (expectedWindowState == Qt::WindowNoState) {
QCOMPARE(widget.pos(), expectedPosition);
QCOMPARE(widget.size(), expectedSize);
}
widget.show();
QTest::qWaitForWindowShown(&widget);
QTest::qWait(100);
if (expectedWindowState == Qt::WindowNoState) {
QTRY_COMPARE(widget.pos(), expectedPosition);
QTRY_COMPARE(widget.size(), expectedSize);
}
widget.showNormal();
QTest::qWait(10);
if (expectedWindowState != Qt::WindowNoState) {
// restoring from maximized or fullscreen, we can only restore to the normal geometry
QTRY_COMPARE(widget.geometry(), expectedNormalGeometry);
} else {
QTRY_COMPARE(widget.pos(), expectedPosition);
QTRY_COMPARE(widget.size(), expectedSize);
}
#if 0
// Code for saving a new geometry*.dat files
{
QWidget widgetToSave;
widgetToSave.move(expectedPosition);
widgetToSave.resize(expectedSize);
widgetToSave.show();
#ifdef Q_WS_X11
qt_x11_wait_for_window_manager(&widget);
#endif
QTest::qWait(500); // stabilize
widgetToSave.setWindowState(Qt::WindowStates(expectedWindowState));
QTest::qWait(500); // stabilize
QByteArray geometryToSave = widgetToSave.saveGeometry();
// Code for saving a new geometry.dat file.
f.setFileName(fileName.mid(1));
QVERIFY(f.open(QIODevice::WriteOnly)); // did you forget to 'p4 edit *.dat'? :)
f.write(geometryToSave);
f.close();
}
#endif
}
void tst_QWidget::widgetAt()
{
Q_CHECK_PAINTEVENTS
QWidget *w1 = new QWidget(0, Qt::X11BypassWindowManagerHint);
w1->setGeometry(0,0,150,150);
w1->setObjectName("w1");
QWidget *w2 = new QWidget(0, Qt::X11BypassWindowManagerHint | Qt::FramelessWindowHint);
w2->setGeometry(50,50,100,100);
w2->setObjectName("w2");
w1->show();
QTest::qWaitForWindowShown(w1);
qApp->processEvents();
QWidget *wr;
QTRY_VERIFY((wr = QApplication::widgetAt(100, 100)));
QCOMPARE(wr->objectName(), QString("w1"));
w2->show();
QTest::qWaitForWindowShown(w2);
qApp->processEvents();
qApp->processEvents();
qApp->processEvents();
QTRY_VERIFY((wr = QApplication::widgetAt(100, 100)));
QCOMPARE(wr->objectName(), QString("w2"));
w2->lower();
qApp->processEvents();
QTRY_VERIFY((wr = QApplication::widgetAt(100, 100)));
const bool match = (wr->objectName() == QString("w1"));
w2->raise();
QVERIFY(match);
qApp->processEvents();
QTRY_VERIFY((wr = QApplication::widgetAt(100, 100)));
QCOMPARE(wr->objectName(), QString("w2"));
QWidget *w3 = new QWidget(w2);
w3->setGeometry(10,10,50,50);
w3->setObjectName("w3");
w3->show();
qApp->processEvents();
QTRY_VERIFY((wr = QApplication::widgetAt(100,100)));
QCOMPARE(wr->objectName(), QString("w3"));
w3->setAttribute(Qt::WA_TransparentForMouseEvents);
qApp->processEvents();
QTRY_VERIFY((wr = QApplication::widgetAt(100, 100)));
QCOMPARE(wr->objectName(), QString("w2"));
QRegion rgn = QRect(QPoint(0,0), w2->size());
QPoint point = w2->mapFromGlobal(QPoint(100,100));
rgn -= QRect(point, QSize(1,1));
w2->setMask(rgn);
qApp->processEvents();
QTest::qWait(10);
#if defined(Q_OS_WINCE)
QEXPECT_FAIL("", "Windows CE does only support rectangular regions", Continue); //See also task 147191
#endif
#if defined(Q_OS_SYMBIAN)
QEXPECT_FAIL("", "Symbian/S60 does only support rectangular regions", Continue); //See also task 147191
#endif
#if defined(Q_WS_QPA)
QEXPECT_FAIL("", "Window mask not implemented on Lighthouse", Continue);
#endif
QTRY_COMPARE(QApplication::widgetAt(100,100)->objectName(), w1->objectName());
QTRY_COMPARE(QApplication::widgetAt(101,101)->objectName(), w2->objectName());
QBitmap bitmap(w2->size());
QPainter p(&bitmap);
p.fillRect(bitmap.rect(), Qt::color1);
p.setPen(Qt::color0);
p.drawPoint(w2->mapFromGlobal(QPoint(100,100)));
p.end();
w2->setMask(bitmap);
qApp->processEvents();
QTest::qWait(10);
#if defined(Q_OS_WINCE)
QEXPECT_FAIL("", "Windows CE does only support rectangular regions", Continue); //See also task 147191
#endif
#if defined(Q_OS_SYMBIAN)
QEXPECT_FAIL("", "Symbian/S60 does only support rectangular regions", Continue); //See also task 147191
#endif
#if defined(Q_WS_QPA)
QEXPECT_FAIL("", "Window mask not implemented on Lighthouse", Continue);
#endif
QTRY_VERIFY(QApplication::widgetAt(100,100) == w1);
QTRY_VERIFY(QApplication::widgetAt(101,101) == w2);
delete w2;
delete w1;
}
#if defined(Q_WS_X11)
bool getProperty(Display *display, Window target, Atom type, Atom property,
unsigned char** data, unsigned long* count)
{
Atom atom_return;
int size;
unsigned long nitems, bytes_left;
int ret = XGetWindowProperty(display, target, property,
0l, 1l, false,
type, &atom_return, &size,
&nitems, &bytes_left, data);
if (ret != Success || nitems < 1)
return false;
if (bytes_left != 0) {
XFree(*data);
unsigned long remain = ((size / 8) * nitems) + bytes_left;
ret = XGetWindowProperty(display, target,
property, 0l, remain, false,
type, &atom_return, &size,
&nitems, &bytes_left, data);
if (ret != Success)
return false;
}
*count = nitems;
return true;
}
QString textPropertyToString(Display *display, XTextProperty& text_prop)
{
QString ret;
if (text_prop.value && text_prop.nitems > 0) {
if (text_prop.encoding == XA_STRING) {
ret = reinterpret_cast<char *>(text_prop.value);
} else {
text_prop.nitems = strlen(reinterpret_cast<char *>(text_prop.value));
char **list;
int num;
if (XmbTextPropertyToTextList(display, &text_prop, &list, &num) == Success
&& num > 0 && *list) {
ret = QString::fromLocal8Bit(*list);
XFreeStringList(list);
}
}
}
return ret;
}
#endif
#if defined(Q_WS_S60)
// Returns the application's status pane control, if not present returns NULL.
static CCoeControl* GetStatusPaneControl( TInt aPaneId )
{
const TUid paneUid = { aPaneId };
CEikStatusPane* statusPane = CEikonEnv::Static()->AppUiFactory()->StatusPane();
if (statusPane && statusPane->PaneCapabilities(paneUid).IsPresent()){
CCoeControl* control = NULL;
// ControlL shouldn't leave because the pane is present
TRAPD(err, control = statusPane->ControlL(paneUid));
return err != KErrNone ? NULL : control;
}
return NULL;
}
// Returns the application's title pane, if not present returns NULL.
static CAknTitlePane* TitlePane()
{
return static_cast<CAknTitlePane*>(GetStatusPaneControl(EEikStatusPaneUidTitle));
}
// Returns the application's title pane, if not present returns NULL.
static CAknContextPane* ContextPane()
{
return static_cast<CAknContextPane*>(GetStatusPaneControl(EEikStatusPaneUidContext));
}
#endif
static QString visibleWindowTitle(QWidget *window, Qt::WindowState state = Qt::WindowNoState)
{
QString vTitle;
#ifdef Q_WS_WIN
Q_UNUSED(state);
const size_t maxTitleLength = 256;
wchar_t title[maxTitleLength];
GetWindowText(window->winId(), title, maxTitleLength);
vTitle = QString::fromWCharArray(title);
#elif defined(Q_WS_X11)
/*
We can't check what the window manager displays, but we can
check what we tell the window manager to display. This will
have to do.
*/
Atom UTF8_STRING = XInternAtom(window->x11Info().display(), "UTF8_STRING", false);
Atom _NET_WM_NAME = XInternAtom(window->x11Info().display(), "_NET_WM_NAME", false);
Atom _NET_WM_ICON_NAME = XInternAtom(window->x11Info().display(), "_NET_WM_ICON_NAME", false);
uchar *data = 0;
ulong length = 0;
if (state == Qt::WindowMinimized) {
if (getProperty(window->x11Info().display(), window->winId(),
UTF8_STRING, _NET_WM_ICON_NAME, &data, &length)) {
vTitle = QString::fromUtf8((char *) data, length);
XFree(data);
} else {
XTextProperty text_prop;
if (XGetWMIconName(window->x11Info().display(), window->winId(), &text_prop)) {
vTitle = textPropertyToString(window->x11Info().display(), text_prop);
XFree((char *) text_prop.value);
}
}
} else {
if (getProperty(window->x11Info().display(), window->winId(),
UTF8_STRING, _NET_WM_NAME, &data, &length)) {
vTitle = QString::fromUtf8((char *) data, length);
XFree(data);
} else {
XTextProperty text_prop;
if (XGetWMName(window->x11Info().display(), window->winId(), &text_prop)) {
vTitle = textPropertyToString(window->x11Info().display(), text_prop);
XFree((char *) text_prop.value);
}
}
}
#elif defined(Q_WS_MAC)
vTitle = nativeWindowTitle(window, state);
#elif defined(Q_WS_QWS)
if (qwsServer) {
const QWSWindow *win = 0;
const QList<QWSWindow*> windows = qwsServer->clientWindows();
for (int i = 0; i < windows.count(); ++i) {
const QWSWindow* w = windows.at(i);
if (w->winId() == window->winId()) {
win = w;
break;
}
}
if (win)
vTitle = win->caption();
}
#elif defined (Q_WS_S60)
CAknTitlePane* titlePane = TitlePane();
if(titlePane)
{
const TDesC* nTitle = titlePane->Text();
vTitle = QString::fromUtf16(nTitle->Ptr(), nTitle->Length());
}
#endif
return vTitle;
}
void tst_QWidget::windowTitle()
{
QWidget widget(0);
widget.setWindowTitle("Application Name");
widget.winId(); // Make sure the window is created...
QCOMPARE(visibleWindowTitle(&widget), QString("Application Name"));
widget.setWindowTitle("Application Name *");
QCOMPARE(visibleWindowTitle(&widget), QString("Application Name *"));
widget.setWindowTitle("Application Name[*]");
QCOMPARE(visibleWindowTitle(&widget), QString("Application Name"));
widget.setWindowTitle("Application Name[*][*]");
QCOMPARE(visibleWindowTitle(&widget), QString("Application Name[*]"));
widget.setWindowTitle("Application Name[*][*][*]");
QCOMPARE(visibleWindowTitle(&widget), QString("Application Name[*]"));
widget.setWindowTitle("Application Name[*][*][*][*]");
QCOMPARE(visibleWindowTitle(&widget), QString("Application Name[*][*]"));
}
void tst_QWidget::windowIconText()
{
#ifdef Q_OS_SYMBIAN
QSKIP("Symbian/S60 windows don't have window icon text", SkipAll);
#endif
QWidget widget(0);
widget.setWindowTitle("Application Name");
widget.setWindowIconText("Application Minimized");
widget.showNormal();
QCOMPARE(visibleWindowTitle(&widget), QString("Application Name"));
widget.showMinimized();
#if defined(Q_WS_QWS) || defined(Q_OS_WINCE)
QEXPECT_FAIL(0, "Qt/Embedded/WinCE does not implement showMinimized()", Continue);
//See task 147193 for WinCE
#endif
QApplication::instance()->processEvents();
QCOMPARE(visibleWindowTitle(&widget, Qt::WindowMinimized),
QString("Application Minimized"));
widget.setWindowTitle("Application Name[*]");
widget.setWindowIconText("Application Minimized[*]");
widget.showNormal();
QApplication::instance()->processEvents();
QCOMPARE(visibleWindowTitle(&widget), QString("Application Name"));
widget.showMinimized();
#if defined (Q_WS_QWS) || defined(Q_OS_WINCE)
QEXPECT_FAIL(0, "Qt/Embedded/WinCE does not implement showMinimized()", Continue);
//See task 147193 for WinCE
#endif
QApplication::instance()->processEvents();
QCOMPARE(visibleWindowTitle(&widget, Qt::WindowMinimized),
QString("Application Minimized"));
widget.setWindowModified(true);
widget.showNormal();
QApplication::instance()->processEvents();
if (widget.style()->styleHint(QStyle::SH_TitleBar_ModifyNotification, 0, &widget))
QCOMPARE(visibleWindowTitle(&widget), QString("Application Name*"));
else
QCOMPARE(visibleWindowTitle(&widget), QString("Application Name"));
widget.showMinimized();
#if defined (Q_WS_QWS) || defined(Q_OS_WINCE)
QEXPECT_FAIL(0, "Qt/Embedded/WinCE does not implement showMinimized()", Continue);
//See task 147193 for WinCE
#endif
QApplication::instance()->processEvents();
#ifdef Q_WS_MAC
QCOMPARE(visibleWindowTitle(&widget, Qt::WindowMinimized),
QString("Application Minimized"));
QVERIFY(nativeWindowModified(&widget));
#else
QCOMPARE(visibleWindowTitle(&widget, Qt::WindowMinimized),
QString("Application Minimized*"));
#endif
}
void tst_QWidget::windowModified()
{
QWidget widget(0);
widget.show();
QTest::qWaitForWindowShown(&widget);
#ifndef Q_WS_MAC
QTest::ignoreMessage(QtWarningMsg, "QWidget::setWindowModified: The window title does not contain a '[*]' placeholder");
#endif
widget.setWindowTitle("Application Name");
QTest::qWait(10);
QTRY_COMPARE(visibleWindowTitle(&widget), QString("Application Name"));
#ifdef Q_WS_MAC
widget.setWindowModified(true);
QVERIFY(nativeWindowModified(&widget));
#else
widget.setWindowModified(true);
QApplication::instance()->processEvents();
QCOMPARE(visibleWindowTitle(&widget), QString("Application Name"));
widget.setWindowModified(false);
QApplication::instance()->processEvents();
QCOMPARE(visibleWindowTitle(&widget), QString("Application Name"));
widget.setWindowTitle("Application Name[*]");
widget.setWindowModified(true);
QApplication::instance()->processEvents();
if (widget.style()->styleHint(QStyle::SH_TitleBar_ModifyNotification, 0, &widget))
QCOMPARE(visibleWindowTitle(&widget), QString("Application Name*"));
else
QCOMPARE(visibleWindowTitle(&widget), QString("Application Name"));
widget.setWindowModified(false);
QApplication::instance()->processEvents();
QCOMPARE(visibleWindowTitle(&widget), QString("Application Name"));
widget.setWindowTitle("Application[*] Name[*]");
widget.setWindowModified(true);
QApplication::instance()->processEvents();
QCOMPARE(visibleWindowTitle(&widget), QString("Application* Name*"));
widget.setWindowModified(false);
QApplication::instance()->processEvents();
QCOMPARE(visibleWindowTitle(&widget), QString("Application Name"));
widget.setWindowTitle("Application Name[*][*]");
widget.setWindowModified(true);
QApplication::instance()->processEvents();
QCOMPARE(visibleWindowTitle(&widget), QString("Application Name[*]"));
widget.setWindowModified(false);
QApplication::instance()->processEvents();
QCOMPARE(visibleWindowTitle(&widget), QString("Application Name[*]"));
widget.setWindowTitle("Application[*][*] Name[*][*]");
widget.setWindowModified(true);
QApplication::instance()->processEvents();
QCOMPARE(visibleWindowTitle(&widget), QString("Application[*] Name[*]"));
widget.setWindowModified(false);
QApplication::instance()->processEvents();
QCOMPARE(visibleWindowTitle(&widget), QString("Application[*] Name[*]"));
widget.setWindowTitle("Application[*] Name[*][*][*]");
widget.setWindowModified(true);
QApplication::instance()->processEvents();
QCOMPARE(visibleWindowTitle(&widget), QString("Application* Name[*]*"));
widget.setWindowModified(false);
QApplication::instance()->processEvents();
QCOMPARE(visibleWindowTitle(&widget), QString("Application Name[*]"));
widget.setWindowTitle("Application[*][*][*] Name[*][*][*]");
widget.setWindowModified(true);
QApplication::instance()->processEvents();
QCOMPARE(visibleWindowTitle(&widget), QString("Application[*]* Name[*]*"));
widget.setWindowModified(false);
QApplication::instance()->processEvents();
QCOMPARE(visibleWindowTitle(&widget), QString("Application[*] Name[*]"));
#endif
}
void tst_QWidget::task110173()
{
QWidget w;
QPushButton *pb1 = new QPushButton("click", &w);
pb1->setFocusPolicy(Qt::ClickFocus);
pb1->move(100, 100);
QPushButton *pb2 = new QPushButton("push", &w);
pb2->setFocusPolicy(Qt::ClickFocus);
pb2->move(300, 300);
QTest::keyClick( &w, Qt::Key_Tab );
w.show();
QTest::qWaitForWindowShown(&w);
QTest::qWait(200);
}
class Widget : public QWidget
{
public:
Widget() : deleteThis(false) { setFocusPolicy(Qt::StrongFocus); }
void actionEvent(QActionEvent *) { if (deleteThis) delete this; }
void changeEvent(QEvent *) { if (deleteThis) delete this; }
void closeEvent(QCloseEvent *) { if (deleteThis) delete this; }
void hideEvent(QHideEvent *) { if (deleteThis) delete this; }
void focusOutEvent(QFocusEvent *) { if (deleteThis) delete this; }
void keyPressEvent(QKeyEvent *) { if (deleteThis) delete this; }
void keyReleaseEvent(QKeyEvent *) { if (deleteThis) delete this; }
void mouseDoubleClickEvent(QMouseEvent *) { if (deleteThis) delete this; }
void mousePressEvent(QMouseEvent *) { if (deleteThis) delete this; }
void mouseReleaseEvent(QMouseEvent *) { if (deleteThis) delete this; }
void mouseMoveEvent(QMouseEvent *) { if (deleteThis) delete this; }
bool deleteThis;
};
void tst_QWidget::testDeletionInEventHandlers()
{
// closeEvent
QPointer<Widget> w = new Widget;
w->deleteThis = true;
w->close();
QVERIFY(w == 0);
delete w;
// focusOut (crashes)
//w = new Widget;
//w->show();
//w->setFocus();
//QVERIFY(qApp->focusWidget() == w);
//w->deleteThis = true;
//w->clearFocus();
//QVERIFY(w == 0);
// key press
w = new Widget;
w->show();
w->deleteThis = true;
QTest::keyPress(w, Qt::Key_A);
QVERIFY(w == 0);
delete w;
// key release
w = new Widget;
w->show();
w->deleteThis = true;
QTest::keyRelease(w, Qt::Key_A);
QVERIFY(w == 0);
delete w;
// mouse press
w = new Widget;
w->show();
w->deleteThis = true;
QTest::mousePress(w, Qt::LeftButton);
QVERIFY(w == 0);
delete w;
// mouse release
w = new Widget;
w->show();
w->deleteThis = true;
QTest::mouseRelease(w, Qt::LeftButton);
QVERIFY(w == 0);
delete w;
// mouse double click
w = new Widget;
w->show();
w->deleteThis = true;
QTest::mouseDClick(w, Qt::LeftButton);
QVERIFY(w == 0);
delete w;
// hide event (crashes)
//w = new Widget;
//w->show();
//w->deleteThis = true;
//w->hide();
//QVERIFY(w == 0);
// action event
w = new Widget;
w->deleteThis = true;
w->addAction(new QAction(w));
QVERIFY(w == 0);
delete w;
// change event
w = new Widget;
w->show();
w->deleteThis = true;
w->setMouseTracking(true);
QVERIFY(w == 0);
delete w;
w = new Widget;
w->setMouseTracking(true);
w->show();
w->deleteThis = true;
QMouseEvent me(QEvent::MouseMove, QPoint(0, 0), Qt::NoButton, Qt::NoButton, Qt::NoModifier);
QApplication::sendEvent(w, &me);
QVERIFY(w == 0);
delete w;
}
#ifdef Q_WS_MAC
/*
Test that retaining and releasing the HIView returned by QWidget::winId()
works even if the widget itself is deleted.
*/
void tst_QWidget::retainHIView()
{
// Single window
{
const WidgetViewPair window = createAndRetain();
delete window.first;
QVERIFY(testAndRelease(window.second));
}
// Child widget
{
const WidgetViewPair parent = createAndRetain();
const WidgetViewPair child = createAndRetain(parent.first);
delete parent.first;
QVERIFY(testAndRelease(parent.second));
QVERIFY(testAndRelease(child.second));
}
// Multiple children
{
const WidgetViewPair parent = createAndRetain();
const WidgetViewPair child1 = createAndRetain(parent.first);
const WidgetViewPair child2 = createAndRetain(parent.first);
delete parent.first;
QVERIFY(testAndRelease(parent.second));
QVERIFY(testAndRelease(child1.second));
QVERIFY(testAndRelease(child2.second));
}
// Grandchild widget
{
const WidgetViewPair parent = createAndRetain();
const WidgetViewPair child = createAndRetain(parent.first);
const WidgetViewPair grandchild = createAndRetain(child.first);
delete parent.first;
QVERIFY(testAndRelease(parent.second));
QVERIFY(testAndRelease(child.second));
QVERIFY(testAndRelease(grandchild.second));
}
// Reparent child widget
{
const WidgetViewPair parent1 = createAndRetain();
const WidgetViewPair parent2 = createAndRetain();
const WidgetViewPair child = createAndRetain(parent1.first);
child.first->setParent(parent2.first);
delete parent1.first;
QVERIFY(testAndRelease(parent1.second));
delete parent2.first;
QVERIFY(testAndRelease(parent2.second));
QVERIFY(testAndRelease(child.second));
}
// Reparent window
{
const WidgetViewPair window1 = createAndRetain();
const WidgetViewPair window2 = createAndRetain();
const WidgetViewPair child1 = createAndRetain(window1.first);
const WidgetViewPair child2 = createAndRetain(window2.first);
window2.first->setParent(window1.first);
delete window2.first;
QVERIFY(testAndRelease(window2.second));
QVERIFY(testAndRelease(child2.second));
delete window1.first;
QVERIFY(testAndRelease(window1.second));
QVERIFY(testAndRelease(child1.second));
}
// Delete child widget
{
const WidgetViewPair parent = createAndRetain();
const WidgetViewPair child = createAndRetain(parent.first);
delete child.first;
QVERIFY(testAndRelease(child.second));
delete parent.first;
QVERIFY(testAndRelease(parent.second));
}
}
void tst_QWidget::sheetOpacity()
{
QWidget tmpWindow;
QWidget sheet(&tmpWindow, Qt::Sheet);
tmpWindow.show();
sheet.show();
QCOMPARE(int(sheet.windowOpacity() * 255), 242); // 95%
sheet.setParent(0, Qt::Dialog);
QCOMPARE(int(sheet.windowOpacity() * 255), 255);
}
class MaskedPainter : public QWidget
{
public:
QRect mask;
MaskedPainter()
: mask(20, 20, 50, 50)
{
setMask(mask);
}
void paintEvent(QPaintEvent *)
{
QPainter p(this);
p.fillRect(mask, QColor(Qt::red));
}
};
/*
Verifies that the entire area inside the mask is painted red.
*/
bool verifyWidgetMask(QWidget *widget, QRect mask)
{
const QImage image = QPixmap::grabWindow(widget->winId()).toImage();
const QImage masked = image.copy(mask);
QImage red(masked);
red.fill(QColor(Qt::red).rgb());
return (masked == red);
}
void tst_QWidget::setMask()
{
testWidget->hide(); // get this out of the way.
{
MaskedPainter w;
w.resize(200, 200);
w.show();
QTest::qWait(100);
QVERIFY(verifyWidgetMask(&w, w.mask));
}
{
MaskedPainter w;
w.resize(200, 200);
w.setWindowFlags(w.windowFlags() | Qt::FramelessWindowHint);
w.show();
QTest::qWait(100);
QRect mask = w.mask;
QVERIFY(verifyWidgetMask(&w, mask));
}
}
#endif
class StaticWidget : public QWidget
{
Q_OBJECT
public:
bool partial;
bool gotPaintEvent;
QRegion paintedRegion;
StaticWidget(QWidget *parent = 0)
:QWidget(parent)
{
setAttribute(Qt::WA_StaticContents);
setAttribute(Qt::WA_OpaquePaintEvent);
setPalette(Qt::red); // Make sure we have an opaque palette.
setAutoFillBackground(true);
gotPaintEvent = false;
}
void paintEvent(QPaintEvent *e)
{
paintedRegion += e->region();
gotPaintEvent = true;
// qDebug() << "paint" << e->region();
// Look for a full update, set partial to false if found.
foreach(QRect r, e->region().rects()) {
partial = (r != rect());
if (partial == false)
break;
}
}
};
/*
Test that widget resizes and moves can be done with minimal repaints when WA_StaticContents
and WA_OpaquePaintEvent is set. Test is mac-only for now.
*/
void tst_QWidget::optimizedResizeMove()
{
QWidget parent;
parent.resize(400, 400);
StaticWidget staticWidget(&parent);
staticWidget.gotPaintEvent = false;
staticWidget.move(150, 150);
staticWidget.resize(150, 150);
parent.show();
QTest::qWaitForWindowShown(&parent);
QTest::qWait(20);
QTRY_COMPARE(staticWidget.gotPaintEvent, true);
staticWidget.gotPaintEvent = false;
staticWidget.move(staticWidget.pos() + QPoint(10, 10));
QTest::qWait(20);
QCOMPARE(staticWidget.gotPaintEvent, false);
staticWidget.gotPaintEvent = false;
staticWidget.move(staticWidget.pos() + QPoint(-10, -10));
QTest::qWait(20);
QCOMPARE(staticWidget.gotPaintEvent, false);
staticWidget.gotPaintEvent = false;
staticWidget.move(staticWidget.pos() + QPoint(-10, 10));
QTest::qWait(20);
QCOMPARE(staticWidget.gotPaintEvent, false);
staticWidget.gotPaintEvent = false;
staticWidget.resize(staticWidget.size() + QSize(10, 10));
QTest::qWait(20);
QCOMPARE(staticWidget.gotPaintEvent, true);
QCOMPARE(staticWidget.partial, true);
staticWidget.gotPaintEvent = false;
staticWidget.resize(staticWidget.size() + QSize(-10, -10));
QTest::qWait(20);
QCOMPARE(staticWidget.gotPaintEvent, false);
staticWidget.gotPaintEvent = false;
staticWidget.resize(staticWidget.size() + QSize(10, -10));
QTest::qWait(20);
QCOMPARE(staticWidget.gotPaintEvent, true);
QCOMPARE(staticWidget.partial, true);
staticWidget.gotPaintEvent = false;
staticWidget.move(staticWidget.pos() + QPoint(10, 10));
staticWidget.resize(staticWidget.size() + QSize(-10, -10));
QTest::qWait(20);
QCOMPARE(staticWidget.gotPaintEvent, false);
staticWidget.gotPaintEvent = false;
staticWidget.move(staticWidget.pos() + QPoint(10, 10));
staticWidget.resize(staticWidget.size() + QSize(10, 10));
QTest::qWait(20);
QCOMPARE(staticWidget.gotPaintEvent, true);
QCOMPARE(staticWidget.partial, true);
staticWidget.gotPaintEvent = false;
staticWidget.move(staticWidget.pos() + QPoint(-10, -10));
staticWidget.resize(staticWidget.size() + QSize(-10, -10));
QTest::qWait(20);
QCOMPARE(staticWidget.gotPaintEvent, false);
staticWidget.setAttribute(Qt::WA_StaticContents, false);
staticWidget.gotPaintEvent = false;
staticWidget.move(staticWidget.pos() + QPoint(-10, -10));
staticWidget.resize(staticWidget.size() + QSize(-10, -10));
QTest::qWait(20);
QCOMPARE(staticWidget.gotPaintEvent, true);
QCOMPARE(staticWidget.partial, false);
staticWidget.setAttribute(Qt::WA_StaticContents, true);
staticWidget.setAttribute(Qt::WA_StaticContents, false);
staticWidget.gotPaintEvent = false;
staticWidget.move(staticWidget.pos() + QPoint(10, 10));
QTest::qWait(20);
QCOMPARE(staticWidget.gotPaintEvent, false);
staticWidget.setAttribute(Qt::WA_StaticContents, true);
}
void tst_QWidget::optimizedResize_topLevel()
{
#if defined(Q_WS_MAC) || defined(Q_WS_QWS)
QSKIP("We do not yet have static contents support for *top-levels* on this platform", SkipAll);
#endif
StaticWidget topLevel;
topLevel.gotPaintEvent = false;
topLevel.show();
QTest::qWaitForWindowShown(&topLevel);
QTest::qWait(10);
QTRY_COMPARE(topLevel.gotPaintEvent, true);
topLevel.gotPaintEvent = false;
topLevel.partial = false;
topLevel.paintedRegion = QRegion();
#ifndef Q_WS_WIN
topLevel.resize(topLevel.size() + QSize(10, 10));
#else
// Static contents does not work when programmatically resizing
// top-levels with QWidget::resize. We do some funky stuff in
// setGeometry_sys. However, resizing it with the mouse or with
// a native function call works (it basically has to go through
// WM_RESIZE in QApplication). This is a corner case, though.
// See task 243708
const QRect frame = topLevel.frameGeometry();
MoveWindow(topLevel.winId(), frame.x(), frame.y(),
frame.width() + 10, frame.height() + 10,
true);
#endif
QTest::qWait(100);
// Expected update region: New rect - old rect.
QRegion expectedUpdateRegion(topLevel.rect());
expectedUpdateRegion -= QRect(QPoint(), topLevel.size() - QSize(10, 10));
QTRY_COMPARE(topLevel.gotPaintEvent, true);
QCOMPARE(topLevel.partial, true);
QCOMPARE(topLevel.paintedRegion, expectedUpdateRegion);
}
class SiblingDeleter : public QWidget
{
public:
inline SiblingDeleter(QWidget *sibling, QWidget *parent)
: QWidget(parent), sibling(sibling) {}
inline virtual ~SiblingDeleter() { delete sibling; }
private:
QPointer<QWidget> sibling;
};
void tst_QWidget::childDeletesItsSibling()
{
QWidget *commonParent = new QWidget(0);
QPointer<QWidget> child = new QWidget(0);
QPointer<QWidget> siblingDeleter = new SiblingDeleter(child, commonParent);
child->setParent(commonParent);
delete commonParent; // don't crash
QVERIFY(!child);
QVERIFY(!siblingDeleter);
}
#ifdef Q_WS_QWS
# define SET_SAFE_SIZE(w) \
do { \
QSize safeSize(qt_screen->width() - 250, qt_screen->height() - 250); \
if (!safeSize.isValid()) \
QSKIP("Screen size too small", SkipAll); \
if (defaultSize.width() > safeSize.width() || defaultSize.height() > safeSize.height()) { \
defaultSize = safeSize; \
w.resize(defaultSize); \
w.setAttribute(Qt::WA_Resized, false); \
} \
} while (false)
#else
# define SET_SAFE_SIZE(w)
#endif
void tst_QWidget::setMinimumSize()
{
QWidget w;
QSize defaultSize = w.size();
SET_SAFE_SIZE(w);
w.setMinimumSize(defaultSize + QSize(100, 100));
QCOMPARE(w.size(), defaultSize + QSize(100, 100));
QVERIFY(!w.testAttribute(Qt::WA_Resized));
w.setMinimumSize(defaultSize + QSize(50, 50));
QCOMPARE(w.size(), defaultSize + QSize(100, 100));
QVERIFY(!w.testAttribute(Qt::WA_Resized));
w.setMinimumSize(defaultSize + QSize(200, 200));
QCOMPARE(w.size(), defaultSize + QSize(200, 200));
QVERIFY(!w.testAttribute(Qt::WA_Resized));
#ifdef Q_OS_WINCE
QSKIP("Setting a minimum size larger than the desktop does not work", SkipAll);
#endif
QSize nonDefaultSize = defaultSize + QSize(5,5);
w.setMinimumSize(nonDefaultSize);
w.show();
QTest::qWait(50);
QVERIFY(w.height() >= nonDefaultSize.height());
QVERIFY(w.width() >= nonDefaultSize.width());
}
void tst_QWidget::setMaximumSize()
{
QWidget w;
QSize defaultSize = w.size();
SET_SAFE_SIZE(w);
w.setMinimumSize(defaultSize + QSize(100, 100));
QCOMPARE(w.size(), defaultSize + QSize(100, 100));
QVERIFY(!w.testAttribute(Qt::WA_Resized));
w.setMinimumSize(defaultSize);
w.setMaximumSize(defaultSize + QSize(200, 200));
QCOMPARE(w.size(), defaultSize + QSize(100, 100));
QVERIFY(!w.testAttribute(Qt::WA_Resized));
w.setMaximumSize(defaultSize + QSize(50, 50));
QCOMPARE(w.size(), defaultSize + QSize(50, 50));
QVERIFY(!w.testAttribute(Qt::WA_Resized));
#if 0
//we don't enforce maximum size on show, apparently
QSize nonDefaultSize = defaultSize - QSize(5,5);
w.setMaximumSize(nonDefaultSize);
w.show();
QTest::qWait(50);
qDebug() << nonDefaultSize << w.size();
QVERIFY(w.height() <= nonDefaultSize.height());
QVERIFY(w.width() <= nonDefaultSize.width());
#endif
}
void tst_QWidget::setFixedSize()
{
QWidget w;
QSize defaultSize = w.size();
SET_SAFE_SIZE(w);
w.setFixedSize(defaultSize + QSize(100, 100));
QCOMPARE(w.size(), defaultSize + QSize(100, 100));
QVERIFY(w.testAttribute(Qt::WA_Resized));
w.setFixedSize(defaultSize + QSize(200, 200));
QCOMPARE(w.minimumSize(), defaultSize + QSize(200,200));
QCOMPARE(w.maximumSize(), defaultSize + QSize(200,200));
QCOMPARE(w.size(), defaultSize + QSize(200, 200));
QVERIFY(w.testAttribute(Qt::WA_Resized));
w.setFixedSize(defaultSize + QSize(50, 50));
QCOMPARE(w.size(), defaultSize + QSize(50, 50));
QVERIFY(w.testAttribute(Qt::WA_Resized));
w.setAttribute(Qt::WA_Resized, false);
w.setFixedSize(defaultSize + QSize(50, 50));
QVERIFY(!w.testAttribute(Qt::WA_Resized));
w.setFixedSize(defaultSize + QSize(150, 150));
w.show();
QTest::qWait(50);
QVERIFY(w.size() == defaultSize + QSize(150,150));
}
void tst_QWidget::ensureCreated()
{
{
QWidget widget;
WId widgetWinId = widget.winId();
Q_UNUSED(widgetWinId);
QVERIFY(widget.testAttribute(Qt::WA_WState_Created));
}
{
QWidget window;
QDialog dialog(&window);
dialog.setWindowModality(Qt::NonModal);
WId dialogWinId = dialog.winId();
Q_UNUSED(dialogWinId);
QVERIFY(dialog.testAttribute(Qt::WA_WState_Created));
QVERIFY(window.testAttribute(Qt::WA_WState_Created));
}
{
QWidget window;
QDialog dialog(&window);
dialog.setWindowModality(Qt::WindowModal);
WId dialogWinId = dialog.winId();
Q_UNUSED(dialogWinId);
QVERIFY(dialog.testAttribute(Qt::WA_WState_Created));
QVERIFY(window.testAttribute(Qt::WA_WState_Created));
}
{
QWidget window;
QDialog dialog(&window);
dialog.setWindowModality(Qt::ApplicationModal);
WId dialogWinId = dialog.winId();
Q_UNUSED(dialogWinId);
QVERIFY(dialog.testAttribute(Qt::WA_WState_Created));
QVERIFY(window.testAttribute(Qt::WA_WState_Created));
}
}
class WinIdChangeWidget : public QWidget {
public:
WinIdChangeWidget(QWidget *p = 0)
: QWidget(p)
{
}
protected:
bool event(QEvent *e)
{
if (e->type() == QEvent::WinIdChange) {
m_winIdList.append(internalWinId());
return true;
}
return QWidget::event(e);
}
public:
QList<WId> m_winIdList;
int winIdChangeEventCount() const { return m_winIdList.count(); }
};
void tst_QWidget::winIdChangeEvent()
{
{
// Transforming an alien widget into a native widget
WinIdChangeWidget widget;
const WId winIdBefore = widget.internalWinId();
const WId winIdAfter = widget.winId();
QVERIFY(winIdBefore != winIdAfter);
QCOMPARE(widget.winIdChangeEventCount(), 1);
}
{
// Changing parent of a native widget
// Should cause winId of child to change, on all platforms
QWidget parent1, parent2;
WinIdChangeWidget child(&parent1);
const WId winIdBefore = child.winId();
QCOMPARE(child.winIdChangeEventCount(), 1);
child.setParent(&parent2);
const WId winIdAfter = child.internalWinId();
QVERIFY(winIdBefore != winIdAfter);
QCOMPARE(child.winIdChangeEventCount(), 3);
// winId is set to zero during reparenting
QVERIFY(0 == child.m_winIdList[1]);
}
{
// Changing grandparent of a native widget
// Should cause winId of grandchild to change only on Symbian
QWidget grandparent1, grandparent2;
QWidget parent(&grandparent1);
WinIdChangeWidget child(&parent);
const WId winIdBefore = child.winId();
QCOMPARE(child.winIdChangeEventCount(), 1);
parent.setParent(&grandparent2);
const WId winIdAfter = child.internalWinId();
#ifdef Q_OS_SYMBIAN
QVERIFY(winIdBefore != winIdAfter);
QVERIFY(winIdAfter != 0);
QCOMPARE(child.winIdChangeEventCount(), 2);
#else
QCOMPARE(winIdBefore, winIdAfter);
QCOMPARE(child.winIdChangeEventCount(), 1);
#endif
}
{
// Changing parent of an alien widget
QWidget parent1, parent2;
WinIdChangeWidget child(&parent1);
const WId winIdBefore = child.internalWinId();
child.setParent(&parent2);
const WId winIdAfter = child.internalWinId();
QCOMPARE(winIdBefore, winIdAfter);
QCOMPARE(child.winIdChangeEventCount(), 0);
}
{
// Making native child widget into a top-level window
QWidget parent;
WinIdChangeWidget child(&parent);
child.winId();
const WId winIdBefore = child.internalWinId();
QCOMPARE(child.winIdChangeEventCount(), 1);
const Qt::WindowFlags flags = child.windowFlags();
child.setWindowFlags(flags | Qt::Window);
const WId winIdAfter = child.internalWinId();
QVERIFY(winIdBefore != winIdAfter);
QCOMPARE(child.winIdChangeEventCount(), 3);
// winId is set to zero during reparenting
QVERIFY(0 == child.m_winIdList[1]);
}
}
#ifdef Q_OS_SYMBIAN
void tst_QWidget::reparentCausesChildWinIdChange()
{
QWidget *parent = new QWidget;
QWidget *w1 = new QWidget;
QWidget *w2 = new QWidget;
QWidget *w3 = new QWidget;
w1->setParent(parent);
w2->setParent(w1);
w3->setParent(w2);
WId winId1 = w1->winId();
WId winId2 = w2->winId();
WId winId3 = w3->winId();
// reparenting causes winIds of the widget being reparented, and all of its children, to change
w1->setParent(0);
QVERIFY(w1->winId() != winId1);
winId1 = w1->winId();
QVERIFY(w2->winId() != winId2);
winId2 = w2->winId();
QVERIFY(w3->winId() != winId3);
winId3 = w3->winId();
w1->setParent(parent);
QVERIFY(w1->winId() != winId1);
winId1 = w1->winId();
QVERIFY(w2->winId() != winId2);
winId2 = w2->winId();
QVERIFY(w3->winId() != winId3);
winId3 = w3->winId();
w2->setParent(0);
QVERIFY(w2->winId() != winId2);
winId2 = w2->winId();
QVERIFY(w3->winId() != winId3);
winId3 = w3->winId();
w2->setParent(parent);
QVERIFY(w2->winId() != winId2);
winId2 = w2->winId();
QVERIFY(w3->winId() != winId3);
winId3 = w3->winId();
w2->setParent(w1);
QVERIFY(w2->winId() != winId2);
winId2 = w2->winId();
QVERIFY(w3->winId() != winId3);
winId3 = w3->winId();
w3->setParent(0);
QVERIFY(w3->winId() != winId3);
winId3 = w3->winId();
w3->setParent(w1);
QVERIFY(w3->winId() != winId3);
winId3 = w3->winId();
w3->setParent(w2);
QVERIFY(w3->winId() != winId3);
winId3 = w3->winId();
delete parent;
}
#else
void tst_QWidget::persistentWinId()
{
QWidget *parent = new QWidget;
QWidget *w1 = new QWidget;
QWidget *w2 = new QWidget;
QWidget *w3 = new QWidget;
w1->setParent(parent);
w2->setParent(w1);
w3->setParent(w2);
WId winId1 = w1->winId();
WId winId2 = w2->winId();
WId winId3 = w3->winId();
// reparenting should change the winId of the widget being reparented, but not of its children
w1->setParent(0);
QVERIFY(w1->winId() != winId1);
winId1 = w1->winId();
QCOMPARE(w2->winId(), winId2);
QCOMPARE(w3->winId(), winId3);
w1->setParent(parent);
QVERIFY(w1->winId() != winId1);
winId1 = w1->winId();
QCOMPARE(w2->winId(), winId2);
QCOMPARE(w3->winId(), winId3);
w2->setParent(0);
QVERIFY(w2->winId() != winId2);
winId2 = w2->winId();
QCOMPARE(w3->winId(), winId3);
w2->setParent(parent);
QVERIFY(w2->winId() != winId2);
winId2 = w2->winId();
QCOMPARE(w3->winId(), winId3);
w2->setParent(w1);
QVERIFY(w2->winId() != winId2);
winId2 = w2->winId();
QCOMPARE(w3->winId(), winId3);
w3->setParent(0);
QVERIFY(w3->winId() != winId3);
winId3 = w3->winId();
w3->setParent(w1);
QVERIFY(w3->winId() != winId3);
winId3 = w3->winId();
w3->setParent(w2);
QVERIFY(w3->winId() != winId3);
winId3 = w3->winId();
delete parent;
}
#endif // Q_OS_SYMBIAN
void tst_QWidget::showNativeChild()
{
QWidget topLevel;
topLevel.setGeometry(0, 0, 100, 100);
QWidget child(&topLevel);
child.winId();
topLevel.show();
QTest::qWaitForWindowShown(&topLevel);
}
class ShowHideEventWidget : public QWidget
{
public:
int numberOfShowEvents, numberOfHideEvents;
ShowHideEventWidget(QWidget *parent = 0)
: QWidget(parent), numberOfShowEvents(0), numberOfHideEvents(0)
{ }
void create()
{ QWidget::create(); }
void showEvent(QShowEvent *)
{ ++numberOfShowEvents; }
void hideEvent(QHideEvent *)
{ ++numberOfHideEvents; }
};
void tst_QWidget::showHideEvent_data()
{
QTest::addColumn<bool>("show");
QTest::addColumn<bool>("hide");
QTest::addColumn<bool>("create");
QTest::addColumn<int>("expectedShowEvents");
QTest::addColumn<int>("expectedHideEvents");
QTest::newRow("window: only show")
<< true
<< false
<< false
<< 1
<< 0;
QTest::newRow("window: show/hide")
<< true
<< true
<< false
<< 1
<< 1;
QTest::newRow("window: show/hide/create")
<< true
<< true
<< true
<< 1
<< 1;
QTest::newRow("window: hide/create")
<< false
<< true
<< true
<< 0
<< 0;
QTest::newRow("window: only hide")
<< false
<< true
<< false
<< 0
<< 0;
QTest::newRow("window: nothing")
<< false
<< false
<< false
<< 0
<< 0;
}
void tst_QWidget::showHideEvent()
{
QFETCH(bool, show);
QFETCH(bool, hide);
QFETCH(bool, create);
QFETCH(int, expectedShowEvents);
QFETCH(int, expectedHideEvents);
ShowHideEventWidget widget;
if (show)
widget.show();
if (hide)
widget.hide();
if (create && !widget.testAttribute(Qt::WA_WState_Created))
widget.create();
QCOMPARE(widget.numberOfShowEvents, expectedShowEvents);
QCOMPARE(widget.numberOfHideEvents, expectedHideEvents);
}
void tst_QWidget::update()
{
QTest::qWait(10); // Wait for the initStuff to do it's stuff.
Q_CHECK_PAINTEVENTS
UpdateWidget w;
w.setGeometry(50, 50, 100, 100);
w.show();
QTest::qWaitForWindowShown(&w);
QApplication::processEvents();
QApplication::processEvents();
QTRY_COMPARE(w.numPaintEvents, 1);
QCOMPARE(w.visibleRegion(), QRegion(w.rect()));
QCOMPARE(w.paintedRegion, w.visibleRegion());
w.reset();
UpdateWidget child(&w);
child.setGeometry(10, 10, 80, 80);
child.show();
QPoint childOffset = child.mapToParent(QPoint());
// widgets are transparent by default, so both should get repaints
{
QApplication::processEvents();
QApplication::processEvents();
QCOMPARE(child.numPaintEvents, 1);
QCOMPARE(child.visibleRegion(), QRegion(child.rect()));
QCOMPARE(child.paintedRegion, child.visibleRegion());
QCOMPARE(w.numPaintEvents, 1);
QCOMPARE(w.visibleRegion(), QRegion(w.rect()));
QCOMPARE(w.paintedRegion, child.visibleRegion().translated(childOffset));
w.reset();
child.reset();
w.update();
QApplication::processEvents();
QApplication::processEvents();
QCOMPARE(child.numPaintEvents, 1);
QCOMPARE(child.visibleRegion(), QRegion(child.rect()));
QCOMPARE(child.paintedRegion, child.visibleRegion());
QCOMPARE(w.numPaintEvents, 1);
QCOMPARE(w.visibleRegion(), QRegion(w.rect()));
QCOMPARE(w.paintedRegion, w.visibleRegion());
}
QPalette opaquePalette = child.palette();
opaquePalette.setColor(child.backgroundRole(), QColor(Qt::red));
// setting an opaque background on the child should prevent paint-events
// for the parent in the child area
{
child.setPalette(opaquePalette);
child.setAutoFillBackground(true);
QApplication::processEvents();
w.reset();
child.reset();
w.update();
QApplication::processEvents();
QApplication::processEvents();
QCOMPARE(w.numPaintEvents, 1);
QRegion expectedVisible = QRegion(w.rect())
- child.visibleRegion().translated(childOffset);
QCOMPARE(w.visibleRegion(), expectedVisible);
QCOMPARE(w.paintedRegion, expectedVisible);
#ifdef QT_MAC_USE_COCOA
if (QApplicationPrivate::graphics_system_name != QLatin1String("raster"))
QEXPECT_FAIL(0, "Cocoa compositor says to paint this.", Continue);
#endif
QCOMPARE(child.numPaintEvents, 0);
w.reset();
child.reset();
child.update();
QApplication::processEvents();
QApplication::processEvents();
QCOMPARE(w.numPaintEvents, 0);
QCOMPARE(child.numPaintEvents, 1);
QCOMPARE(child.paintedRegion, child.visibleRegion());
w.reset();
child.reset();
}
// overlapping sibling
UpdateWidget sibling(&w);
child.setGeometry(10, 10, 20, 20);
sibling.setGeometry(15, 15, 20, 20);
sibling.show();
QApplication::processEvents();
w.reset();
child.reset();
sibling.reset();
const QPoint siblingOffset = sibling.mapToParent(QPoint());
sibling.update();
QApplication::processEvents();
QApplication::processEvents();
// child is opaque, sibling transparent
{
QCOMPARE(sibling.numPaintEvents, 1);
QCOMPARE(sibling.paintedRegion, sibling.visibleRegion());
QCOMPARE(child.numPaintEvents, 1);
QCOMPARE(child.paintedRegion.translated(childOffset),
child.visibleRegion().translated(childOffset)
& sibling.visibleRegion().translated(siblingOffset));
QCOMPARE(w.numPaintEvents, 1);
QCOMPARE(w.paintedRegion,
w.visibleRegion() & sibling.visibleRegion().translated(siblingOffset));
QCOMPARE(w.paintedRegion,
(w.visibleRegion() - child.visibleRegion().translated(childOffset))
& sibling.visibleRegion().translated(siblingOffset));
}
w.reset();
child.reset();
sibling.reset();
sibling.setPalette(opaquePalette);
sibling.setAutoFillBackground(true);
sibling.update();
QApplication::processEvents();
QApplication::processEvents();
// child opaque, sibling opaque
{
QCOMPARE(sibling.numPaintEvents, 1);
QCOMPARE(sibling.paintedRegion, sibling.visibleRegion());
#ifdef QT_MAC_USE_COCOA
if (child.internalWinId()) // child is native
QEXPECT_FAIL(0, "Cocoa compositor paints child and sibling", Continue);
#endif
QCOMPARE(child.numPaintEvents, 0);
QCOMPARE(child.visibleRegion(),
QRegion(child.rect())
- sibling.visibleRegion().translated(siblingOffset - childOffset));
QCOMPARE(w.numPaintEvents, 0);
QCOMPARE(w.visibleRegion(),
QRegion(w.rect())
- child.visibleRegion().translated(childOffset)
- sibling.visibleRegion().translated(siblingOffset));
}
}
static inline bool isOpaque(QWidget *widget)
{
if (!widget)
return false;
return qt_widget_private(widget)->isOpaque;
}
void tst_QWidget::isOpaque()
{
#ifndef Q_WS_MAC
QWidget w;
QVERIFY(::isOpaque(&w));
QWidget child(&w);
QVERIFY(!::isOpaque(&child));
child.setAutoFillBackground(true);
QVERIFY(::isOpaque(&child));
QPalette palette;
// background color
palette = child.palette();
palette.setColor(child.backgroundRole(), QColor(255, 0, 0, 127));
child.setPalette(palette);
QVERIFY(!::isOpaque(&child));
palette.setColor(child.backgroundRole(), QColor(255, 0, 0, 255));
child.setPalette(palette);
QVERIFY(::isOpaque(&child));
palette.setColor(QPalette::Window, QColor(0, 0, 255, 127));
w.setPalette(palette);
QVERIFY(!::isOpaque(&w));
child.setAutoFillBackground(false);
QVERIFY(!::isOpaque(&child));
// Qt::WA_OpaquePaintEvent
child.setAttribute(Qt::WA_OpaquePaintEvent);
QVERIFY(::isOpaque(&child));
child.setAttribute(Qt::WA_OpaquePaintEvent, false);
QVERIFY(!::isOpaque(&child));
// Qt::WA_NoSystemBackground
child.setAttribute(Qt::WA_NoSystemBackground);
QVERIFY(!::isOpaque(&child));
child.setAttribute(Qt::WA_NoSystemBackground, false);
QVERIFY(!::isOpaque(&child));
palette.setColor(QPalette::Window, QColor(0, 0, 255, 255));
w.setPalette(palette);
QVERIFY(::isOpaque(&w));
w.setAttribute(Qt::WA_NoSystemBackground);
QVERIFY(!::isOpaque(&w));
w.setAttribute(Qt::WA_NoSystemBackground, false);
QVERIFY(::isOpaque(&w));
{
QPalette palette = QApplication::palette();
QPalette old = palette;
palette.setColor(QPalette::Window, Qt::transparent);
QApplication::setPalette(palette);
QWidget widget;
QVERIFY(!::isOpaque(&widget));
QApplication::setPalette(old);
QCOMPARE(::isOpaque(&widget), old.color(QPalette::Window).alpha() == 255);
}
#endif
}
#ifndef Q_WS_MAC
/*
Test that scrolling of a widget invalidates the correct regions
*/
void tst_QWidget::scroll()
{
UpdateWidget updateWidget;
updateWidget.resize(500, 500);
updateWidget.reset();
updateWidget.show();
QTest::qWaitForWindowShown(&updateWidget);
QTest::qWait(50);
qApp->processEvents();
QTRY_VERIFY(updateWidget.numPaintEvents > 0);
{
updateWidget.reset();
updateWidget.scroll(10, 10);
qApp->processEvents();
QRegion dirty(QRect(0, 0, 500, 10));
dirty += QRegion(QRect(0, 10, 10, 490));
QCOMPARE(updateWidget.paintedRegion, dirty);
}
{
updateWidget.reset();
updateWidget.update(0, 0, 10, 10);
updateWidget.scroll(0, 10);
qApp->processEvents();
QRegion dirty(QRect(0, 0, 500, 10));
dirty += QRegion(QRect(0, 10, 10, 10));
QCOMPARE(updateWidget.paintedRegion, dirty);
}
{
updateWidget.reset();
updateWidget.update(0, 0, 100, 100);
updateWidget.scroll(10, 10, QRect(50, 50, 100, 100));
qApp->processEvents();
QRegion dirty(QRect(0, 0, 100, 50));
dirty += QRegion(QRect(0, 50, 150, 10));
dirty += QRegion(QRect(0, 60, 110, 40));
dirty += QRegion(QRect(50, 100, 60, 10));
dirty += QRegion(QRect(50, 110, 10, 40));
QCOMPARE(updateWidget.paintedRegion, dirty);
}
{
updateWidget.reset();
updateWidget.update(0, 0, 100, 100);
updateWidget.scroll(10, 10, QRect(100, 100, 100, 100));
qApp->processEvents();
QRegion dirty(QRect(0, 0, 100, 100));
dirty += QRegion(QRect(100, 100, 100, 10));
dirty += QRegion(QRect(100, 110, 10, 90));
QCOMPARE(updateWidget.paintedRegion, dirty);
}
}
#endif
class DestroyedSlotChecker : public QObject
{
Q_OBJECT
public:
bool wasQWidget;
DestroyedSlotChecker()
: wasQWidget(false)
{
}
public slots:
void destroyedSlot(QObject *object)
{
wasQWidget = (qobject_cast<QWidget *>(object) != 0 || object->isWidgetType());
}
};
/*
Test that qobject_cast<QWidget*> returns 0 in a slot
connected to QObject::destroyed.
*/
void tst_QWidget::qobject_castInDestroyedSlot()
{
DestroyedSlotChecker checker;
QWidget *widget = new QWidget();
QObject::connect(widget, SIGNAL(destroyed(QObject *)), &checker, SLOT(destroyedSlot(QObject *)));
delete widget;
QVERIFY(checker.wasQWidget == true);
}
Q_DECLARE_METATYPE(QList<QRect>)
void tst_QWidget::setWindowGeometry_data()
{
QTest::addColumn<QList<QRect> >("rects");
QTest::addColumn<int>("windowFlags");
QList<QList<QRect> > rects;
rects << (QList<QRect>()
<< QRect(100, 100, 200, 200)
<< QApplication::desktop()->availableGeometry().adjusted(100, 100, -100, -100)
<< QRect(130, 100, 0, 200)
<< QRect(100, 50, 200, 0)
<< QRect(130, 50, 0, 0))
<< (QList<QRect>()
<< QApplication::desktop()->availableGeometry().adjusted(100, 100, -100, -100)
<< QRect(130, 100, 0, 200)
<< QRect(100, 50, 200, 0)
<< QRect(130, 50, 0, 0)
<< QRect(100, 100, 200, 200))
<< (QList<QRect>()
<< QRect(130, 100, 0, 200)
<< QRect(100, 50, 200, 0)
<< QRect(130, 50, 0, 0)
<< QRect(100, 100, 200, 200)
<< QApplication::desktop()->availableGeometry().adjusted(100, 100, -100, -100))
<< (QList<QRect>()
<< QRect(100, 50, 200, 0)
<< QRect(130, 50, 0, 0)
<< QRect(100, 100, 200, 200)
<< QApplication::desktop()->availableGeometry().adjusted(100, 100, -100, -100)
<< QRect(130, 100, 0, 200))
<< (QList<QRect>()
<< QRect(130, 50, 0, 0)
<< QRect(100, 100, 200, 200)
<< QApplication::desktop()->availableGeometry().adjusted(100, 100, -100, -100)
<< QRect(130, 100, 0, 200)
<< QRect(100, 50, 200, 0));
QList<int> windowFlags;
windowFlags << 0
<< Qt::FramelessWindowHint
#ifdef Q_WS_X11
<< Qt::X11BypassWindowManagerHint
#endif
;
foreach (QList<QRect> l, rects) {
QRect rect = l.first();
foreach (int windowFlag, windowFlags) {
QTest::newRow(QString("%1,%2 %3x%4, flags %5")
.arg(rect.x())
.arg(rect.y())
.arg(rect.width())
.arg(rect.height())
.arg(windowFlag, 0, 16).toAscii())
<< l
<< windowFlag;
}
}
}
void tst_QWidget::setWindowGeometry()
{
#ifdef Q_WS_X11
//Since WindowManager operation are all assync, and we have no way to know if the window
// manager has finished playing with the window geometry, this test can't be reliable.
QSKIP("Window Manager behaviour are too random for this test", SkipAll);
#endif
QFETCH(QList<QRect>, rects);
QFETCH(int, windowFlags);
QRect rect = rects.takeFirst();
{
// test setGeometry() without actually showing the window
QWidget widget;
if (windowFlags != 0)
widget.setWindowFlags(Qt::WindowFlags(windowFlags));
widget.setGeometry(rect);
QTest::qWait(100);
QCOMPARE(widget.geometry(), rect);
// setGeometry() without showing
foreach (QRect r, rects) {
widget.setGeometry(r);
QTest::qWait(100);
QCOMPARE(widget.geometry(), r);
}
}
{
// setGeometry() first, then show()
QWidget widget;
if (windowFlags != 0)
widget.setWindowFlags(Qt::WindowFlags(windowFlags));
widget.setGeometry(rect);
widget.show();
QTest::qWaitForWindowShown(&widget);
QTest::qWait(20);
QTRY_COMPARE(widget.geometry(), rect);
// setGeometry() while shown
foreach (QRect r, rects) {
widget.setGeometry(r);
QTest::qWait(10);
QTRY_COMPARE(widget.geometry(), r);
}
widget.setGeometry(rect);
QTest::qWait(20);
QTRY_COMPARE(widget.geometry(), rect);
// now hide
widget.hide();
QTest::qWait(20);
QTRY_COMPARE(widget.geometry(), rect);
// setGeometry() after hide()
foreach (QRect r, rects) {
widget.setGeometry(r);
QTest::qWait(10);
QTRY_COMPARE(widget.geometry(), r);
}
widget.setGeometry(rect);
QTest::qWait(10);
QTRY_COMPARE(widget.geometry(), rect);
// show() again, geometry() should still be the same
widget.show();
QTest::qWaitForWindowShown(&widget);
QTest::qWait(10);
QTRY_COMPARE(widget.geometry(), rect);
// final hide(), again geometry() should be unchanged
widget.hide();
QTest::qWait(10);
QTRY_COMPARE(widget.geometry(), rect);
}
{
// show() first, then setGeometry()
QWidget widget;
if (windowFlags != 0)
widget.setWindowFlags(Qt::WindowFlags(windowFlags));
widget.show();
QTest::qWaitForWindowShown(&widget);
widget.setGeometry(rect);
QTest::qWait(10);
QTRY_COMPARE(widget.geometry(), rect);
// setGeometry() while shown
foreach (QRect r, rects) {
widget.setGeometry(r);
QTest::qWait(10);
QTRY_COMPARE(widget.geometry(), r);
}
widget.setGeometry(rect);
QTest::qWait(10);
QTRY_COMPARE(widget.geometry(), rect);
// now hide
widget.hide();
QTest::qWait(10);
QTRY_COMPARE(widget.geometry(), rect);
// setGeometry() after hide()
foreach (QRect r, rects) {
widget.setGeometry(r);
QTest::qWait(10);
QTRY_COMPARE(widget.geometry(), r);
}
widget.setGeometry(rect);
QTest::qWait(10);
QTRY_COMPARE(widget.geometry(), rect);
// show() again, geometry() should still be the same
widget.show();
QTest::qWaitForWindowShown(&widget);
QTest::qWait(10);
QTRY_COMPARE(widget.geometry(), rect);
// final hide(), again geometry() should be unchanged
widget.hide();
QTest::qWait(10);
QTRY_COMPARE(widget.geometry(), rect);
}
}
#if defined (Q_WS_WIN) && !defined(Q_OS_WINCE)
void tst_QWidget::setGeometry_win()
{
QWidget widget;
widget.setGeometry(0, 600, 100,100);
widget.show();
widget.setWindowState(widget.windowState() | Qt::WindowMaximized);
QRect geom = widget.normalGeometry();
widget.close();
widget.setGeometry(geom);
widget.setWindowState(widget.windowState() | Qt::WindowMaximized);
widget.show();
RECT rt;
::GetWindowRect(widget.internalWinId(), &rt);
QVERIFY(rt.left <= 0);
QVERIFY(rt.top <= 0);
}
#endif
void tst_QWidget::windowMoveResize_data()
{
setWindowGeometry_data();
}
void tst_QWidget::windowMoveResize()
{
#ifdef Q_WS_X11
//Since WindowManager operation are all assync, and we have no way to know if the window
// manager has finished playing with the window geometry, this test can't be reliable.
QSKIP("Window Manager behaviour are too random for this test", SkipAll);
#endif
#ifdef Q_OS_IRIX
QSKIP("4DWM issues on IRIX makes this test fail", SkipAll);
#endif
QFETCH(QList<QRect>, rects);
QFETCH(int, windowFlags);
QRect rect = rects.takeFirst();
{
// test setGeometry() without actually showing the window
QWidget widget;
if (windowFlags != 0)
widget.setWindowFlags(Qt::WindowFlags(windowFlags));
widget.move(rect.topLeft());
widget.resize(rect.size());
QTest::qWait(10);
QTRY_COMPARE(widget.pos(), rect.topLeft());
QTRY_COMPARE(widget.size(), rect.size());
// move() without showing
foreach (QRect r, rects) {
widget.move(r.topLeft());
widget.resize(r.size());
QApplication::processEvents();
QTRY_COMPARE(widget.pos(), r.topLeft());
QTRY_COMPARE(widget.size(), r.size());
}
}
{
// move() first, then show()
QWidget widget;
if (windowFlags != 0)
widget.setWindowFlags(Qt::WindowFlags(windowFlags));
widget.move(rect.topLeft());
widget.resize(rect.size());
widget.show();
QTest::qWait(10);
#if defined(Q_WS_MAC) && !defined(QT_MAC_USE_COCOA)
QEXPECT_FAIL("130,50 0x0, flags 0",
"Showing a window with 0x0 size shifts it up.",
Continue);
#endif
QTRY_COMPARE(widget.pos(), rect.topLeft());
QTRY_COMPARE(widget.size(), rect.size());
// move() while shown
foreach (QRect r, rects) {
#ifdef Q_WS_X11
if ((widget.width() == 0 || widget.height() == 0) && r.width() != 0 && r.height() != 0) {
QEXPECT_FAIL("130,100 0x200, flags 0",
"First resize after show of zero-sized gets wrong win_gravity.",
Continue);
QEXPECT_FAIL("100,50 200x0, flags 0",
"First resize after show of zero-sized gets wrong win_gravity.",
Continue);
QEXPECT_FAIL("130,50 0x0, flags 0",
"First resize after show of zero-sized gets wrong win_gravity.",
Continue);
}
#endif
widget.move(r.topLeft());
widget.resize(r.size());
QApplication::processEvents();
QTRY_COMPARE(widget.pos(), r.topLeft());
QTRY_COMPARE(widget.size(), r.size());
}
widget.move(rect.topLeft());
widget.resize(rect.size());
QApplication::processEvents();
QTRY_COMPARE(widget.pos(), rect.topLeft());
QTRY_COMPARE(widget.size(), rect.size());
// now hide
widget.hide();
QTest::qWait(10);
QTRY_COMPARE(widget.pos(), rect.topLeft());
QTRY_COMPARE(widget.size(), rect.size());
// move() after hide()
foreach (QRect r, rects) {
widget.move(r.topLeft());
widget.resize(r.size());
QApplication::processEvents();
#if defined(Q_WS_MAC) && defined(QT_MAC_USE_COCOA)
if (r.width() == 0 && r.height() > 0) {
widget.move(r.topLeft());
widget.resize(r.size());
}
#endif
QTRY_COMPARE(widget.pos(), r.topLeft());
QTRY_COMPARE(widget.size(), r.size());
}
widget.move(rect.topLeft());
widget.resize(rect.size());
QTest::qWait(10);
QTRY_COMPARE(widget.pos(), rect.topLeft());
QTRY_COMPARE(widget.size(), rect.size());
// show() again, pos() should be the same
widget.show();
QTest::qWaitForWindowShown(&widget);
QApplication::processEvents();
QTRY_COMPARE(widget.pos(), rect.topLeft());
QTRY_COMPARE(widget.size(), rect.size());
// final hide(), again pos() should be unchanged
widget.hide();
QApplication::processEvents();
QTRY_COMPARE(widget.pos(), rect.topLeft());
QTRY_COMPARE(widget.size(), rect.size());
}
{
// show() first, then move()
QWidget widget;
if (windowFlags != 0)
widget.setWindowFlags(Qt::WindowFlags(windowFlags));
widget.show();
QTest::qWaitForWindowShown(&widget);
QApplication::processEvents();
widget.move(rect.topLeft());
widget.resize(rect.size());
QApplication::processEvents();
QTRY_COMPARE(widget.pos(), rect.topLeft());
QTRY_COMPARE(widget.size(), rect.size());
// move() while shown
foreach (QRect r, rects) {
widget.move(r.topLeft());
widget.resize(r.size());
QApplication::processEvents();
QTRY_COMPARE(widget.pos(), r.topLeft());
QTRY_COMPARE(widget.size(), r.size());
}
widget.move(rect.topLeft());
widget.resize(rect.size());
QApplication::processEvents();
QTRY_COMPARE(widget.pos(), rect.topLeft());
QTRY_COMPARE(widget.size(), rect.size());
// now hide
widget.hide();
QApplication::processEvents();
QTRY_COMPARE(widget.pos(), rect.topLeft());
QTRY_COMPARE(widget.size(), rect.size());
// move() after hide()
foreach (QRect r, rects) {
widget.move(r.topLeft());
widget.resize(r.size());
QApplication::processEvents();
#if defined(Q_WS_MAC) && defined(QT_MAC_USE_COCOA)
if (r.width() == 0 && r.height() > 0) {
widget.move(r.topLeft());
widget.resize(r.size());
}
#endif
QTRY_COMPARE(widget.pos(), r.topLeft());
QTRY_COMPARE(widget.size(), r.size());
}
widget.move(rect.topLeft());
widget.resize(rect.size());
QApplication::processEvents();
QTRY_COMPARE(widget.pos(), rect.topLeft());
QTRY_COMPARE(widget.size(), rect.size());
// show() again, pos() should be the same
widget.show();
QTest::qWaitForWindowShown(&widget);
QTest::qWait(10);
QTRY_COMPARE(widget.pos(), rect.topLeft());
QTRY_COMPARE(widget.size(), rect.size());
// final hide(), again pos() should be unchanged
widget.hide();
QTest::qWait(10);
QTRY_COMPARE(widget.pos(), rect.topLeft());
QTRY_COMPARE(widget.size(), rect.size());
}
}
class ColorWidget : public QWidget
{
public:
ColorWidget(QWidget *parent = 0, const QColor &c = QColor(Qt::red))
: QWidget(parent, Qt::FramelessWindowHint), color(c)
{
QPalette opaquePalette = palette();
opaquePalette.setColor(backgroundRole(), color);
setPalette(opaquePalette);
setAutoFillBackground(true);
}
void paintEvent(QPaintEvent *e) {
r += e->region();
}
void reset() {
r = QRegion();
}
QColor color;
QRegion r;
};
#define VERIFY_COLOR(region, color) { \
const QRegion r = QRegion(region); \
for (int i = 0; i < r.rects().size(); ++i) { \
const QRect rect = r.rects().at(i); \
for (int t = 0; t < 5; t++) { \
const QPixmap pixmap = QPixmap::grabWindow(QDesktopWidget().winId(), \
rect.left(), rect.top(), \
rect.width(), rect.height()); \
QCOMPARE(pixmap.size(), rect.size()); \
QPixmap expectedPixmap(pixmap); /* ensure equal formats */ \
expectedPixmap.detach(); \
expectedPixmap.fill(color); \
QImage image = pixmap.toImage(); \
uint alphaCorrection = image.format() == QImage::Format_RGB32 ? 0xff000000 : 0; \
uint firstPixel = image.pixel(0,0) | alphaCorrection; \
if ( firstPixel != QColor(color).rgb() && t < 4 ) \
{ QTest::qWait(200); continue; } \
QCOMPARE(firstPixel, QColor(color).rgb()); \
QCOMPARE(pixmap, expectedPixmap); \
break; \
} \
} \
}
void tst_QWidget::moveChild_data()
{
QTest::addColumn<QPoint>("offset");
QTest::newRow("right") << QPoint(20, 0);
QTest::newRow("down") << QPoint(0, 20);
QTest::newRow("left") << QPoint(-20, 0);
QTest::newRow("up") << QPoint(0, -20);
}
void tst_QWidget::moveChild()
{
QFETCH(QPoint, offset);
ColorWidget parent;
// prevent custom styles
parent.setStyle(new QWindowsStyle);
ColorWidget child(&parent, Qt::blue);
#ifndef Q_OS_WINCE
parent.setGeometry(QRect(QPoint(QApplication::desktop()->availableGeometry(&parent).topLeft()),
QSize(100, 100)));
#else
parent.setGeometry(60, 60, 150, 150);
#endif
child.setGeometry(25, 25, 50, 50);
QPoint childOffset = child.mapToGlobal(QPoint());
parent.show();
QTest::qWaitForWindowShown(&parent);
QTest::qWait(30);
const QPoint tlwOffset = parent.geometry().topLeft();
QTRY_COMPARE(parent.r, QRegion(parent.rect()) - child.geometry());
QTRY_COMPARE(child.r, QRegion(child.rect()));
VERIFY_COLOR(child.geometry().translated(tlwOffset),
child.color);
VERIFY_COLOR(QRegion(parent.geometry()) - child.geometry().translated(tlwOffset),
parent.color);
parent.reset();
child.reset();
// move
const QRect oldGeometry = child.geometry();
QPoint pos = child.pos() + offset;
child.move(pos);
QTest::qWait(100);
QTRY_COMPARE(pos, child.pos());
QCOMPARE(parent.r, QRegion(oldGeometry) - child.geometry());
#if !defined(Q_WS_MAC)
// should be scrolled in backingstore
QCOMPARE(child.r, QRegion());
#endif
VERIFY_COLOR(child.geometry().translated(tlwOffset),
child.color);
VERIFY_COLOR(QRegion(parent.geometry()) - child.geometry().translated(tlwOffset),
parent.color);
}
void tst_QWidget::showAndMoveChild()
{
QWidget parent(0, Qt::FramelessWindowHint);
// prevent custom styles
parent.setStyle(new QWindowsStyle);
QDesktopWidget desktop;
QRect desktopDimensions = desktop.availableGeometry(&parent);
parent.setGeometry(desktopDimensions);
parent.setPalette(Qt::red);
parent.show();
QTest::qWaitForWindowShown(&parent);
QTest::qWait(10);
const QPoint tlwOffset = parent.geometry().topLeft();
QWidget child(&parent);
child.resize(desktopDimensions.width()/2, desktopDimensions.height()/2);
child.setPalette(Qt::blue);
child.setAutoFillBackground(true);
// Ensure that the child is repainted correctly when moved right after show.
// NB! Do NOT processEvents() (or qWait()) in between show() and move().
child.show();
child.move(desktopDimensions.width()/2, desktopDimensions.height()/2);
qApp->processEvents();
VERIFY_COLOR(child.geometry().translated(tlwOffset), Qt::blue);
VERIFY_COLOR(QRegion(parent.geometry()) - child.geometry().translated(tlwOffset), Qt::red);
}
void tst_QWidget::subtractOpaqueSiblings()
{
#ifdef QT_MAC_USE_COCOA
QSKIP("Cocoa only has rect granularity.", SkipAll);
#else
QWidget w;
w.setGeometry(50, 50, 300, 300);
ColorWidget *large = new ColorWidget(&w, Qt::red);
large->setGeometry(50, 50, 200, 200);
ColorWidget *medium = new ColorWidget(large, Qt::gray);
medium->setGeometry(50, 50, 100, 100);
ColorWidget *tall = new ColorWidget(&w, Qt::blue);
tall->setGeometry(100, 30, 50, 100);
w.show();
QTest::qWaitForWindowShown(&w);
QTest::qWait(10);
large->reset();
medium->reset();
tall->reset();
medium->update();
QTest::qWait(10);
// QWidgetPrivate::subtractOpaqueSiblings() should prevent parts of medium
// to be repainted and tall from be repainted at all.
QTRY_COMPARE(large->r, QRegion());
QTRY_COMPARE(tall->r, QRegion());
QTRY_COMPARE(medium->r.translated(medium->mapTo(&w, QPoint())),
QRegion(medium->geometry().translated(large->pos()))
- tall->geometry());
#endif
}
void tst_QWidget::deleteStyle()
{
QWidget widget;
widget.setStyle(new QWindowsStyle);
widget.show();
delete widget.style();
qApp->processEvents();
}
#ifdef Q_WS_WIN
void tst_QWidget::getDC()
{
QWidget widget;
widget.setGeometry(0, 0, 2, 4);
HDC dc = widget.getDC();
QVERIFY(dc != 0);
widget.releaseDC(dc);
}
#endif
class TopLevelFocusCheck: public QWidget
{
Q_OBJECT
public:
QLineEdit* edit;
TopLevelFocusCheck(QWidget* parent = 0) : QWidget(parent)
{
edit = new QLineEdit(this);
edit->hide();
edit->installEventFilter(this);
}
public slots:
void mouseDoubleClickEvent ( QMouseEvent * /*event*/ )
{
edit->show();
edit->setFocus(Qt::OtherFocusReason);
qApp->processEvents();
}
bool eventFilter(QObject *obj, QEvent *event)
{
if (obj == edit && event->type()== QEvent::FocusOut) {
edit->hide();
return true;
}
return false;
}
};
void tst_QWidget::multipleToplevelFocusCheck()
{
TopLevelFocusCheck w1;
TopLevelFocusCheck w2;
w1.resize(200, 200);
w1.show();
QTest::qWaitForWindowShown(&w1);
w2.resize(200,200);
w2.show();
QTest::qWaitForWindowShown(&w2);
QTest::qWait(100);
QApplication::setActiveWindow(&w1);
w1.activateWindow();
QApplication::processEvents();
QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&w1));
QTest::qWait(50);
QTest::mouseDClick(&w1, Qt::LeftButton);
QTRY_COMPARE(QApplication::focusWidget(), static_cast<QWidget *>(w1.edit));
w2.activateWindow();
QApplication::setActiveWindow(&w2);
QApplication::processEvents();
QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&w2));
QTest::mouseClick(&w2, Qt::LeftButton);
#ifdef Q_WS_QWS
QEXPECT_FAIL("", "embedded toplevels take focus anyway", Continue);
#endif
QTRY_COMPARE(QApplication::focusWidget(), (QWidget *)0);
QTest::mouseDClick(&w2, Qt::LeftButton);
QTRY_COMPARE(QApplication::focusWidget(), static_cast<QWidget *>(w2.edit));
w1.activateWindow();
QApplication::setActiveWindow(&w1);
QApplication::processEvents();
QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&w1));
QTest::mouseDClick(&w1, Qt::LeftButton);
QTRY_COMPARE(QApplication::focusWidget(), static_cast<QWidget *>(w1.edit));
w2.activateWindow();
QApplication::setActiveWindow(&w2);
QApplication::processEvents();
QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&w2));
QTest::mouseClick(&w2, Qt::LeftButton);
QTRY_COMPARE(QApplication::focusWidget(), (QWidget *)0);
}
void tst_QWidget::setFocus()
{
{
// move focus to another window
testWidget->activateWindow();
QApplication::setActiveWindow(testWidget);
if (testWidget->focusWidget())
testWidget->focusWidget()->clearFocus();
else
testWidget->clearFocus();
// window and children never shown, nobody gets focus
QWidget window;
QWidget child1(&window);
child1.setFocusPolicy(Qt::StrongFocus);
QWidget child2(&window);
child2.setFocusPolicy(Qt::StrongFocus);
child1.setFocus();
QVERIFY(!child1.hasFocus());
QCOMPARE(window.focusWidget(), &child1);
QCOMPARE(QApplication::focusWidget(), static_cast<QWidget *>(0));
child2.setFocus();
QVERIFY(!child2.hasFocus());
QCOMPARE(window.focusWidget(), &child2);
QCOMPARE(QApplication::focusWidget(), static_cast<QWidget *>(0));
}
{
// window and children show, but window not active, nobody gets focus
QWidget window;
QWidget child1(&window);
child1.setFocusPolicy(Qt::StrongFocus);
QWidget child2(&window);
child2.setFocusPolicy(Qt::StrongFocus);
window.show();
// note: window may be active, but we don't want it to be
testWidget->activateWindow();
QApplication::setActiveWindow(testWidget);
if (testWidget->focusWidget())
testWidget->focusWidget()->clearFocus();
else
testWidget->clearFocus();
child1.setFocus();
QVERIFY(!child1.hasFocus());
QCOMPARE(window.focusWidget(), &child1);
QCOMPARE(QApplication::focusWidget(), static_cast<QWidget *>(0));
child2.setFocus();
QVERIFY(!child2.hasFocus());
QCOMPARE(window.focusWidget(), &child2);
QCOMPARE(QApplication::focusWidget(), static_cast<QWidget *>(0));
}
{
// window and children show, but window *is* active, children get focus
QWidget window;
QWidget child1(&window);
child1.setFocusPolicy(Qt::StrongFocus);
QWidget child2(&window);
child2.setFocusPolicy(Qt::StrongFocus);
window.show();
#ifdef Q_WS_X11
QApplication::setActiveWindow(&window);
QTest::qWaitForWindowShown(&window);
#else
window.activateWindow();
QApplication::processEvents();
#endif
child1.setFocus();
QTRY_VERIFY(child1.hasFocus());
QCOMPARE(window.focusWidget(), &child1);
QCOMPARE(QApplication::focusWidget(), &child1);
child2.setFocus();
QVERIFY(child2.hasFocus());
QCOMPARE(window.focusWidget(), &child2);
QCOMPARE(QApplication::focusWidget(), &child2);
}
{
// window shown and active, children created, don't get focus, but get focus when shown
QWidget window;
window.show();
#ifdef Q_WS_X11
QApplication::setActiveWindow(&window);
QTest::qWaitForWindowShown(&window);
#else
window.activateWindow();
#endif
QWidget child1(&window);
child1.setFocusPolicy(Qt::StrongFocus);
QWidget child2(&window);
child2.setFocusPolicy(Qt::StrongFocus);
child1.setFocus();
QVERIFY(!child1.hasFocus());
QCOMPARE(window.focusWidget(), static_cast<QWidget *>(0));
QCOMPARE(QApplication::focusWidget(), static_cast<QWidget *>(0));
child1.show();
#ifdef Q_WS_X11
QApplication::setActiveWindow(&child1);
child1.activateWindow();
#endif
QApplication::processEvents();
QTRY_VERIFY(child1.hasFocus());
QCOMPARE(window.focusWidget(), &child1);
QCOMPARE(QApplication::focusWidget(), &child1);
child2.setFocus();
QVERIFY(!child2.hasFocus());
QCOMPARE(window.focusWidget(), &child1);
QCOMPARE(QApplication::focusWidget(), &child1);
child2.show();
QVERIFY(child2.hasFocus());
QCOMPARE(window.focusWidget(), &child2);
QCOMPARE(QApplication::focusWidget(), &child2);
}
{
// window shown and active, children created, don't get focus,
// even after setFocus(), hide(), then show()
QWidget window;
window.show();
#ifdef Q_WS_X11
QApplication::setActiveWindow(&window);
QTest::qWaitForWindowShown(&window);
#else
window.activateWindow();
#endif
QWidget child1(&window);
child1.setFocusPolicy(Qt::StrongFocus);
QWidget child2(&window);
child2.setFocusPolicy(Qt::StrongFocus);
child1.setFocus();
QVERIFY(!child1.hasFocus());
QCOMPARE(window.focusWidget(), static_cast<QWidget *>(0));
QCOMPARE(QApplication::focusWidget(), static_cast<QWidget *>(0));
child1.hide();
QVERIFY(!child1.hasFocus());
QCOMPARE(window.focusWidget(), static_cast<QWidget *>(0));
QCOMPARE(QApplication::focusWidget(), static_cast<QWidget *>(0));
child1.show();
QVERIFY(!child1.hasFocus());
QCOMPARE(window.focusWidget(), static_cast<QWidget *>(0));
QCOMPARE(QApplication::focusWidget(), static_cast<QWidget *>(0));
child2.setFocus();
QVERIFY(!child2.hasFocus());
QCOMPARE(window.focusWidget(), static_cast<QWidget *>(0));
QCOMPARE(QApplication::focusWidget(), static_cast<QWidget *>(0));
child2.hide();
QVERIFY(!child2.hasFocus());
QCOMPARE(window.focusWidget(), static_cast<QWidget *>(0));
QCOMPARE(QApplication::focusWidget(), static_cast<QWidget *>(0));
child2.show();
QVERIFY(!child2.hasFocus());
QCOMPARE(window.focusWidget(), static_cast<QWidget *>(0));
QCOMPARE(QApplication::focusWidget(), static_cast<QWidget *>(0));
}
}
class EventSpy : public QObject
{
public:
EventSpy(QWidget *widget, QEvent::Type event)
: m_widget(widget), eventToSpy(event), m_count(0)
{
if (m_widget)
m_widget->installEventFilter(this);
}
QWidget *widget() const { return m_widget; }
int count() const { return m_count; }
void clear() { m_count = 0; }
protected:
bool eventFilter(QObject *object, QEvent *event)
{
if (event->type() == eventToSpy)
++m_count;
return QObject::eventFilter(object, event);
}
private:
QWidget *m_widget;
QEvent::Type eventToSpy;
int m_count;
};
void tst_QWidget::setCursor()
{
#ifndef QT_NO_CURSOR
{
QWidget window;
QWidget child(&window);
QVERIFY(!window.testAttribute(Qt::WA_SetCursor));
QVERIFY(!child.testAttribute(Qt::WA_SetCursor));
window.setCursor(window.cursor());
QVERIFY(window.testAttribute(Qt::WA_SetCursor));
QVERIFY(!child.testAttribute(Qt::WA_SetCursor));
QCOMPARE(child.cursor().shape(), window.cursor().shape());
}
// do it again, but with window show()n
{
QWidget window;
QWidget child(&window);
window.show();
QVERIFY(!window.testAttribute(Qt::WA_SetCursor));
QVERIFY(!child.testAttribute(Qt::WA_SetCursor));
window.setCursor(window.cursor());
QVERIFY(window.testAttribute(Qt::WA_SetCursor));
QVERIFY(!child.testAttribute(Qt::WA_SetCursor));
QCOMPARE(child.cursor().shape(), window.cursor().shape());
}
{
QWidget window;
QWidget child(&window);
window.setCursor(Qt::WaitCursor);
QVERIFY(window.testAttribute(Qt::WA_SetCursor));
QVERIFY(!child.testAttribute(Qt::WA_SetCursor));
QCOMPARE(child.cursor().shape(), window.cursor().shape());
}
// same thing again, just with window show()n
{
QWidget window;
QWidget child(&window);
window.show();
window.setCursor(Qt::WaitCursor);
QVERIFY(window.testAttribute(Qt::WA_SetCursor));
QVERIFY(!child.testAttribute(Qt::WA_SetCursor));
QCOMPARE(child.cursor().shape(), window.cursor().shape());
}
// reparenting child should not cause the WA_SetCursor to become set
{
QWidget window;
QWidget window2;
QWidget child(&window);
window.setCursor(Qt::WaitCursor);
child.setParent(0);
QVERIFY(!child.testAttribute(Qt::WA_SetCursor));
QCOMPARE(child.cursor().shape(), QCursor().shape());
child.setParent(&window2);
QVERIFY(!child.testAttribute(Qt::WA_SetCursor));
QCOMPARE(child.cursor().shape(), window2.cursor().shape());
window2.setCursor(Qt::WaitCursor);
QVERIFY(!child.testAttribute(Qt::WA_SetCursor));
QCOMPARE(child.cursor().shape(), window2.cursor().shape());
}
// again, with windows show()n
{
QWidget window;
QWidget window2;
QWidget child(&window);
window.setCursor(Qt::WaitCursor);
window.show();
child.setParent(0);
QVERIFY(!child.testAttribute(Qt::WA_SetCursor));
QCOMPARE(child.cursor().shape(), QCursor().shape());
child.setParent(&window2);
QVERIFY(!child.testAttribute(Qt::WA_SetCursor));
QCOMPARE(child.cursor().shape(), window2.cursor().shape());
window2.show();
window2.setCursor(Qt::WaitCursor);
QVERIFY(!child.testAttribute(Qt::WA_SetCursor));
QCOMPARE(child.cursor().shape(), window2.cursor().shape());
}
// test if CursorChange is sent
{
QWidget widget;
EventSpy spy(&widget, QEvent::CursorChange);
QCOMPARE(spy.count(), 0);
widget.setCursor(QCursor(Qt::WaitCursor));
QCOMPARE(spy.count(), 1);
widget.unsetCursor();
QCOMPARE(spy.count(), 2);
}
#endif
}
void tst_QWidget::setToolTip()
{
QWidget widget;
EventSpy spy(&widget, QEvent::ToolTipChange);
QCOMPARE(spy.count(), 0);
QCOMPARE(widget.toolTip(), QString());
widget.setToolTip(QString("Hello"));
QCOMPARE(widget.toolTip(), QString("Hello"));
QCOMPARE(spy.count(), 1);
widget.setToolTip(QString());
QCOMPARE(widget.toolTip(), QString());
QCOMPARE(spy.count(), 2);
#ifdef Q_OS_WINCE_WM
QSKIP("Mouse over doesn't work on Windows mobile.", SkipAll);
#endif
for (int pass = 0; pass < 2; ++pass) {
QWidget *popup = new QWidget(0, Qt::Popup);
popup->resize(150, 50);
QFrame *frame = new QFrame(popup);
frame->setGeometry(0, 0, 50, 50);
frame->setFrameStyle(QFrame::Box | QFrame::Plain);
EventSpy spy1(frame, QEvent::ToolTip);
EventSpy spy2(popup, QEvent::ToolTip);
frame->setMouseTracking(pass == 0 ? false : true);
frame->setToolTip(QLatin1String("TOOLTIP FRAME"));
popup->setToolTip(QLatin1String("TOOLTIP POPUP"));
popup->show();
QTest::qWaitForWindowShown(popup);
QTest::qWait(10);
QTest::mouseMove(frame);
QTest::qWait(900); // delay is 700
QCOMPARE(spy1.count(), 1);
QCOMPARE(spy2.count(), 0);
if (pass == 0)
QTest::qWait(2200); // delay is 2000
QTest::mouseMove(popup);
delete popup;
}
}
void tst_QWidget::testWindowIconChangeEventPropagation()
{
// Create widget hierarchy.
QWidget topLevelWidget;
QWidget topLevelChild(&topLevelWidget);
QDialog dialog(&topLevelWidget);
QWidget dialogChild(&dialog);
QWidgetList widgets;
widgets << &topLevelWidget << &topLevelChild
<< &dialog << &dialogChild;
QCOMPARE(widgets.count(), 4);
// Create spy lists.
QList <EventSpy *> applicationEventSpies;
QList <EventSpy *> widgetEventSpies;
foreach (QWidget *widget, widgets) {
applicationEventSpies.append(new EventSpy(widget, QEvent::ApplicationWindowIconChange));
widgetEventSpies.append(new EventSpy(widget, QEvent::WindowIconChange));
}
// QApplication::setWindowIcon
const QIcon windowIcon = qApp->style()->standardIcon(QStyle::SP_TitleBarMenuButton);
qApp->setWindowIcon(windowIcon);
for (int i = 0; i < widgets.count(); ++i) {
// Check QEvent::ApplicationWindowIconChange
EventSpy *spy = applicationEventSpies.at(i);
QWidget *widget = spy->widget();
if (widget->isWindow()) {
QCOMPARE(spy->count(), 1);
QCOMPARE(widget->windowIcon(), windowIcon);
} else {
QCOMPARE(spy->count(), 0);
}
spy->clear();
// Check QEvent::WindowIconChange
spy = widgetEventSpies.at(i);
QCOMPARE(spy->count(), 1);
spy->clear();
}
// Set icon on a top-level widget.
topLevelWidget.setWindowIcon(*new QIcon);
for (int i = 0; i < widgets.count(); ++i) {
// Check QEvent::ApplicationWindowIconChange
EventSpy *spy = applicationEventSpies.at(i);
QCOMPARE(spy->count(), 0);
spy->clear();
// Check QEvent::WindowIconChange
spy = widgetEventSpies.at(i);
QWidget *widget = spy->widget();
if (widget == &topLevelWidget) {
QCOMPARE(widget->windowIcon(), QIcon());
QCOMPARE(spy->count(), 1);
} else if (topLevelWidget.isAncestorOf(widget)) {
QCOMPARE(spy->count(), 1);
} else {
QCOMPARE(spy->count(), 0);
}
spy->clear();
}
// Cleanup.
for (int i = 0; i < widgets.count(); ++i) {
delete applicationEventSpies.at(i);
delete widgetEventSpies.at(i);
}
qApp->setWindowIcon(QIcon());
}
#ifdef Q_WS_X11
void tst_QWidget::minAndMaxSizeWithX11BypassWindowManagerHint()
{
// Same size as in QWidget::create_sys().
const QSize desktopSize = QApplication::desktop()->size();
const QSize originalSize(desktopSize.width() / 2, desktopSize.height() * 4 / 10);
{ // Maximum size.
QWidget widget(0, Qt::X11BypassWindowManagerHint);
const QSize newMaximumSize = widget.size().boundedTo(originalSize) - QSize(10, 10);
widget.setMaximumSize(newMaximumSize);
QCOMPARE(widget.size(), newMaximumSize);
widget.show();
qt_x11_wait_for_window_manager(&widget);
QCOMPARE(widget.size(), newMaximumSize);
}
{ // Minimum size.
QWidget widget(0, Qt::X11BypassWindowManagerHint);
const QSize newMinimumSize = widget.size().expandedTo(originalSize) + QSize(10, 10);
widget.setMinimumSize(newMinimumSize);
QCOMPARE(widget.size(), newMinimumSize);
widget.show();
qt_x11_wait_for_window_manager(&widget);
QCOMPARE(widget.size(), newMinimumSize);
}
}
class ShowHideShowWidget : public QWidget
{
Q_OBJECT
int state;
public:
bool gotExpectedMapNotify;
ShowHideShowWidget()
: state(0), gotExpectedMapNotify(false)
{
startTimer(1000);
}
void timerEvent(QTimerEvent *)
{
switch (state++) {
case 0:
show();
break;
case 1:
emit done();
break;
}
}
bool x11Event(XEvent *event)
{
if (state == 1 && event->type == MapNotify)
gotExpectedMapNotify = true;
return false;
}
signals:
void done();
};
void tst_QWidget::showHideShow()
{
ShowHideShowWidget w;
w.show();
w.hide();
QEventLoop eventLoop;
connect(&w, SIGNAL(done()), &eventLoop, SLOT(quit()));
eventLoop.exec();
QVERIFY(w.gotExpectedMapNotify);
}
void tst_QWidget::clean_qt_x11_enforce_cursor()
{
{
QWidget window;
QWidget *w = new QWidget(&window);
QWidget *child = new QWidget(w);
child->setAttribute(Qt::WA_SetCursor, true);
window.show();
QApplication::setActiveWindow(&window);
QTest::qWaitForWindowShown(&window);
QTest::qWait(100);
QCursor::setPos(window.geometry().center());
QTest::qWait(100);
child->setFocus();
QApplication::processEvents();
QTest::qWait(100);
delete w;
}
QGraphicsScene scene;
QLineEdit *edit = new QLineEdit;
scene.addWidget(edit);
// If the test didn't crash, then it passed.
}
#endif
class EventRecorder : public QObject
{
Q_OBJECT
public:
typedef QList<QPair<QWidget *, QEvent::Type> > EventList;
EventRecorder(QObject *parent = 0)
: QObject(parent)
{ }
EventList eventList()
{
return events;
}
void clear()
{
events.clear();
}
bool eventFilter(QObject *object, QEvent *event)
{
QWidget *widget = qobject_cast<QWidget *>(object);
if (widget && !event->spontaneous())
events.append(qMakePair(widget, event->type()));
return false;
}
private:
EventList events;
};
void tst_QWidget::compatibilityChildInsertedEvents()
{
EventRecorder::EventList expected;
bool accessibilityEnabled = false;
#if defined(Q_WS_MAC) && !defined(QT_MAC_USE_COCOA)
accessibilityEnabled = AXAPIEnabled();
#endif
// Move away the cursor; otherwise it might result in an enter event if it's
// inside the widget when the widget is shown.
QCursor::setPos(qApp->desktop()->availableGeometry().bottomRight());
QTest::qWait(100);
{
// no children created, not shown
QWidget widget;
EventRecorder spy;
widget.installEventFilter(&spy);
QCoreApplication::postEvent(&widget, new QEvent(QEvent::Type(QEvent::User + 1)));
QCoreApplication::sendPostedEvents();
expected =
EventRecorder::EventList()
<< qMakePair(&widget, QEvent::PolishRequest)
<< qMakePair(&widget, QEvent::Polish)
<< qMakePair(&widget, QEvent::Type(QEvent::User + 1));
QCOMPARE(spy.eventList(), expected);
}
{
// no children, shown
QWidget widget;
EventRecorder spy;
widget.installEventFilter(&spy);
QCoreApplication::postEvent(&widget, new QEvent(QEvent::Type(QEvent::User + 1)));
widget.show();
expected =
EventRecorder::EventList()
<< qMakePair(&widget, QEvent::WinIdChange)
<< qMakePair(&widget, QEvent::Polish)
<< qMakePair(&widget, QEvent::Move)
<< qMakePair(&widget, QEvent::Resize)
<< qMakePair(&widget, QEvent::Show);
if (accessibilityEnabled)
expected << qMakePair(&widget, QEvent::AccessibilityPrepare);
expected << qMakePair(&widget, QEvent::ShowToParent);
QCOMPARE(spy.eventList(), expected);
spy.clear();
QCoreApplication::sendPostedEvents();
expected =
EventRecorder::EventList()
<< qMakePair(&widget, QEvent::PolishRequest)
<< qMakePair(&widget, QEvent::Type(QEvent::User + 1));
#ifndef QT_MAC_USE_CARBON
#ifdef QT_MAC_USE_COCOA
if (QApplicationPrivate::graphics_system_name == QLatin1String("raster"))
#endif // QT_MAC_USE_COCOA
expected << qMakePair(&widget, QEvent::UpdateRequest);
#endif // !QT_MAC_USE_CARBON
QCOMPARE(spy.eventList(), expected);
}
{
// 2 children, not shown
QWidget widget;
EventRecorder spy;
widget.installEventFilter(&spy);
QCoreApplication::postEvent(&widget, new QEvent(QEvent::Type(QEvent::User + 1)));
QWidget child1(&widget);
QWidget child2;
child2.setParent(&widget);
QCoreApplication::postEvent(&widget, new QEvent(QEvent::Type(QEvent::User + 2)));
expected =
EventRecorder::EventList()
<< qMakePair(&widget, QEvent::ChildAdded)
<< qMakePair(&widget, QEvent::ChildAdded);
QCOMPARE(spy.eventList(), expected);
spy.clear();
QCoreApplication::sendPostedEvents();
expected =
EventRecorder::EventList()
<< qMakePair(&widget, QEvent::PolishRequest)
<< qMakePair(&widget, QEvent::Polish)
<< qMakePair(&widget, QEvent::ChildPolished)
<< qMakePair(&widget, QEvent::ChildPolished)
<< qMakePair(&widget, QEvent::Type(QEvent::User + 1))
<< qMakePair(&widget, QEvent::Type(QEvent::User + 2));
QCOMPARE(spy.eventList(), expected);
}
{
// 2 children, widget shown
QWidget widget;
EventRecorder spy;
widget.installEventFilter(&spy);
QCoreApplication::postEvent(&widget, new QEvent(QEvent::Type(QEvent::User + 1)));
QWidget child1(&widget);
QWidget child2;
child2.setParent(&widget);
QCoreApplication::postEvent(&widget, new QEvent(QEvent::Type(QEvent::User + 2)));
expected =
EventRecorder::EventList()
<< qMakePair(&widget, QEvent::ChildAdded)
<< qMakePair(&widget, QEvent::ChildAdded);
QCOMPARE(spy.eventList(), expected);
spy.clear();
widget.show();
expected =
EventRecorder::EventList()
<< qMakePair(&widget, QEvent::WinIdChange)
<< qMakePair(&widget, QEvent::Polish)
<< qMakePair(&widget, QEvent::ChildPolished)
<< qMakePair(&widget, QEvent::ChildPolished)
<< qMakePair(&widget, QEvent::Move)
<< qMakePair(&widget, QEvent::Resize)
<< qMakePair(&widget, QEvent::Show);
if (accessibilityEnabled)
expected << qMakePair(&widget, QEvent::AccessibilityPrepare);
expected << qMakePair(&widget, QEvent::ShowToParent);
QCOMPARE(spy.eventList(), expected);
spy.clear();
QCoreApplication::sendPostedEvents();
expected =
EventRecorder::EventList()
<< qMakePair(&widget, QEvent::PolishRequest)
<< qMakePair(&widget, QEvent::Type(QEvent::User + 1))
<< qMakePair(&widget, QEvent::Type(QEvent::User + 2));
#ifndef QT_MAC_USE_CARBON
#ifdef QT_MAC_USE_COCOA
if (QApplicationPrivate::graphics_system_name == QLatin1String("raster"))
#endif // QT_MAC_USE_COCOA
expected << qMakePair(&widget, QEvent::UpdateRequest);
#endif // !QT_MAC_USE_CARBON
QCOMPARE(spy.eventList(), expected);
}
{
// 2 children, but one is reparented away, not shown
QWidget widget;
EventRecorder spy;
widget.installEventFilter(&spy);
QCoreApplication::postEvent(&widget, new QEvent(QEvent::Type(QEvent::User + 1)));
QWidget child1(&widget);
QWidget child2;
child2.setParent(&widget);
child2.setParent(0);
QCoreApplication::postEvent(&widget, new QEvent(QEvent::Type(QEvent::User + 2)));
expected =
EventRecorder::EventList()
<< qMakePair(&widget, QEvent::ChildAdded)
<< qMakePair(&widget, QEvent::ChildAdded)
<< qMakePair(&widget, QEvent::ChildRemoved);
QCOMPARE(spy.eventList(), expected);
spy.clear();
QCoreApplication::sendPostedEvents();
expected =
EventRecorder::EventList()
<< qMakePair(&widget, QEvent::PolishRequest)
<< qMakePair(&widget, QEvent::Polish)
<< qMakePair(&widget, QEvent::ChildPolished)
<< qMakePair(&widget, QEvent::Type(QEvent::User + 1))
<< qMakePair(&widget, QEvent::Type(QEvent::User + 2));
QCOMPARE(spy.eventList(), expected);
}
{
// 2 children, but one is reparented away, then widget is shown
QWidget widget;
EventRecorder spy;
widget.installEventFilter(&spy);
QCoreApplication::postEvent(&widget, new QEvent(QEvent::Type(QEvent::User + 1)));
QWidget child1(&widget);
QWidget child2;
child2.setParent(&widget);
child2.setParent(0);
QCoreApplication::postEvent(&widget, new QEvent(QEvent::Type(QEvent::User + 2)));
expected =
EventRecorder::EventList()
<< qMakePair(&widget, QEvent::ChildAdded)
<< qMakePair(&widget, QEvent::ChildAdded)
<< qMakePair(&widget, QEvent::ChildRemoved);
QCOMPARE(spy.eventList(), expected);
spy.clear();
widget.show();
expected =
EventRecorder::EventList()
<< qMakePair(&widget, QEvent::WinIdChange)
<< qMakePair(&widget, QEvent::Polish)
<< qMakePair(&widget, QEvent::ChildPolished)
<< qMakePair(&widget, QEvent::Move)
<< qMakePair(&widget, QEvent::Resize)
<< qMakePair(&widget, QEvent::Show);
if (accessibilityEnabled)
expected << qMakePair(&widget, QEvent::AccessibilityPrepare);
expected << qMakePair(&widget, QEvent::ShowToParent);
QCOMPARE(spy.eventList(), expected);
spy.clear();
QCoreApplication::sendPostedEvents();
expected =
EventRecorder::EventList()
<< qMakePair(&widget, QEvent::PolishRequest)
<< qMakePair(&widget, QEvent::Type(QEvent::User + 1))
<< qMakePair(&widget, QEvent::Type(QEvent::User + 2));
#ifndef QT_MAC_USE_CARBON
#ifdef QT_MAC_USE_COCOA
if (QApplicationPrivate::graphics_system_name == QLatin1String("raster"))
#endif // QT_MAC_USE_COCOA
expected << qMakePair(&widget, QEvent::UpdateRequest);
#endif // !QT_MAC_USE_CARBON
QCOMPARE(spy.eventList(), expected);
}
}
class RenderWidget : public QWidget
{
public:
RenderWidget(QWidget *source)
: source(source), ellipse(false) {}
void setEllipseEnabled(bool enable = true)
{
ellipse = enable;
update();
}
protected:
void paintEvent(QPaintEvent *)
{
if (ellipse) {
QPainter painter(this);
painter.fillRect(rect(), Qt::red);
painter.end();
QRegion regionToRender = QRegion(0, 0, source->width(), source->height() / 2,
QRegion::Ellipse);
source->render(this, QPoint(0, 30), regionToRender);
} else {
source->render(this);
}
}
private:
QWidget *source;
bool ellipse;
};
void tst_QWidget::render()
{
return;
QCalendarWidget source;
// disable anti-aliasing to eliminate potential differences when subpixel antialiasing
// is enabled on the screen
QFont f;
f.setStyleStrategy(QFont::NoAntialias);
source.setFont(f);
source.show();
QTest::qWaitForWindowShown(&source);
// Render the entire source into target.
RenderWidget target(&source);
target.resize(source.size());
target.show();
qApp->processEvents();
qApp->sendPostedEvents();
QTest::qWait(250);
QImage sourceImage = QPixmap::grabWidget(&source).toImage();
qApp->processEvents();
QImage targetImage = QPixmap::grabWidget(&target).toImage();
qApp->processEvents();
QCOMPARE(sourceImage, targetImage);
// Fill target.rect() will Qt::red and render
// QRegion(0, 0, source->width(), source->height() / 2, QRegion::Ellipse)
// of source into target with offset (0, 30).
target.setEllipseEnabled();
qApp->processEvents();
qApp->sendPostedEvents();
targetImage = QPixmap::grabWidget(&target).toImage();
QVERIFY(sourceImage != targetImage);
QCOMPARE(targetImage.pixel(target.width() / 2, 29), QColor(Qt::red).rgb());
QCOMPARE(targetImage.pixel(target.width() / 2, 30), sourceImage.pixel(source.width() / 2, 0));
// Test that a child widget properly fills its background
{
QWidget window;
window.resize(100, 100);
// prevent custom styles
window.setStyle(new QWindowsStyle);
window.show();
QTest::qWaitForWindowShown(&window);
QWidget child(&window);
child.resize(window.size());
child.show();
qApp->processEvents();
QCOMPARE(QPixmap::grabWidget(&child), QPixmap::grabWidget(&window));
}
{ // Check that the target offset is correct.
QWidget widget;
widget.resize(200, 200);
widget.setAutoFillBackground(true);
widget.setPalette(Qt::red);
// prevent custom styles
widget.setStyle(new QWindowsStyle);
widget.show();
QTest::qWaitForWindowShown(&widget);
QImage image(widget.size(), QImage::Format_RGB32);
image.fill(QColor(Qt::blue).rgb());
// Target offset (0, 0)
widget.render(&image, QPoint(), QRect(20, 20, 100, 100));
QCOMPARE(image.pixel(0, 0), QColor(Qt::red).rgb());
QCOMPARE(image.pixel(99, 99), QColor(Qt::red).rgb());
QCOMPARE(image.pixel(100, 100), QColor(Qt::blue).rgb());
// Target offset (20, 20).
image.fill(QColor(Qt::blue).rgb());
widget.render(&image, QPoint(20, 20), QRect(20, 20, 100, 100));
QCOMPARE(image.pixel(0, 0), QColor(Qt::blue).rgb());
QCOMPARE(image.pixel(19, 19), QColor(Qt::blue).rgb());
QCOMPARE(image.pixel(20, 20), QColor(Qt::red).rgb());
QCOMPARE(image.pixel(119, 119), QColor(Qt::red).rgb());
QCOMPARE(image.pixel(120, 120), QColor(Qt::blue).rgb());
}
}
// On Windows the active palette is used instead of the inactive palette even
// though the widget is invisible. This is probably related to task 178507/168682,
// but for the renderInvisible test it doesn't matter, we're mostly interested
// in testing the geometry so just workaround the palette issue for now.
static void workaroundPaletteIssue(QWidget *widget)
{
#ifndef Q_WS_WIN
return;
#endif
if (!widget)
return;
QWidget *navigationBar = qFindChild<QWidget *>(widget, QLatin1String("qt_calendar_navigationbar"));
QVERIFY(navigationBar);
QPalette palette = navigationBar->palette();
const QColor background = palette.color(QPalette::Inactive, navigationBar->backgroundRole());
const QColor highlightedText = palette.color(QPalette::Inactive, QPalette::HighlightedText);
palette.setColor(QPalette::Active, navigationBar->backgroundRole(), background);
palette.setColor(QPalette::Active, QPalette::HighlightedText, highlightedText);
navigationBar->setPalette(palette);
}
//#define RENDER_DEBUG
void tst_QWidget::renderInvisible()
{
QCalendarWidget *calendar = new QCalendarWidget;
// disable anti-aliasing to eliminate potential differences when subpixel antialiasing
// is enabled on the screen
QFont f;
f.setStyleStrategy(QFont::NoAntialias);
calendar->setFont(f);
calendar->show();
QTest::qWaitForWindowShown(calendar);
// Create a dummy focus widget to get rid of focus rect in reference image.
QLineEdit dummyFocusWidget;
dummyFocusWidget.show();
QTest::qWaitForWindowShown(&dummyFocusWidget);
qApp->processEvents();
QTest::qWait(120);
// Create normal reference image.
const QSize calendarSize = calendar->size();
QImage referenceImage(calendarSize, QImage::Format_ARGB32);
calendar->render(&referenceImage);
#ifdef RENDER_DEBUG
referenceImage.save("referenceImage.png");
#endif
QVERIFY(!referenceImage.isNull());
// Create resized reference image.
const QSize calendarSizeResized = calendar->size() + QSize(50, 50);
calendar->resize(calendarSizeResized);
qApp->processEvents();
QTest::qWait(30);
QImage referenceImageResized(calendarSizeResized, QImage::Format_ARGB32);
calendar->render(&referenceImageResized);
#ifdef RENDER_DEBUG
referenceImageResized.save("referenceImageResized.png");
#endif
QVERIFY(!referenceImageResized.isNull());
// Explicitly hide the calendar.
calendar->hide();
qApp->processEvents();
QTest::qWait(30);
workaroundPaletteIssue(calendar);
{ // Make sure we get the same image when the calendar is explicitly hidden.
QImage testImage(calendarSizeResized, QImage::Format_ARGB32);
calendar->render(&testImage);
#ifdef RENDER_DEBUG
testImage.save("explicitlyHiddenCalendarResized.png");
#endif
QCOMPARE(testImage, referenceImageResized);
}
// Now that we have reference images we can delete the source and re-create
// the calendar and check that we get the same images from a calendar which has never
// been visible, laid out or created (Qt::WA_WState_Created).
delete calendar;
calendar = new QCalendarWidget;
calendar->setFont(f);
workaroundPaletteIssue(calendar);
{ // Never been visible, created or laid out.
QImage testImage(calendarSize, QImage::Format_ARGB32);
calendar->render(&testImage);
#ifdef RENDER_DEBUG
testImage.save("neverBeenVisibleCreatedOrLaidOut.png");
#endif
QCOMPARE(testImage, referenceImage);
}
calendar->hide();
qApp->processEvents();
QTest::qWait(30);
{ // Calendar explicitly hidden.
QImage testImage(calendarSize, QImage::Format_ARGB32);
calendar->render(&testImage);
#ifdef RENDER_DEBUG
testImage.save("explicitlyHiddenCalendar.png");
#endif
QCOMPARE(testImage, referenceImage);
}
// Get navigation bar and explicitly hide it.
QWidget *navigationBar = qFindChild<QWidget *>(calendar, QLatin1String("qt_calendar_navigationbar"));
QVERIFY(navigationBar);
navigationBar->hide();
{ // Check that the navigation bar isn't drawn when rendering the entire calendar.
QImage testImage(calendarSize, QImage::Format_ARGB32);
calendar->render(&testImage);
#ifdef RENDER_DEBUG
testImage.save("calendarWithoutNavigationBar.png");
#endif
QVERIFY(testImage != referenceImage);
}
{ // Make sure the navigation bar renders correctly even though it's hidden.
QImage testImage(navigationBar->size(), QImage::Format_ARGB32);
navigationBar->render(&testImage);
#ifdef RENDER_DEBUG
testImage.save("explicitlyHiddenNavigationBar.png");
#endif
QCOMPARE(testImage, referenceImage.copy(navigationBar->rect()));
}
// Get next month button.
QWidget *nextMonthButton = qFindChild<QWidget *>(navigationBar, QLatin1String("qt_calendar_nextmonth"));
QVERIFY(nextMonthButton);
{ // Render next month button.
// Fill test image with correct background color.
QImage testImage(nextMonthButton->size(), QImage::Format_ARGB32);
navigationBar->render(&testImage, QPoint(), QRegion(), QWidget::RenderFlags());
#ifdef RENDER_DEBUG
testImage.save("nextMonthButtonBackground.png");
#endif
// Set the button's background color to Qt::transparent; otherwise it will fill the
// background with QPalette::Window.
const QPalette originalPalette = nextMonthButton->palette();
QPalette palette = originalPalette;
palette.setColor(QPalette::Window, Qt::transparent);
nextMonthButton->setPalette(palette);
// Render the button on top of the background.
nextMonthButton->render(&testImage);
#ifdef RENDER_DEBUG
testImage.save("nextMonthButton.png");
#endif
const QRect buttonRect(nextMonthButton->mapTo(calendar, QPoint()), nextMonthButton->size());
QCOMPARE(testImage, referenceImage.copy(buttonRect));
// Restore palette.
nextMonthButton->setPalette(originalPalette);
}
// Navigation bar isn't explicitly hidden anymore.
navigationBar->show();
qApp->processEvents();
QTest::qWait(30);
QVERIFY(!calendar->isVisible());
// Now, completely mess up the layout. This will trigger an update on the layout
// when the calendar is visible or shown, but it's not. QWidget::render must therefore
// make sure the layout is activated before rendering.
QVERIFY(!calendar->isVisible());
calendar->resize(calendarSizeResized);
qApp->processEvents();
{ // Make sure we get an image equal to the resized reference image.
QImage testImage(calendarSizeResized, QImage::Format_ARGB32);
calendar->render(&testImage);
#ifdef RENDER_DEBUG
testImage.save("calendarResized.png");
#endif
QCOMPARE(testImage, referenceImageResized);
}
{ // Make sure we lay out the widget correctly the first time it's rendered.
QCalendarWidget calendar;
const QSize calendarSize = calendar.sizeHint();
QImage image(2 * calendarSize, QImage::Format_ARGB32);
image.fill(QColor(Qt::red).rgb());
calendar.render(&image);
for (int i = calendarSize.height(); i < 2 * calendarSize.height(); ++i)
for (int j = calendarSize.width(); j < 2 * calendarSize.width(); ++j)
QCOMPARE(image.pixel(j, i), QColor(Qt::red).rgb());
}
{ // Ensure that we don't call adjustSize() on invisible top-levels if render() is called
// right after widgets have been added/removed to/from its layout.
QWidget topLevel;
topLevel.setLayout(new QVBoxLayout);
QWidget *widget = new QLineEdit;
topLevel.layout()->addWidget(widget);
const QSize initialSize = topLevel.size();
QPixmap pixmap(topLevel.sizeHint());
topLevel.render(&pixmap); // triggers adjustSize()
const QSize finalSize = topLevel.size();
QVERIFY(finalSize != initialSize);
topLevel.layout()->removeWidget(widget);
QCOMPARE(topLevel.size(), finalSize);
topLevel.render(&pixmap);
QCOMPARE(topLevel.size(), finalSize);
topLevel.layout()->addWidget(widget);
QCOMPARE(topLevel.size(), finalSize);
topLevel.render(&pixmap);
QCOMPARE(topLevel.size(), finalSize);
}
}
void tst_QWidget::renderWithPainter()
{
QWidget widget;
// prevent custom styles
widget.setStyle(new QWindowsStyle);
widget.show();
widget.resize(70, 50);
widget.setAutoFillBackground(true);
widget.setPalette(Qt::black);
// Render the entire widget onto the image.
QImage image(QSize(70, 50), QImage::Format_ARGB32);
image.fill(QColor(Qt::red).rgb());
QPainter painter(&image);
widget.render(&painter);
for (int i = 0; i < image.height(); ++i) {
for (int j = 0; j < image.width(); ++j)
QCOMPARE(image.pixel(j, i), QColor(Qt::black).rgb());
}
// Translate painter (10, 10).
painter.save();
image.fill(QColor(Qt::red).rgb());
painter.translate(10, 10);
widget.render(&painter);
painter.restore();
for (int i = 0; i < image.height(); ++i) {
for (int j = 0; j < image.width(); ++j) {
if (i < 10 || j < 10)
QCOMPARE(image.pixel(j, i), QColor(Qt::red).rgb());
else
QCOMPARE(image.pixel(j, i), QColor(Qt::black).rgb());
}
}
// Pass target offset (10, 10) (the same as QPainter::translate).
image.fill(QColor(Qt::red).rgb());
widget.render(&painter, QPoint(10, 10));
for (int i = 0; i < image.height(); ++i) {
for (int j = 0; j < image.width(); ++j) {
if (i < 10 || j < 10)
QCOMPARE(image.pixel(j, i), QColor(Qt::red).rgb());
else
QCOMPARE(image.pixel(j, i), QColor(Qt::black).rgb());
}
}
// Translate (10, 10) and pass target offset (10, 10).
painter.save();
image.fill(QColor(Qt::red).rgb());
painter.translate(10, 10);
widget.render(&painter, QPoint(10, 10));
painter.restore();
for (int i = 0; i < image.height(); ++i) {
for (int j = 0; j < image.width(); ++j) {
if (i < 20 || j < 20)
QCOMPARE(image.pixel(j, i), QColor(Qt::red).rgb());
else
QCOMPARE(image.pixel(j, i), QColor(Qt::black).rgb());
}
}
// Rotate painter 90 degrees.
painter.save();
image.fill(QColor(Qt::red).rgb());
painter.rotate(90);
widget.render(&painter);
painter.restore();
for (int i = 0; i < image.height(); ++i) {
for (int j = 0; j < image.width(); ++j)
QCOMPARE(image.pixel(j, i), QColor(Qt::red).rgb());
}
// Translate and rotate.
image.fill(QColor(Qt::red).rgb());
widget.resize(40, 10);
painter.translate(10, 10);
painter.rotate(90);
widget.render(&painter);
for (int i = 0; i < image.height(); ++i) {
for (int j = 0; j < image.width(); ++j) {
if (i >= 10 && j >= 0 && j < 10)
QCOMPARE(image.pixel(j, i), QColor(Qt::black).rgb());
else
QCOMPARE(image.pixel(j, i), QColor(Qt::red).rgb());
}
}
// Make sure QWidget::render does not modify the render hints set on the painter.
painter.setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform
| QPainter::NonCosmeticDefaultPen | QPainter::TextAntialiasing);
QPainter::RenderHints oldRenderHints = painter.renderHints();
widget.render(&painter);
QCOMPARE(painter.renderHints(), oldRenderHints);
}
void tst_QWidget::render_task188133()
{
QMainWindow mainWindow;
// Make sure QWidget::render does not trigger QWidget::repaint/update
// and asserts for Qt::WA_WState_Created.
QPixmap pixmap = QPixmap::grabWidget(&mainWindow);
}
void tst_QWidget::render_task211796()
{
class MyWidget : public QWidget
{
void resizeEvent(QResizeEvent *)
{
QPixmap pixmap(size());
render(&pixmap);
}
};
{ // Please don't die in a resize recursion.
MyWidget widget;
widget.resize(200, 200);
widget.show();
}
{ // Same check with a deeper hierarchy.
QWidget widget;
widget.show();
QWidget child(&widget);
MyWidget grandChild;
grandChild.setParent(&child);
grandChild.resize(100, 100);
child.show();
}
}
void tst_QWidget::render_task217815()
{
// Make sure we don't change the size of the widget when calling
// render() and the widget has an explicit size set.
// This was a problem on Windows because we called createWinId(),
// which in turn enforced the size to be bigger than the smallest
// possible native window size (which is (115,something) on WinXP).
QWidget widget;
const QSize explicitSize(80, 20);
widget.resize(explicitSize);
QCOMPARE(widget.size(), explicitSize);
QPixmap pixmap(explicitSize);
widget.render(&pixmap);
QCOMPARE(widget.size(), explicitSize);
}
void tst_QWidget::render_windowOpacity()
{
#ifdef Q_OS_WINCE
QSKIP("Window Opacity is not supported on Windows CE", SkipAll);
#endif
const qreal opacity = 0.5;
{ // Check that the painter opacity effects the widget drawing.
QWidget topLevel;
QWidget child(&topLevel);
child.resize(50, 50);
child.setPalette(Qt::red);
child.setAutoFillBackground(true);
QPixmap expected(child.size());
#ifdef Q_WS_X11
if (expected.depth() < 24) {
QSKIP("This test won't give correct results with dithered pixmaps", SkipAll);
}
#endif
expected.fill(Qt::green);
QPainter painter(&expected);
painter.setOpacity(opacity);
painter.fillRect(QRect(QPoint(0, 0), child.size()), Qt::red);
painter.end();
QPixmap result(child.size());
result.fill(Qt::green);
painter.begin(&result);
painter.setOpacity(opacity);
child.render(&painter);
painter.end();
QCOMPARE(result, expected);
}
{ // Combine the opacity set on the painter with the widget opacity.
class MyWidget : public QWidget
{
public:
void paintEvent(QPaintEvent *)
{
QPainter painter(this);
painter.setOpacity(opacity);
QCOMPARE(painter.opacity(), opacity);
painter.fillRect(rect(), Qt::red);
}
qreal opacity;
};
MyWidget widget;
widget.resize(50, 50);
widget.opacity = opacity;
widget.setPalette(Qt::blue);
widget.setAutoFillBackground(true);
QPixmap expected(widget.size());
expected.fill(Qt::green);
QPainter painter(&expected);
painter.setOpacity(opacity);
QPixmap pixmap(widget.size());
pixmap.fill(Qt::blue);
QPainter pixmapPainter(&pixmap);
pixmapPainter.setOpacity(opacity);
pixmapPainter.fillRect(QRect(QPoint(), widget.size()), Qt::red);
painter.drawPixmap(QPoint(), pixmap);
painter.end();
QPixmap result(widget.size());
result.fill(Qt::green);
painter.begin(&result);
painter.setOpacity(opacity);
widget.render(&painter);
painter.end();
QCOMPARE(result, expected);
}
}
void tst_QWidget::render_systemClip()
{
QWidget widget;
widget.setPalette(Qt::blue);
widget.resize(100, 100);
QImage image(widget.size(), QImage::Format_RGB32);
image.fill(QColor(Qt::red).rgb());
QPaintEngine *paintEngine = image.paintEngine();
QVERIFY(paintEngine);
paintEngine->setSystemClip(QRegion(0, 0, 50, 50));
QPainter painter(&image);
// Make sure we're using the same paint engine and has the right clip set.
QCOMPARE(painter.paintEngine(), paintEngine);
QCOMPARE(paintEngine->systemClip(), QRegion(0, 0, 50, 50));
// Translate painter outside system clip.
painter.translate(50, 0);
widget.render(&painter);
#ifdef RENDER_DEBUG
image.save("outside_systemclip.png");
#endif
// All pixels should be red.
for (int i = 0; i < image.height(); ++i) {
for (int j = 0; j < image.width(); ++j)
QCOMPARE(image.pixel(j, i), QColor(Qt::red).rgb());
}
// Restore painter and refill image with red.
image.fill(QColor(Qt::red).rgb());
painter.translate(-50, 0);
// Set transform on the painter.
QTransform transform;
transform.shear(0, 1);
painter.setTransform(transform);
widget.render(&painter);
#ifdef RENDER_DEBUG
image.save("blue_triangle.png");
#endif
// We should now have a blue triangle starting at scan line 1, and the rest should be red.
// rrrrrrrrrr
// brrrrrrrrr
// bbrrrrrrrr
// bbbrrrrrrr
// bbbbrrrrrr
// rrrrrrrrrr
// ...
#ifndef Q_WS_MAC
for (int i = 0; i < image.height(); ++i) {
for (int j = 0; j < image.width(); ++j) {
if (i < 50 && j < i)
QCOMPARE(image.pixel(j, i), QColor(Qt::blue).rgb());
else
QCOMPARE(image.pixel(j, i), QColor(Qt::red).rgb());
}
}
#else
// We don't paint directly on the image on the Mac, so we cannot do the pixel comparison
// as above due to QPainter::SmoothPixmapTransform. We therefore need to generate an
// expected image by first painting on a pixmap, and then draw the pixmap onto
// the image using QPainter::SmoothPixmapTransform. Then we can compare pixels :)
// The check is basically the same, except that it takes the smoothening into account.
QPixmap pixmap(50, 50);
const QRegion sysClip(0, 0, 50, 50);
widget.render(&pixmap, QPoint(), sysClip);
QImage expectedImage(widget.size(), QImage::Format_RGB32);
expectedImage.fill(QColor(Qt::red).rgb());
expectedImage.paintEngine()->setSystemClip(sysClip);
QPainter expectedImagePainter(&expectedImage);
expectedImagePainter.setTransform(QTransform().shear(0, 1));
// NB! This is the important part (SmoothPixmapTransform).
expectedImagePainter.setRenderHints(QPainter::SmoothPixmapTransform);
expectedImagePainter.drawPixmap(QPoint(0, 0), pixmap);
expectedImagePainter.end();
QCOMPARE(image, expectedImage);
#endif
}
void tst_QWidget::render_systemClip2_data()
{
QTest::addColumn<bool>("autoFillBackground");
QTest::addColumn<bool>("usePaintEvent");
QTest::addColumn<QColor>("expectedColor");
QTest::newRow("Only auto-fill background") << true << false << QColor(Qt::blue);
QTest::newRow("Only draw in paintEvent") << false << true << QColor(Qt::green);
QTest::newRow("Auto-fill background and draw in paintEvent") << true << true << QColor(Qt::green);
}
void tst_QWidget::render_systemClip2()
{
QFETCH(bool, autoFillBackground);
QFETCH(bool, usePaintEvent);
QFETCH(QColor, expectedColor);
QVERIFY2(expectedColor != QColor(Qt::red), "Qt::red is the reference color for the image, pick another color");
class MyWidget : public QWidget
{
public:
bool usePaintEvent;
void paintEvent(QPaintEvent *)
{
if (usePaintEvent)
QPainter(this).fillRect(rect(), Qt::green);
}
};
MyWidget widget;
widget.usePaintEvent = usePaintEvent;
widget.setPalette(Qt::blue);
// NB! widget.setAutoFillBackground(autoFillBackground) won't do the
// trick here since the widget is a top-level. The background is filled
// regardless, unless Qt::WA_OpaquePaintEvent or Qt::WA_NoSystemBackground
// is set. We therefore use the opaque attribute to turn off auto-fill.
if (!autoFillBackground)
widget.setAttribute(Qt::WA_OpaquePaintEvent);
widget.resize(100, 100);
QImage image(widget.size(), QImage::Format_RGB32);
image.fill(QColor(Qt::red).rgb());
QPaintEngine *paintEngine = image.paintEngine();
QVERIFY(paintEngine);
QRegion systemClip(QRegion(50, 0, 50, 10));
systemClip += QRegion(90, 10, 10, 40);
paintEngine->setSystemClip(systemClip);
// Render entire widget directly onto device.
widget.render(&image);
#ifdef RENDER_DEBUG
image.save("systemclip_with_device.png");
#endif
// All pixels within the system clip should now be
// the expectedColor, and the rest should be red.
for (int i = 0; i < image.height(); ++i) {
for (int j = 0; j < image.width(); ++j) {
if (systemClip.contains(QPoint(j, i)))
QCOMPARE(image.pixel(j, i), expectedColor.rgb());
else
QCOMPARE(image.pixel(j, i), QColor(Qt::red).rgb());
}
}
// Refill image with red.
image.fill(QColor(Qt::red).rgb());
paintEngine->setSystemClip(systemClip);
// Do the same with an untransformed painter.
QPainter painter(&image);
//Make sure we're using the same paint engine and has the right clip set.
QCOMPARE(painter.paintEngine(), paintEngine);
QCOMPARE(paintEngine->systemClip(), systemClip);
widget.render(&painter);
#ifdef RENDER_DEBUG
image.save("systemclip_with_untransformed_painter.png");
#endif
// All pixels within the system clip should now be
// the expectedColor, and the rest should be red.
for (int i = 0; i < image.height(); ++i) {
for (int j = 0; j < image.width(); ++j) {
if (systemClip.contains(QPoint(j, i)))
QCOMPARE(image.pixel(j, i), expectedColor.rgb());
else
QCOMPARE(image.pixel(j, i), QColor(Qt::red).rgb());
}
}
}
void tst_QWidget::render_systemClip3_data()
{
QTest::addColumn<QSize>("size");
QTest::addColumn<bool>("useSystemClip");
// Reference: http://en.wikipedia.org/wiki/Flag_of_Norway
QTest::newRow("Norwegian Civil Flag") << QSize(220, 160) << false;
QTest::newRow("Norwegian War Flag") << QSize(270, 160) << true;
}
// This test ensures that the current engine clip (systemClip + painter clip)
// is preserved after QPainter::setClipRegion(..., Qt::ReplaceClip);
void tst_QWidget::render_systemClip3()
{
QFETCH(QSize, size);
QFETCH(bool, useSystemClip);
// Calculate the inner/outer cross of the flag.
QRegion outerCross(0, 0, size.width(), size.height());
outerCross -= QRect(0, 0, 60, 60);
outerCross -= QRect(100, 0, size.width() - 100, 60);
outerCross -= QRect(0, 100, 60, 60);
outerCross -= QRect(100, 100, size.width() - 100, 60);
QRegion innerCross(0, 0, size.width(), size.height());
innerCross -= QRect(0, 0, 70, 70);
innerCross -= QRect(90, 0, size.width() - 90, 70);
innerCross -= QRect(0, 90, 70, 70);
innerCross -= QRect(90, 90, size.width() - 90, 70);
const QRegion redArea(QRegion(0, 0, size.width(), size.height()) - outerCross);
const QRegion whiteArea(outerCross - innerCross);
const QRegion blueArea(innerCross);
QRegion systemClip;
// Okay, here's the image that should look like a Norwegian civil/war flag in the end.
QImage flag(size, QImage::Format_ARGB32);
flag.fill(QColor(Qt::transparent).rgba());
if (useSystemClip) {
QPainterPath warClip(QPoint(size.width(), 0));
warClip.lineTo(size.width() - 110, 60);
warClip.lineTo(size.width(), 80);
warClip.lineTo(size.width() - 110, 100);
warClip.lineTo(size.width(), 160);
warClip.closeSubpath();
systemClip = QRegion(0, 0, size.width(), size.height()) - QRegion(warClip.toFillPolygon().toPolygon());
flag.paintEngine()->setSystemClip(systemClip);
}
QPainter painter(&flag);
painter.fillRect(QRect(QPoint(), size), Qt::red); // Fill image background with red.
painter.setClipRegion(outerCross); // Limit widget painting to inside the outer cross.
// Here's the widget that's supposed to draw the inner/outer cross of the flag.
// The outer cross (white) should be drawn when the background is auto-filled, and
// the inner cross (blue) should be drawn in the paintEvent.
class MyWidget : public QWidget
{ public:
void paintEvent(QPaintEvent *)
{
QPainter painter(this);
// Be evil and try to paint outside the outer cross. This should not be
// possible since the shared painter is clipped to the outer cross.
painter.setClipRect(0, 0, 60, 60, Qt::ReplaceClip);
painter.fillRect(rect(), Qt::green);
painter.setClipRegion(clip, Qt::ReplaceClip);
painter.fillRect(rect(), Qt::blue);
}
QRegion clip;
};
MyWidget widget;
widget.clip = innerCross;
widget.setFixedSize(size);
widget.setPalette(Qt::white);
widget.setAutoFillBackground(true);
widget.render(&painter);
#ifdef RENDER_DEBUG
flag.save("flag.png");
#endif
// Let's make sure we got a Norwegian flag.
for (int i = 0; i < flag.height(); ++i) {
for (int j = 0; j < flag.width(); ++j) {
const QPoint pixel(j, i);
const QRgb pixelValue = flag.pixel(pixel);
if (useSystemClip && !systemClip.contains(pixel))
QCOMPARE(pixelValue, QColor(Qt::transparent).rgba());
else if (redArea.contains(pixel))
QCOMPARE(pixelValue, QColor(Qt::red).rgba());
else if (whiteArea.contains(pixel))
QCOMPARE(pixelValue, QColor(Qt::white).rgba());
else
QCOMPARE(pixelValue, QColor(Qt::blue).rgba());
}
}
}
void tst_QWidget::render_task252837()
{
QWidget widget;
widget.resize(200, 200);
QPixmap pixmap(widget.size());
QPainter painter(&pixmap);
// Please do not crash.
widget.render(&painter);
}
void tst_QWidget::render_worldTransform()
{
class MyWidget : public QWidget
{ public:
void paintEvent(QPaintEvent *)
{
QPainter painter(this);
// Make sure world transform is identity.
QCOMPARE(painter.worldTransform(), QTransform());
// Make sure device transform is correct.
const QPoint widgetOffset = geometry().topLeft();
QTransform expectedDeviceTransform = QTransform::fromTranslate(105, 5);
expectedDeviceTransform.rotate(90);
expectedDeviceTransform.translate(widgetOffset.x(), widgetOffset.y());
QCOMPARE(painter.deviceTransform(), expectedDeviceTransform);
// Set new world transform.
QTransform newWorldTransform = QTransform::fromTranslate(10, 10);
newWorldTransform.rotate(90);
painter.setWorldTransform(newWorldTransform);
QCOMPARE(painter.worldTransform(), newWorldTransform);
// Again, check device transform.
expectedDeviceTransform.translate(10, 10);
expectedDeviceTransform.rotate(90);
QCOMPARE(painter.deviceTransform(), expectedDeviceTransform);
painter.fillRect(QRect(0, 0, 20, 10), Qt::green);
}
};
MyWidget widget;
widget.setFixedSize(100, 100);
widget.setPalette(Qt::red);
widget.setAutoFillBackground(true);
MyWidget child;
child.setParent(&widget);
child.move(50, 50);
child.setFixedSize(50, 50);
child.setPalette(Qt::blue);
child.setAutoFillBackground(true);
QImage image(QSize(110, 110), QImage::Format_RGB32);
image.fill(QColor(Qt::black).rgb());
QPainter painter(&image);
painter.translate(105, 5);
painter.rotate(90);
const QTransform worldTransform = painter.worldTransform();
const QTransform deviceTransform = painter.deviceTransform();
// Render widgets onto image.
widget.render(&painter);
#ifdef RENDER_DEBUG
image.save("render_worldTransform_image.png");
#endif
// Ensure the transforms are unchanged after render.
QCOMPARE(painter.worldTransform(), painter.worldTransform());
QCOMPARE(painter.deviceTransform(), painter.deviceTransform());
painter.end();
// Paint expected image.
QImage expected(QSize(110, 110), QImage::Format_RGB32);
expected.fill(QColor(Qt::black).rgb());
QPainter expectedPainter(&expected);
expectedPainter.translate(105, 5);
expectedPainter.rotate(90);
expectedPainter.save();
expectedPainter.fillRect(widget.rect(),Qt::red);
expectedPainter.translate(10, 10);
expectedPainter.rotate(90);
expectedPainter.fillRect(QRect(0, 0, 20, 10), Qt::green);
expectedPainter.restore();
expectedPainter.translate(50, 50);
expectedPainter.fillRect(child.rect(),Qt::blue);
expectedPainter.translate(10, 10);
expectedPainter.rotate(90);
expectedPainter.fillRect(QRect(0, 0, 20, 10), Qt::green);
expectedPainter.end();
#ifdef RENDER_DEBUG
expected.save("render_worldTransform_expected.png");
#endif
QCOMPARE(image, expected);
}
void tst_QWidget::setContentsMargins()
{
QLabel label("why does it always rain on me?");
QSize oldSize = label.sizeHint();
label.setFrameStyle(QFrame::Sunken | QFrame::Box);
QSize newSize = label.sizeHint();
QVERIFY(oldSize != newSize);
QLabel label2("why does it always rain on me?");
label2.show();
label2.setFrameStyle(QFrame::Sunken | QFrame::Box);
QCOMPARE(newSize, label2.sizeHint());
QLabel label3("why does it always rain on me?");
label3.setFrameStyle(QFrame::Sunken | QFrame::Box);
QCOMPARE(newSize, label3.sizeHint());
}
void tst_QWidget::moveWindowInShowEvent_data()
{
QTest::addColumn<QPoint>("initial");
QTest::addColumn<QPoint>("position");
QPoint p = QApplication::desktop()->availableGeometry().topLeft();
QTest::newRow("1") << p << (p + QPoint(10, 10));
QTest::newRow("2") << (p + QPoint(10,10)) << p;
}
void tst_QWidget::moveWindowInShowEvent()
{
#ifdef Q_OS_IRIX
QSKIP("4DWM issues on IRIX makes this test fail", SkipAll);
#endif
QFETCH(QPoint, initial);
QFETCH(QPoint, position);
class MoveWindowInShowEventWidget : public QWidget
{
public:
QPoint position;
void showEvent(QShowEvent *)
{
move(position);
}
};
MoveWindowInShowEventWidget widget;
widget.resize(QSize(qApp->desktop()->availableGeometry().size() / 3).expandedTo(QSize(1, 1)));
// move to this position in showEvent()
widget.position = position;
// put the widget in it's starting position
widget.move(initial);
QCOMPARE(widget.pos(), initial);
// show it
widget.show();
#ifdef Q_WS_X11
qt_x11_wait_for_window_manager(&widget);
#endif
QTest::qWait(100);
// it should have moved
QCOMPARE(widget.pos(), position);
}
void tst_QWidget::repaintWhenChildDeleted()
{
#ifdef Q_WS_WIN
if (QSysInfo::WindowsVersion & QSysInfo::WV_VISTA) {
QTest::qWait(1000);
}
#endif
ColorWidget w(0, Qt::red);
#if !defined(Q_OS_WINCE) && !defined(Q_WS_S60)
QPoint startPoint = QApplication::desktop()->availableGeometry(&w).topLeft();
startPoint.rx() += 50;
startPoint.ry() += 50;
w.setGeometry(QRect(startPoint, QSize(100, 100)));
#else
w.setGeometry(60, 60, 110, 110);
#endif
w.show();
QTest::qWaitForWindowShown(&w);
QTest::qWait(10);
QTRY_COMPARE(w.r, QRegion(w.rect()));
w.r = QRegion();
{
const QPoint tlwOffset = w.geometry().topLeft();
ColorWidget child(&w, Qt::blue);
child.setGeometry(10, 10, 10, 10);
child.show();
QTest::qWait(10);
QTRY_COMPARE(child.r, QRegion(child.rect()));
w.r = QRegion();
}
QTest::qWait(10);
QTRY_COMPARE(w.r, QRegion(10, 10, 10, 10));
}
// task 175114
void tst_QWidget::hideOpaqueChildWhileHidden()
{
ColorWidget w(0, Qt::red);
#if !defined(Q_OS_WINCE) && !defined(Q_WS_S60)
QPoint startPoint = QApplication::desktop()->availableGeometry(&w).topLeft();
startPoint.rx() += 50;
startPoint.ry() += 50;
w.setGeometry(QRect(startPoint, QSize(100, 100)));
#else
w.setGeometry(60, 60, 110, 110);
#endif
ColorWidget child(&w, Qt::blue);
child.setGeometry(10, 10, 80, 80);
ColorWidget child2(&child, Qt::white);
child2.setGeometry(10, 10, 60, 60);
w.show();
QTest::qWaitForWindowShown(&w);
QTest::qWait(10);
QTRY_COMPARE(child2.r, QRegion(child2.rect()));
child.r = QRegion();
child2.r = QRegion();
w.r = QRegion();
child.hide();
child2.hide();
QTest::qWait(100);
QCOMPARE(w.r, QRegion(child.geometry()));
child.show();
QTest::qWait(100);
QCOMPARE(child.r, QRegion(child.rect()));
QCOMPARE(child2.r, QRegion());
}
void tst_QWidget::updateWhileMinimized()
{
#if defined(Q_OS_WINCE) || defined(Q_WS_QWS)
QSKIP("This test doesn't make sense without support for showMinimized()", SkipAll);
#endif
UpdateWidget widget;
// Filter out activation change and focus events to avoid update() calls in QWidget.
widget.updateOnActivationChangeAndFocusIn = false;
widget.reset();
widget.show();
QTest::qWaitForWindowShown(&widget);
QApplication::processEvents();
QTRY_VERIFY(widget.numPaintEvents > 0);
QTest::qWait(150);
// Minimize window.
widget.showMinimized();
QTest::qWait(110);
widget.reset();
// The widget is not visible on the screen (but isVisible() still returns true).
// Make sure update requests are discarded until the widget is shown again.
widget.update(0, 0, 50, 50);
QTest::qWait(10);
QCOMPARE(widget.numPaintEvents, 0);
// Restore window.
widget.showNormal();
QTest::qWait(30);
QTRY_COMPARE(widget.numPaintEvents, 1);
QCOMPARE(widget.paintedRegion, QRegion(0, 0, 50, 50));
}
#if defined(Q_WS_WIN) || defined(Q_WS_X11)
class PaintOnScreenWidget: public QWidget
{
public:
PaintOnScreenWidget(QWidget *parent = 0, Qt::WindowFlags f = 0)
:QWidget(parent, f)
{
}
#if defined(Q_WS_WIN)
// This is the only way to enable PaintOnScreen on Windows.
QPaintEngine * paintEngine () const {return 0;}
#endif
};
void tst_QWidget::alienWidgets()
{
qApp->setAttribute(Qt::AA_DontCreateNativeWidgetSiblings);
QWidget parent;
QWidget child(&parent);
QWidget grandChild(&child);
QWidget greatGrandChild(&grandChild);
parent.show();
#ifdef Q_WS_X11
qt_x11_wait_for_window_manager(&parent);
#endif
// Verify that the WA_WState_Created attribute is set
// and the top-level is the only native window.
QVERIFY(parent.testAttribute(Qt::WA_WState_Created));
QVERIFY(parent.internalWinId());
QVERIFY(child.testAttribute(Qt::WA_WState_Created));
QVERIFY(!child.internalWinId());
QVERIFY(grandChild.testAttribute(Qt::WA_WState_Created));
QVERIFY(!grandChild.internalWinId());
QVERIFY(greatGrandChild.testAttribute(Qt::WA_WState_Created));
QVERIFY(!greatGrandChild.internalWinId());
// Enforce native windows all the way up in the parent hierarchy
// if not WA_DontCreateNativeAncestors is set.
grandChild.setAttribute(Qt::WA_DontCreateNativeAncestors);
greatGrandChild.setAttribute(Qt::WA_NativeWindow);
QVERIFY(greatGrandChild.internalWinId());
QVERIFY(grandChild.internalWinId());
QVERIFY(!child.internalWinId());
{
// Ensure that hide() on an ancestor of a widget with
// Qt::WA_DontCreateNativeAncestors still gets unmapped
QWidget window;
QWidget widget(&window);
QWidget child(&widget);
child.setAttribute(Qt::WA_NativeWindow);
child.setAttribute(Qt::WA_DontCreateNativeAncestors);
window.show();
QVERIFY(child.testAttribute(Qt::WA_Mapped));
widget.hide();
QVERIFY(!child.testAttribute(Qt::WA_Mapped));
}
// Enforce a native window when calling QWidget::winId.
QVERIFY(child.winId());
QVERIFY(child.internalWinId());
// Check that paint on screen widgets (incl. children) are native.
PaintOnScreenWidget paintOnScreen(&parent);
QWidget paintOnScreenChild(&paintOnScreen);
paintOnScreen.show();
QVERIFY(paintOnScreen.testAttribute(Qt::WA_WState_Created));
QVERIFY(!paintOnScreen.testAttribute(Qt::WA_NativeWindow));
QVERIFY(!paintOnScreen.internalWinId());
QVERIFY(!paintOnScreenChild.testAttribute(Qt::WA_NativeWindow));
QVERIFY(!paintOnScreenChild.internalWinId());
paintOnScreen.setAttribute(Qt::WA_PaintOnScreen);
QVERIFY(paintOnScreen.testAttribute(Qt::WA_NativeWindow));
QVERIFY(paintOnScreen.internalWinId());
QVERIFY(paintOnScreenChild.testAttribute(Qt::WA_NativeWindow));
QVERIFY(paintOnScreenChild.internalWinId());
// Check that widgets with the Qt::MSWindowsOwnDC attribute set
// are native.
QWidget msWindowsOwnDC(&parent, Qt::MSWindowsOwnDC);
msWindowsOwnDC.show();
QVERIFY(msWindowsOwnDC.testAttribute(Qt::WA_WState_Created));
QVERIFY(msWindowsOwnDC.testAttribute(Qt::WA_NativeWindow));
QVERIFY(msWindowsOwnDC.internalWinId());
{ // Enforce a native window when calling QWidget::handle() (on X11) or QWidget::getDC() (on Windows).
QWidget widget(&parent);
widget.show();
QVERIFY(widget.testAttribute(Qt::WA_WState_Created));
QVERIFY(!widget.internalWinId());
#ifdef Q_WS_X11
widget.handle();
#else
widget.getDC();
#endif
QVERIFY(widget.internalWinId());
}
#ifdef Q_WS_X11
#ifndef QT_NO_XRENDER
{ // Enforce a native window when calling QWidget::x11PictureHandle().
QWidget widget(&parent);
widget.show();
QVERIFY(widget.testAttribute(Qt::WA_WState_Created));
QVERIFY(!widget.internalWinId());
widget.x11PictureHandle();
QVERIFY(widget.internalWinId());
}
#endif
{ // Make sure we don't create native windows when setting Qt::WA_X11NetWmWindowType attributes
// on alien widgets (see task 194231).
QWidget dummy;
QVERIFY(dummy.winId());
QWidget widget(&dummy);
widget.setAttribute(Qt::WA_X11NetWmWindowTypeToolBar);
QVERIFY(!widget.internalWinId());
}
#endif
{ // Make sure we create native ancestors when setting Qt::WA_PaintOnScreen before show().
QWidget topLevel;
QWidget child(&topLevel);
QWidget grandChild(&child);
PaintOnScreenWidget greatGrandChild(&grandChild);
greatGrandChild.setAttribute(Qt::WA_PaintOnScreen);
QVERIFY(!child.internalWinId());
QVERIFY(!grandChild.internalWinId());
QVERIFY(!greatGrandChild.internalWinId());
topLevel.show();
QVERIFY(child.internalWinId());
QVERIFY(grandChild.internalWinId());
QVERIFY(greatGrandChild.internalWinId());
}
{ // Ensure that widgets reparented into Qt::WA_PaintOnScreen widgets become native.
QWidget topLevel;
QWidget *widget = new PaintOnScreenWidget(&topLevel);
widget->setAttribute(Qt::WA_PaintOnScreen);
QWidget *child = new QWidget;
QWidget *dummy = new QWidget(child);
QWidget *grandChild = new QWidget(child);
QWidget *dummy2 = new QWidget(grandChild);
child->setParent(widget);
QVERIFY(!topLevel.internalWinId());
QVERIFY(!child->internalWinId());
QVERIFY(!dummy->internalWinId());
QVERIFY(!grandChild->internalWinId());
QVERIFY(!dummy2->internalWinId());
topLevel.show();
QVERIFY(topLevel.internalWinId());
QVERIFY(widget->testAttribute(Qt::WA_NativeWindow));
QVERIFY(child->internalWinId());
QVERIFY(child->testAttribute(Qt::WA_NativeWindow));
QVERIFY(!child->testAttribute(Qt::WA_PaintOnScreen));
QVERIFY(!dummy->internalWinId());
QVERIFY(!dummy->testAttribute(Qt::WA_NativeWindow));
QVERIFY(!grandChild->internalWinId());
QVERIFY(!grandChild->testAttribute(Qt::WA_NativeWindow));
QVERIFY(!dummy2->internalWinId());
QVERIFY(!dummy2->testAttribute(Qt::WA_NativeWindow));
}
{ // Ensure that ancestors of a Qt::WA_PaintOnScreen widget stay native
// if they are re-created (typically in QWidgetPrivate::setParent_sys) (task 210822).
QWidget window;
QWidget child(&window);
QWidget grandChild;
grandChild.setWindowTitle("This causes the widget to be created");
PaintOnScreenWidget paintOnScreenWidget;
paintOnScreenWidget.setAttribute(Qt::WA_PaintOnScreen);
paintOnScreenWidget.setParent(&grandChild);
grandChild.setParent(&child);
window.show();
QVERIFY(window.internalWinId());
QVERIFY(child.internalWinId());
QVERIFY(child.testAttribute(Qt::WA_NativeWindow));
QVERIFY(grandChild.internalWinId());
QVERIFY(grandChild.testAttribute(Qt::WA_NativeWindow));
QVERIFY(paintOnScreenWidget.internalWinId());
QVERIFY(paintOnScreenWidget.testAttribute(Qt::WA_NativeWindow));
}
{ // Ensure that all siblings are native unless Qt::AA_DontCreateNativeWidgetSiblings is set.
qApp->setAttribute(Qt::AA_DontCreateNativeWidgetSiblings, false);
QWidget mainWindow;
QWidget *toolBar = new QWidget(&mainWindow);
QWidget *dockWidget = new QWidget(&mainWindow);
QWidget *centralWidget = new QWidget(&mainWindow);
QWidget *button = new QWidget(centralWidget);
QWidget *mdiArea = new QWidget(centralWidget);
QWidget *horizontalScroll = new QWidget(mdiArea);
QWidget *verticalScroll = new QWidget(mdiArea);
QWidget *viewport = new QWidget(mdiArea);
viewport->setAttribute(Qt::WA_NativeWindow);
mainWindow.show();
// Ensure that the viewport and its siblings are native:
QVERIFY(verticalScroll->testAttribute(Qt::WA_NativeWindow));
QVERIFY(verticalScroll->testAttribute(Qt::WA_NativeWindow));
QVERIFY(horizontalScroll->testAttribute(Qt::WA_NativeWindow));
// Ensure that the mdi area and its siblings are native:
QVERIFY(mdiArea->testAttribute(Qt::WA_NativeWindow));
QVERIFY(button->testAttribute(Qt::WA_NativeWindow));
// Ensure that the central widget and its siblings are native:
QVERIFY(centralWidget->testAttribute(Qt::WA_NativeWindow));
QVERIFY(dockWidget->testAttribute(Qt::WA_NativeWindow));
QVERIFY(toolBar->testAttribute(Qt::WA_NativeWindow));
}
}
#endif // Q_WS_WIN / Q_WS_X11
class ASWidget : public QWidget
{
public:
ASWidget(QSize sizeHint, QSizePolicy sizePolicy, bool layout, bool hfwLayout, QWidget *parent = 0)
: QWidget(parent), mySizeHint(sizeHint)
{
setSizePolicy(sizePolicy);
if (layout) {
QSizePolicy sp = QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
sp.setHeightForWidth(hfwLayout);
QVBoxLayout *vbox = new QVBoxLayout;
vbox->setMargin(0);
vbox->addWidget(new ASWidget(sizeHint + QSize(30, 20), sp, false, false));
setLayout(vbox);
}
}
QSize sizeHint() const {
if (layout())
return layout()->totalSizeHint();
return mySizeHint;
}
int heightForWidth(int width) const {
if (sizePolicy().hasHeightForWidth()) {
return width * 2;
} else {
return -1;
}
}
QSize mySizeHint;
};
void tst_QWidget::adjustSize_data()
{
const int MagicW = 200;
const int MagicH = 100;
QTest::addColumn<QSize>("sizeHint");
QTest::addColumn<int>("hPolicy");
QTest::addColumn<int>("vPolicy");
QTest::addColumn<bool>("hfwSP");
QTest::addColumn<bool>("layout");
QTest::addColumn<bool>("hfwLayout");
QTest::addColumn<bool>("haveParent");
QTest::addColumn<QSize>("expectedSize");
QTest::newRow("1") << QSize(5, 6) << int(QSizePolicy::Minimum) << int(QSizePolicy::Expanding)
<< false << false << false << false << QSize(5, qMax(6, MagicH));
QTest::newRow("2") << QSize(5, 6) << int(QSizePolicy::Minimum) << int(QSizePolicy::Expanding)
<< true << false << false << false << QSize(5, qMax(10, MagicH));
QTest::newRow("3") << QSize(5, 6) << int(QSizePolicy::Minimum) << int(QSizePolicy::Expanding)
<< false << true << false << false << QSize(35, 26);
QTest::newRow("4") << QSize(5, 6) << int(QSizePolicy::Minimum) << int(QSizePolicy::Expanding)
<< false << true << true << false << QSize(35, 70);
QTest::newRow("5") << QSize(40001, 30001) << int(QSizePolicy::Minimum) << int(QSizePolicy::Expanding)
<< false << false << false << false << QSize(100000, 100000);
QTest::newRow("6") << QSize(40001, 30001) << int(QSizePolicy::Minimum) << int(QSizePolicy::Expanding)
<< true << false << false << false << QSize(100000, 100000);
QTest::newRow("7") << QSize(40001, 30001) << int(QSizePolicy::Minimum) << int(QSizePolicy::Expanding)
<< false << true << false << false << QSize(100000, 100000);
QTest::newRow("8") << QSize(40001, 30001) << int(QSizePolicy::Minimum) << int(QSizePolicy::Expanding)
<< false << true << true << false << QSize(100000, 100000);
QTest::newRow("9") << QSize(5, 6) << int(QSizePolicy::Expanding) << int(QSizePolicy::Minimum)
<< true << false << false << false << QSize(qMax(5, MagicW), 10);
QTest::newRow("1c") << QSize(5, 6) << int(QSizePolicy::Minimum) << int(QSizePolicy::Expanding)
<< false << false << false << true << QSize(5, 6);
QTest::newRow("2c") << QSize(5, 6) << int(QSizePolicy::Minimum) << int(QSizePolicy::Expanding)
<< true << false << false << true << QSize(5, 6 /* or 10 would be OK too, since hfw contradicts sizeHint() */);
QTest::newRow("3c") << QSize(5, 6) << int(QSizePolicy::Minimum) << int(QSizePolicy::Expanding)
<< false << true << false << true << QSize(35, 26);
QTest::newRow("4c") << QSize(5, 6) << int(QSizePolicy::Minimum) << int(QSizePolicy::Expanding)
<< false << true << true << true << QSize(35, 70);
QTest::newRow("5c") << QSize(40001, 30001) << int(QSizePolicy::Minimum) << int(QSizePolicy::Expanding)
<< false << false << false << true << QSize(40001, 30001);
QTest::newRow("6c") << QSize(40001, 30001) << int(QSizePolicy::Minimum) << int(QSizePolicy::Expanding)
<< true << false << false << true << QSize(40001, 30001 /* or 80002 would be OK too, since hfw contradicts sizeHint() */);
QTest::newRow("7c") << QSize(40001, 30001) << int(QSizePolicy::Minimum) << int(QSizePolicy::Expanding)
<< false << true << false << true << QSize(40001 + 30, 30001 + 20);
QTest::newRow("8c") << QSize(40001, 30001) << int(QSizePolicy::Minimum) << int(QSizePolicy::Expanding)
<< false << true << true << true << QSize(40001 + 30, 80002 + 60);
QTest::newRow("9c") << QSize(5, 6) << int(QSizePolicy::Expanding) << int(QSizePolicy::Minimum)
<< true << false << false << true << QSize(5, 6);
}
void tst_QWidget::adjustSize()
{
QFETCH(QSize, sizeHint);
QFETCH(int, hPolicy);
QFETCH(int, vPolicy);
QFETCH(bool, hfwSP);
QFETCH(bool, layout);
QFETCH(bool, hfwLayout);
QFETCH(bool, haveParent);
QFETCH(QSize, expectedSize);
QWidget *parent = new QWidget;
QSizePolicy sp = QSizePolicy(QSizePolicy::Policy(hPolicy), QSizePolicy::Policy(vPolicy));
sp.setHeightForWidth(hfwSP);
QWidget *child = new ASWidget(sizeHint, sp, layout, hfwLayout, haveParent ? parent : 0);
child->resize(123, 456);
child->adjustSize();
if (expectedSize == QSize(100000, 100000)) {
QVERIFY(child->size().width() < sizeHint.width());
QVERIFY(child->size().height() < sizeHint.height());
} else {
#if defined (Q_OS_WINCE)
if (!haveParent) {
const QRect& desktopRect = qApp->desktop()->availableGeometry();
expectedSize.setWidth(qMin(expectedSize.width(), desktopRect.width()));
expectedSize.setHeight(qMin(expectedSize.height(), desktopRect.height()));
}
#endif
QCOMPARE(child->size(), expectedSize);
}
delete parent;
}
class TestLayout : public QVBoxLayout
{
Q_OBJECT
public:
TestLayout(QWidget *w = 0) : QVBoxLayout(w)
{
invalidated = false;
}
void invalidate()
{
invalidated = true;
}
bool invalidated;
};
void tst_QWidget::updateGeometry_data()
{
QTest::addColumn<QSize>("minSize");
QTest::addColumn<bool>("shouldInvalidate");
QTest::addColumn<QSize>("maxSize");
QTest::addColumn<bool>("shouldInvalidate2");
QTest::addColumn<int>("verticalSizePolicy");
QTest::addColumn<bool>("shouldInvalidate3");
QTest::addColumn<bool>("setVisible");
QTest::addColumn<bool>("shouldInvalidate4");
QTest::newRow("setMinimumSize")
<< QSize(100, 100) << true
<< QSize() << false
<< int(QSizePolicy::Preferred) << false
<< true << false;
QTest::newRow("setMaximumSize")
<< QSize() << false
<< QSize(100, 100) << true
<< int(QSizePolicy::Preferred) << false
<< true << false;
QTest::newRow("setMinimumSize, then maximumSize to a different size")
<< QSize(100, 100) << true
<< QSize(300, 300) << true
<< int(QSizePolicy::Preferred) << false
<< true << false;
QTest::newRow("setMinimumSize, then maximumSize to the same size")
<< QSize(100, 100) << true
<< QSize(100, 100) << true
<< int(QSizePolicy::Preferred) << false
<< true << false;
QTest::newRow("setMinimumSize, then maximumSize to the same size and then hide it")
<< QSize(100, 100) << true
<< QSize(100, 100) << true
<< int(QSizePolicy::Preferred) << false
<< false << true;
QTest::newRow("Change sizePolicy")
<< QSize() << false
<< QSize() << false
<< int(QSizePolicy::Minimum) << true
<< true << false;
}
void tst_QWidget::updateGeometry()
{
QFETCH(QSize, minSize);
QFETCH(bool, shouldInvalidate);
QFETCH(QSize, maxSize);
QFETCH(bool, shouldInvalidate2);
QFETCH(int, verticalSizePolicy);
QFETCH(bool, shouldInvalidate3);
QFETCH(bool, setVisible);
QFETCH(bool, shouldInvalidate4);
QWidget parent;
parent.resize(200, 200);
TestLayout *lout = new TestLayout();
parent.setLayout(lout);
QWidget *child = new QWidget(&parent);
lout->addWidget(child);
parent.show();
QApplication::processEvents();
lout->invalidated = false;
if (minSize.isValid())
child->setMinimumSize(minSize);
QCOMPARE(lout->invalidated, shouldInvalidate);
lout->invalidated = false;
if (maxSize.isValid())
child->setMaximumSize(maxSize);
QCOMPARE(lout->invalidated, shouldInvalidate2);
lout->invalidated = false;
child->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, (QSizePolicy::Policy)verticalSizePolicy));
if (shouldInvalidate3)
QCOMPARE(lout->invalidated, true);
lout->invalidated = false;
if (!setVisible)
child->setVisible(false);
QCOMPARE(lout->invalidated, shouldInvalidate4);
}
void tst_QWidget::sendUpdateRequestImmediately()
{
#ifdef Q_WS_MAC
if (!QApplicationPrivate::graphicsSystem())
QSKIP("We only send update requests on the Mac when passing -graphicssystem", SkipAll);
#endif
UpdateWidget updateWidget;
updateWidget.show();
#ifdef Q_WS_X11
qt_x11_wait_for_window_manager(&updateWidget);
#endif
qApp->processEvents();
#ifdef Q_WS_QWS
QApplication::sendPostedEvents(); //glib workaround
#endif
updateWidget.reset();
QCOMPARE(updateWidget.numUpdateRequestEvents, 0);
updateWidget.repaint();
QCOMPARE(updateWidget.numUpdateRequestEvents, 1);
}
class RedirectedWidget : public QWidget
{
protected:
void paintEvent(QPaintEvent *)
{
// Verify that the widget has a redirection set. The widget is redirected to
// the backing store on all platforms using it; otherwise to itself if the wrect
// does not start in (0, 0) or it has a mask set.
QPaintDevice *oldRedirection = QPainter::redirected(this);
#ifndef Q_WS_MAC
QVERIFY(oldRedirection);
#endif
QImage image(size(), QImage::Format_RGB32);
image.fill(Qt::blue);
{
QPainter painter(this);
QCOMPARE(painter.device(), static_cast<QPaintDevice *>(this));
}
QPainter::setRedirected(this, &image);
QCOMPARE(QPainter::redirected(this), static_cast<QPaintDevice *>(&image));
QPainter painter(this);
painter.fillRect(rect(), Qt::red);
QPainter::restoreRedirected(this);
QCOMPARE(QPainter::redirected(this), oldRedirection);
for (int i = 0; i < image.height(); ++i)
for (int j = 0; j < image.width(); ++j)
QCOMPARE(image.pixel(j, i), QColor(Qt::red).rgb());
}
};
// Test to make sure we're compatible in the particular case where QPainter::setRedirected
// actually works. It has been broken for all other cases since Qt 4.1.4 (backing store).
// QWidget::render is the modern and more powerful way of doing the same.
void tst_QWidget::painterRedirection()
{
RedirectedWidget widget;
// Set FramelessWindowHint and mask to trigger internal painter redirection on the Mac.
widget.setWindowFlags(widget.windowFlags() | Qt::FramelessWindowHint);
widget.setMask(QRect(10, 10, 50, 50));
widget.setFixedSize(100, 200);
widget.show();
#ifdef Q_WS_X11
qt_x11_wait_for_window_manager(&widget);
#endif
QPixmap pixmap(widget.size());
QPainter::setRedirected(&widget, &pixmap, QPoint());
widget.repaint();
QCOMPARE(QPainter::redirected(&widget), static_cast<QPaintDevice *>(&pixmap));
}
void tst_QWidget::doubleRepaint()
{
#ifdef Q_OS_IRIX
QSKIP("4DWM issues on IRIX makes this test fail", SkipAll);
#elif defined(Q_WS_MAC)
if (!macHasAccessToWindowsServer())
QSKIP("Not having window server access causes the wrong number of repaints to be issues", SkipAll);
#endif
UpdateWidget widget;
widget.setFocusPolicy(Qt::StrongFocus);
// Filter out activation change and focus events to avoid update() calls in QWidget.
widget.updateOnActivationChangeAndFocusIn = false;
// Show: 1 repaint
int expectedRepaints = 1;
widget.show();
QTest::qWaitForWindowShown(&widget);
QTest::qWait(10);
QTRY_COMPARE(widget.numPaintEvents, expectedRepaints);
widget.numPaintEvents = 0;
// Minmize: Should not trigger a repaint.
widget.showMinimized();
QTest::qWait(10);
QCOMPARE(widget.numPaintEvents, 0);
widget.numPaintEvents = 0;
// Restore: Should not trigger a repaint.
widget.showNormal();
QTest::qWaitForWindowShown(&widget);
QTest::qWait(10);
QCOMPARE(widget.numPaintEvents, 0);
}
#ifndef Q_WS_MAC
// This test only makes sense on the Mac when passing -graphicssystem.
void tst_QWidget::resizeInPaintEvent()
{
QWidget window;
UpdateWidget widget(&window);
window.show();
QTest::qWaitForWindowShown(&window);
QTRY_VERIFY(widget.numPaintEvents > 0);
widget.reset();
QCOMPARE(widget.numPaintEvents, 0);
widget.resizeInPaintEvent = true;
// This will call resize in the paintEvent, which in turn will call
// invalidateBuffer() and a new update request should be posted.
widget.repaint();
QCOMPARE(widget.numPaintEvents, 1);
widget.numPaintEvents = 0;
QTest::qWait(10);
// Make sure the resize triggers another update.
QTRY_COMPARE(widget.numPaintEvents, 1);
}
void tst_QWidget::opaqueChildren()
{
QWidget widget;
widget.resize(200, 200);
QWidget child(&widget);
child.setGeometry(-700, -700, 200, 200);
QWidget grandChild(&child);
grandChild.resize(200, 200);
QWidget greatGrandChild(&grandChild);
greatGrandChild.setGeometry(50, 50, 200, 200);
greatGrandChild.setPalette(Qt::red);
greatGrandChild.setAutoFillBackground(true); // Opaque child widget.
widget.show();
#ifdef Q_WS_X11
qt_x11_wait_for_window_manager(&widget);
#endif
QTest::qWait(100);
// Child, grandChild and greatGrandChild are outside the ancestor clip.
QRegion expectedOpaqueRegion(50, 50, 150, 150);
QCOMPARE(qt_widget_private(&grandChild)->getOpaqueChildren(), expectedOpaqueRegion);
// Now they are all inside the ancestor clip.
child.setGeometry(50, 50, 150, 150);
QCOMPARE(qt_widget_private(&grandChild)->getOpaqueChildren(), expectedOpaqueRegion);
// Set mask on greatGrandChild.
const QRegion mask(10, 10, 50, 50);
greatGrandChild.setMask(mask);
expectedOpaqueRegion &= mask.translated(50, 50);
QCOMPARE(qt_widget_private(&grandChild)->getOpaqueChildren(), expectedOpaqueRegion);
// Make greatGrandChild "transparent".
greatGrandChild.setAutoFillBackground(false);
QCOMPARE(qt_widget_private(&grandChild)->getOpaqueChildren(), QRegion());
}
#endif
class MaskSetWidget : public QWidget
{
Q_OBJECT
public:
MaskSetWidget(QWidget* p =0)
: QWidget(p) {}
void paintEvent(QPaintEvent* event) {
QPainter p(this);
paintedRegion += event->region();
foreach(QRect r, event->region().rects())
p.fillRect(r, Qt::red);
}
void resizeEvent(QResizeEvent*) {
setMask(QRegion(QRect(0, 0, width(), 10).normalized()));
}
QRegion paintedRegion;
public slots:
void resizeDown() {
setGeometry(QRect(0, 50, 50, 50));
}
void resizeUp() {
setGeometry(QRect(0, 50, 150, 50));
}
};
void tst_QWidget::setMaskInResizeEvent()
{
UpdateWidget w;
w.reset();
w.resize(200, 200);
w.setWindowFlags(Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint);
w.raise();
MaskSetWidget testWidget(&w);
testWidget.setGeometry(0, 0, 100, 100);
testWidget.setMask(QRegion(QRect(0,0,100,10)));
testWidget.show();
w.show();
QTest::qWaitForWindowShown(&w);
QTest::qWait(30);
QTRY_VERIFY(w.numPaintEvents > 0);
w.reset();
testWidget.paintedRegion = QRegion();
QTimer::singleShot(0, &testWidget, SLOT(resizeDown()));
QTest::qWait(100);
QRegion expectedParentUpdate(0, 0, 100, 10); // Old testWidget area.
expectedParentUpdate += testWidget.geometry(); // New testWidget area.
QCOMPARE(w.paintedRegion, expectedParentUpdate);
QCOMPARE(testWidget.paintedRegion, testWidget.mask());
testWidget.paintedRegion = QRegion();
// Now resize the widget again, but in the oposite direction
QTimer::singleShot(0, &testWidget, SLOT(resizeUp()));
QTest::qWait(100);
QTRY_COMPARE(testWidget.paintedRegion, testWidget.mask());
}
class MoveInResizeWidget : public QWidget
{
Q_OBJECT
public:
MoveInResizeWidget(QWidget* p = 0)
: QWidget(p)
{
setWindowFlags(Qt::FramelessWindowHint);
}
void resizeEvent(QResizeEvent*) {
move(QPoint(100,100));
static bool firstTime = true;
if (firstTime)
QTimer::singleShot(250, this, SLOT(resizeMe()));
firstTime = false;
}
public slots:
void resizeMe() {
resize(100, 100);
}
};
void tst_QWidget::moveInResizeEvent()
{
MoveInResizeWidget testWidget;
testWidget.setGeometry(50, 50, 200, 200);
testWidget.show();
QTest::qWaitForWindowShown(&testWidget);
QTest::qWait(300);
QRect expectedGeometry(100,100, 100, 100);
QTRY_COMPARE(testWidget.geometry(), expectedGeometry);
}
#if defined(Q_WS_WIN) || defined(Q_WS_X11)
void tst_QWidget::immediateRepaintAfterShow()
{
UpdateWidget widget;
widget.show();
qApp->processEvents();
// On X11 in particular, we are now waiting for a MapNotify event before
// syncing the backing store. However, if someone request a repaint()
// we must repaint immediately regardless of the current state.
widget.numPaintEvents = 0;
widget.repaint();
QCOMPARE(widget.numPaintEvents, 1);
}
void tst_QWidget::immediateRepaintAfterInvalidateBuffer()
{
QWidget *widget = new UpdateWidget;
widget->show();
#ifdef Q_WS_X11
qt_x11_wait_for_window_manager(widget);
#endif
QTest::qWait(200);
static_cast<UpdateWidget *>(widget)->numPaintEvents = 0;
// Marks the area covered by the widget as dirty in the backing store and
// posts an UpdateRequest event.
qt_widget_private(widget)->invalidateBuffer(widget->rect());
QCOMPARE(static_cast<UpdateWidget *>(widget)->numPaintEvents, 0);
// The entire widget is already dirty, but this time we want to update immediately
// by calling repaint(), and thus we have to repaint the widget and not wait for
// the UpdateRequest to be sent when we get back to the event loop.
widget->repaint();
QCOMPARE(static_cast<UpdateWidget *>(widget)->numPaintEvents, 1);
delete widget;
}
#endif
void tst_QWidget::effectiveWinId()
{
QWidget parent;
QWidget child(&parent);
// Shouldn't crash.
QVERIFY(!parent.effectiveWinId());
QVERIFY(!child.effectiveWinId());
parent.show();
QVERIFY(parent.effectiveWinId());
QVERIFY(child.effectiveWinId());
}
void tst_QWidget::effectiveWinId2()
{
QWidget parent;
class MyWidget : public QWidget {
bool event(QEvent *e)
{
if (e->type() == QEvent::WinIdChange) {
// Shouldn't crash.
effectiveWinId();
}
return QWidget::event(e);
}
};
MyWidget child;
child.setParent(&parent);
parent.show();
child.setParent(0);
child.setParent(&parent);
}
class CustomWidget : public QWidget
{
public:
mutable int metricCallCount;
CustomWidget(QWidget *parent = 0) : QWidget(parent), metricCallCount(0) {}
virtual int metric(PaintDeviceMetric metric) const {
++metricCallCount;
return QWidget::metric(metric);
}
};
void tst_QWidget::customDpi()
{
QWidget *topLevel = new QWidget;
CustomWidget *custom = new CustomWidget(topLevel);
QWidget *child = new QWidget(custom);
custom->metricCallCount = 0;
topLevel->logicalDpiX();
QCOMPARE(custom->metricCallCount, 0);
custom->logicalDpiX();
QCOMPARE(custom->metricCallCount, 1);
child->logicalDpiX();
#ifdef Q_WS_S60
// QWidget::metric is not recursive on Symbian
QCOMPARE(custom->metricCallCount, 1);
#else
QCOMPARE(custom->metricCallCount, 2);
#endif
delete topLevel;
}
void tst_QWidget::customDpiProperty()
{
QWidget *topLevel = new QWidget;
QWidget *middle = new CustomWidget(topLevel);
QWidget *child = new QWidget(middle);
const int initialDpiX = topLevel->logicalDpiX();
const int initialDpiY = topLevel->logicalDpiY();
middle->setProperty("_q_customDpiX", 300);
middle->setProperty("_q_customDpiY", 400);
QCOMPARE(topLevel->logicalDpiX(), initialDpiX);
QCOMPARE(topLevel->logicalDpiY(), initialDpiY);
QCOMPARE(middle->logicalDpiX(), 300);
QCOMPARE(middle->logicalDpiY(), 400);
QCOMPARE(child->logicalDpiX(), 300);
QCOMPARE(child->logicalDpiY(), 400);
middle->setProperty("_q_customDpiX", QVariant());
middle->setProperty("_q_customDpiY", QVariant());
QCOMPARE(topLevel->logicalDpiX(), initialDpiX);
QCOMPARE(topLevel->logicalDpiY(), initialDpiY);
QCOMPARE(middle->logicalDpiX(), initialDpiX);
QCOMPARE(middle->logicalDpiY(), initialDpiY);
QCOMPARE(child->logicalDpiX(), initialDpiX);
QCOMPARE(child->logicalDpiY(), initialDpiY);
delete topLevel;
}
void tst_QWidget::quitOnCloseAttribute()
{
QWidget w;
QCOMPARE(w.testAttribute(Qt::WA_QuitOnClose), true);
w.setAttribute(Qt::WA_QuitOnClose, false);
QCOMPARE(w.testAttribute(Qt::WA_QuitOnClose), false);
w.setAttribute(Qt::WA_QuitOnClose);
w.setWindowFlags(Qt::Tool);
QCOMPARE(w.testAttribute(Qt::WA_QuitOnClose), false);
w.setAttribute(Qt::WA_QuitOnClose);
w.setWindowFlags(Qt::Popup);
QCOMPARE(w.testAttribute(Qt::WA_QuitOnClose), false);
w.setAttribute(Qt::WA_QuitOnClose);
w.setWindowFlags(Qt::ToolTip);
QCOMPARE(w.testAttribute(Qt::WA_QuitOnClose), false);
w.setAttribute(Qt::WA_QuitOnClose);
w.setWindowFlags(Qt::SplashScreen);
QCOMPARE(w.testAttribute(Qt::WA_QuitOnClose), false);
w.setAttribute(Qt::WA_QuitOnClose);
w.setWindowFlags(Qt::SubWindow);
QCOMPARE(w.testAttribute(Qt::WA_QuitOnClose), false);
w.setAttribute(Qt::WA_QuitOnClose);
w.setWindowFlags(Qt::Dialog);
QCOMPARE(w.testAttribute(Qt::WA_QuitOnClose), true);
w.show();
QCOMPARE(w.testAttribute(Qt::WA_QuitOnClose), true);
w.setWindowFlags(Qt::Tool);
QCOMPARE(w.testAttribute(Qt::WA_QuitOnClose), false);
}
void tst_QWidget::moveRect()
{
QWidget widget;
widget.setUpdatesEnabled(false);
QWidget child(&widget);
child.setUpdatesEnabled(false);
child.setAttribute(Qt::WA_OpaquePaintEvent);
widget.show();
QTest::qWait(200);
child.move(10, 10); // Don't crash.
}
#ifdef Q_WS_WIN
class GDIWidget : public QDialog
{
public:
GDIWidget() { setAttribute(Qt::WA_PaintOnScreen); }
QPaintEngine *paintEngine() const { return 0; }
void paintEvent(QPaintEvent *) {
HDC hdc = getDC();
SelectObject(hdc, CreateSolidBrush(RGB(255, 0, 0)));
Rectangle(hdc, 0, 0, 10, 10);
releaseDC(hdc);
QImage im = QPixmap::grabWindow(winId(), 0, 0, width(), height()).toImage();
color = im.pixel(1, 1);
accept();
}
QSize sizeHint() const {
return QSize(400, 300);
}
QColor color;
};
void tst_QWidget::gdiPainting()
{
GDIWidget w;
w.exec();
QCOMPARE(w.color, QColor(255, 0, 0));
}
void tst_QWidget::paintOnScreenPossible()
{
QWidget w1;
w1.setAttribute(Qt::WA_PaintOnScreen);
QVERIFY(!w1.testAttribute(Qt::WA_PaintOnScreen));
GDIWidget w2;
w2.setAttribute(Qt::WA_PaintOnScreen);
QVERIFY(w2.testAttribute(Qt::WA_PaintOnScreen));
}
#endif
void tst_QWidget::reparentStaticWidget()
{
QWidget window1;
QWidget *child = new QWidget(&window1);
child->setPalette(Qt::red);
child->setAutoFillBackground(true);
child->setAttribute(Qt::WA_StaticContents);
child->resize(100, 100);
QWidget *grandChild = new QWidget(child);
grandChild->setPalette(Qt::blue);
grandChild->setAutoFillBackground(true);
grandChild->resize(50, 50);
grandChild->setAttribute(Qt::WA_StaticContents);
window1.show();
QTest::qWaitForWindowShown(&window1);
QWidget window2;
window2.show();
QTest::qWaitForWindowShown(&window2);
QTest::qWait(20);
// Reparent into another top-level.
child->setParent(&window2);
child->show();
// Please don't crash.
window1.resize(window1.size() + QSize(2, 2));
QTest::qWait(20);
// Make sure we move all static children even though
// the reparented widget itself is non-static.
child->setAttribute(Qt::WA_StaticContents, false);
child->setParent(&window1);
child->show();
// Please don't crash.
window2.resize(window2.size() + QSize(2, 2));
QTest::qWait(20);
child->setParent(0);
child->show();
QTest::qWait(20);
// Please don't crash.
child->resize(child->size() + QSize(2, 2));
window2.resize(window2.size() + QSize(2, 2));
QTest::qWait(20);
QWidget *siblingOfGrandChild = new QWidget(child);
siblingOfGrandChild->show();
QTest::qWait(20);
// Nothing should happen when reparenting within the same top-level.
grandChild->setParent(siblingOfGrandChild);
grandChild->show();
QTest::qWait(20);
QWidget paintOnScreen;
paintOnScreen.setAttribute(Qt::WA_PaintOnScreen);
paintOnScreen.show();
QTest::qWaitForWindowShown(&paintOnScreen);
QTest::qWait(20);
child->setParent(&paintOnScreen);
child->show();
QTest::qWait(20);
// Please don't crash.
paintOnScreen.resize(paintOnScreen.size() + QSize(2, 2));
QTest::qWait(20);
}
void tst_QWidget::QTBUG6883_reparentStaticWidget2()
{
QMainWindow mw;
QDockWidget *one = new QDockWidget("one", &mw);
mw.addDockWidget(Qt::LeftDockWidgetArea, one , Qt::Vertical);
QWidget *child = new QWidget();
child->setPalette(Qt::red);
child->setAutoFillBackground(true);
child->setAttribute(Qt::WA_StaticContents);
child->resize(100, 100);
one->setWidget(child);
QToolBar *mainTools = mw.addToolBar("Main Tools");
mainTools->addWidget(new QLineEdit);
mw.show();
QTest::qWaitForWindowShown(&mw);
one->setFloating(true);
QTest::qWait(20);
//do not crash
}
#ifdef Q_WS_QWS
void tst_QWidget::updateOutsideSurfaceClip()
{
UpdateWidget widget;
widget.setWindowFlags(Qt::FramelessWindowHint);
widget.resize(100, 100);
widget.raise();
widget.show();
QTest::qWait(200);
widget.reset();
// Move widget partially outside buffer and change the surface clip.
widget.move(-50, 0);
QTest::qWait(100);
// Update region is outside the surface clip and should not trigger a repaint.
widget.update(0, 0, 20, 20);
QTest::qWait(100);
QCOMPARE(widget.numPaintEvents, 0);
// Now, move the widget back so that the update region is inside the clip
// and make sure we get a repaint of the dirty area.
widget.move(0, 0);
QTest::qWait(100);
QCOMPARE(widget.numPaintEvents, 1);
QCOMPARE(widget.paintedRegion, QRegion(0, 0, 20, 20));
}
#endif
class ColorRedWidget : public QWidget
{
public:
ColorRedWidget(QWidget *parent = 0)
: QWidget(parent, Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint | Qt::ToolTip)
{
}
void paintEvent(QPaintEvent *) {
QPainter p(this);
p.fillRect(rect(),Qt::red);
}
};
void tst_QWidget::translucentWidget()
{
QPixmap pm(16,16);
pm.fill(Qt::red);
ColorRedWidget label;
label.setFixedSize(16,16);
label.setAttribute(Qt::WA_TranslucentBackground);
label.move(qApp->desktop()->availableGeometry().topLeft());
label.show();
#ifdef Q_WS_X11
qt_x11_wait_for_window_manager(&label);
#endif
QTest::qWait(200);
QPixmap widgetSnapshot;
#ifdef Q_WS_WIN
QWidget *desktopWidget = QApplication::desktop()->screen(0);
if (QSysInfo::windowsVersion() >= QSysInfo::WV_VISTA)
widgetSnapshot = QPixmap::grabWindow(desktopWidget->winId(), 0,0, label.width(), label.height());
else
#endif
widgetSnapshot = QPixmap::grabWindow(label.winId());
QImage actual = widgetSnapshot.toImage().convertToFormat(QImage::Format_RGB32);
QImage expected = pm.toImage().convertToFormat(QImage::Format_RGB32);
QCOMPARE(actual.size(),expected.size());
QCOMPARE(actual,expected);
}
class MaskResizeTestWidget : public QWidget
{
Q_OBJECT
public:
MaskResizeTestWidget(QWidget* p =0)
: QWidget(p) {
setMask(QRegion(QRect(0, 0, 100, 100).normalized()));
}
void paintEvent(QPaintEvent* event) {
QPainter p(this);
paintedRegion += event->region();
foreach(QRect r, event->region().rects())
p.fillRect(r, Qt::red);
}
QRegion paintedRegion;
public slots:
void enlargeMask() {
QRegion newMask(QRect(0, 0, 150, 150).normalized());
setMask(newMask);
}
void shrinkMask() {
QRegion newMask(QRect(0, 0, 50, 50).normalized());
setMask(newMask);
}
};
void tst_QWidget::setClearAndResizeMask()
{
UpdateWidget topLevel;
topLevel.resize(150, 150);
topLevel.show();
QTest::qWaitForWindowShown(&topLevel);
QTRY_VERIFY(topLevel.numPaintEvents > 0);
topLevel.reset();
// Mask top-level widget
const QRegion topLevelMask(0, 0, 100, 100, QRegion::Ellipse);
topLevel.setMask(topLevelMask);
QCOMPARE(topLevel.mask(), topLevelMask);
#if defined(Q_WS_WIN) || defined(Q_WS_X11) // We don't control what's happening on other platforms.
// and ensure that the top-level doesn't get any update.
QCOMPARE(topLevel.numPaintEvents, 0);
#endif
topLevel.reset();
// Clear top-level mask
topLevel.clearMask();
QCOMPARE(topLevel.mask(), QRegion());
QTest::qWait(10);
QRegion outsideOldMask(topLevel.rect());
outsideOldMask -= topLevelMask;
#if defined(Q_WS_WIN) || defined(Q_WS_X11) // We don't control what's happening on other platforms.
// and ensure that the top-level gets an update for the area outside the old mask.
QTRY_VERIFY(topLevel.numPaintEvents > 0);
QTRY_COMPARE(topLevel.paintedRegion, outsideOldMask);
#endif
UpdateWidget child(&topLevel);
child.setAutoFillBackground(true); // NB! Opaque child.
child.setPalette(Qt::red);
child.resize(100, 100);
child.show();
QTest::qWait(10);
child.reset();
topLevel.reset();
// Mask child widget with a mask that is smaller than the rect
const QRegion childMask(0, 0, 50, 50);
child.setMask(childMask);
QTRY_COMPARE(child.mask(), childMask);
QTest::qWait(50);
// and ensure that the child widget doesn't get any update.
#ifdef Q_WS_MAC
// Mac always issues a full update when calling setMask, and we cannot force it to not do so.
if (child.internalWinId())
QCOMPARE(child.numPaintEvents, 1);
else
#endif
QCOMPARE(child.numPaintEvents, 0);
// and the parent widget gets an update for the newly exposed area.
QTRY_COMPARE(topLevel.numPaintEvents, 1);
QRegion expectedParentExpose(child.rect());
expectedParentExpose -= childMask;
QCOMPARE(topLevel.paintedRegion, expectedParentExpose);
child.reset();
topLevel.reset();
// Clear child widget mask
child.clearMask();
QTRY_COMPARE(child.mask(), QRegion());
QTest::qWait(10);
// and ensure that that the child widget gets an update for the area outside the old mask.
QTRY_COMPARE(child.numPaintEvents, 1);
outsideOldMask = child.rect();
#ifdef Q_WS_MAC
// Mac always issues a full update when calling setMask, and we cannot force it to not do so.
if (!child.internalWinId())
#endif
outsideOldMask -= childMask;
QCOMPARE(child.paintedRegion, outsideOldMask);
// and the parent widget doesn't get any update.
QCOMPARE(topLevel.numPaintEvents, 0);
child.reset();
topLevel.reset();
// Mask child widget with a mask that is bigger than the rect
child.setMask(QRegion(0, 0, 1000, 1000));
QTest::qWait(100);
#ifdef Q_WS_MAC
// Mac always issues a full update when calling setMask, and we cannot force it to not do so.
if (child.internalWinId())
QTRY_COMPARE(child.numPaintEvents, 1);
else
#endif
// and ensure that we don't get any updates at all.
QTRY_COMPARE(child.numPaintEvents, 0);
QCOMPARE(topLevel.numPaintEvents, 0);
// ...and the same applies when clearing the mask.
child.clearMask();
QTest::qWait(100);
#ifdef Q_WS_MAC
// Mac always issues a full update when calling setMask, and we cannot force it to not do so.
if (child.internalWinId())
QTRY_VERIFY(child.numPaintEvents > 0);
else
#endif
QCOMPARE(child.numPaintEvents, 0);
QCOMPARE(topLevel.numPaintEvents, 0);
QWidget resizeParent;
MaskResizeTestWidget resizeChild(&resizeParent);
resizeParent.resize(300,300);
resizeParent.raise();
resizeParent.setWindowFlags(Qt::WindowStaysOnTopHint);
resizeChild.setGeometry(50,50,200,200);
QPalette pal = resizeParent.palette();
pal.setColor(QPalette::Window, QColor(Qt::white));
resizeParent.setPalette(pal);
resizeParent.show();
QTest::qWaitForWindowShown(&resizeParent);
// Disable the size grip on the Mac; otherwise it'll be included when grabbing the window.
resizeParent.setFixedSize(resizeParent.size());
resizeChild.show();
QTest::qWait(100);
resizeChild.paintedRegion = QRegion();
QTimer::singleShot(100, &resizeChild, SLOT(shrinkMask()));
QTest::qWait(200);
#ifdef Q_WS_MAC
// Mac always issues a full update when calling setMask, and we cannot force it to not do so.
if (child.internalWinId())
QTRY_COMPARE(resizeChild.paintedRegion, resizeChild.mask());
else
#endif
QTRY_COMPARE(resizeChild.paintedRegion, QRegion());
resizeChild.paintedRegion = QRegion();
const QRegion oldMask = resizeChild.mask();
QTimer::singleShot(0, &resizeChild, SLOT(enlargeMask()));
QTest::qWait(100);
#ifdef Q_WS_MAC
// Mac always issues a full update when calling setMask, and we cannot force it to not do so.
if (child.internalWinId())
QTRY_COMPARE(resizeChild.paintedRegion, resizeChild.mask());
else
#endif
QTRY_COMPARE(resizeChild.paintedRegion, resizeChild.mask() - oldMask);
}
void tst_QWidget::maskedUpdate()
{
UpdateWidget topLevel;
topLevel.resize(200, 200);
const QRegion topLevelMask(50, 50, 70, 70);
topLevel.setMask(topLevelMask);
UpdateWidget child(&topLevel);
child.setGeometry(20, 20, 180, 180);
const QRegion childMask(60, 60, 30, 30);
child.setMask(childMask);
UpdateWidget grandChild(&child);
grandChild.setGeometry(50, 50, 100, 100);
const QRegion grandChildMask(20, 20, 10, 10);
grandChild.setMask(grandChildMask);
topLevel.show();
QTest::qWaitForWindowShown(&topLevel);
QTRY_VERIFY(topLevel.numPaintEvents > 0);
#define RESET_WIDGETS \
topLevel.reset(); \
child.reset(); \
grandChild.reset();
#define CLEAR_MASK(widget) \
widget.clearMask(); \
QTest::qWait(100); \
RESET_WIDGETS;
// All widgets are transparent at this point, so any call to update() will result
// in composition, i.e. the update propagates to ancestors and children.
// TopLevel update.
RESET_WIDGETS;
topLevel.update();
QTest::qWait(10);
QTRY_COMPARE(topLevel.paintedRegion, topLevelMask);
QTRY_COMPARE(child.paintedRegion, childMask);
QTRY_COMPARE(grandChild.paintedRegion, grandChildMask);
// Child update.
RESET_WIDGETS;
child.update();
QTest::qWait(10);
QTRY_COMPARE(topLevel.paintedRegion, childMask.translated(child.pos()));
QTRY_COMPARE(child.paintedRegion, childMask);
QTRY_COMPARE(grandChild.paintedRegion, grandChildMask);
// GrandChild update.
RESET_WIDGETS;
grandChild.update();
QTest::qWait(10);
QTRY_COMPARE(topLevel.paintedRegion, grandChildMask.translated(grandChild.mapTo(&topLevel, QPoint())));
QTRY_COMPARE(child.paintedRegion, grandChildMask.translated(grandChild.pos()));
QTRY_COMPARE(grandChild.paintedRegion, grandChildMask);
topLevel.setAttribute(Qt::WA_OpaquePaintEvent);
child.setAttribute(Qt::WA_OpaquePaintEvent);
grandChild.setAttribute(Qt::WA_OpaquePaintEvent);
// All widgets are now opaque, which means no composition, i.e.
// the update does not propate to ancestors and children.
// TopLevel update.
RESET_WIDGETS;
topLevel.update();
QTest::qWait(10);
QRegion expectedTopLevelUpdate = topLevelMask;
expectedTopLevelUpdate -= childMask.translated(child.pos()); // Subtract opaque children.
QTRY_COMPARE(topLevel.paintedRegion, expectedTopLevelUpdate);
QTRY_COMPARE(child.paintedRegion, QRegion());
QTRY_COMPARE(grandChild.paintedRegion, QRegion());
// Child update.
RESET_WIDGETS;
child.update();
QTest::qWait(10);
QTRY_COMPARE(topLevel.paintedRegion, QRegion());
QRegion expectedChildUpdate = childMask;
expectedChildUpdate -= grandChildMask.translated(grandChild.pos()); // Subtract oapque children.
QTRY_COMPARE(child.paintedRegion, expectedChildUpdate);
QTRY_COMPARE(grandChild.paintedRegion, QRegion());
// GrandChild update.
RESET_WIDGETS;
grandChild.update();
QTest::qWait(10);
QTRY_COMPARE(topLevel.paintedRegion, QRegion());
QTRY_COMPARE(child.paintedRegion, QRegion());
QTRY_COMPARE(grandChild.paintedRegion, grandChildMask);
// GrandChild update.
CLEAR_MASK(grandChild);
grandChild.update();
QTest::qWait(10);
QTRY_COMPARE(topLevel.paintedRegion, QRegion());
QTRY_COMPARE(child.paintedRegion, QRegion());
QRegion expectedGrandChildUpdate = grandChild.rect();
// Clip with parent's mask.
expectedGrandChildUpdate &= childMask.translated(-grandChild.pos());
QCOMPARE(grandChild.paintedRegion, expectedGrandChildUpdate);
// GrandChild update.
CLEAR_MASK(child);
grandChild.update();
QTest::qWait(10);
QTRY_COMPARE(topLevel.paintedRegion, QRegion());
QTRY_COMPARE(child.paintedRegion, QRegion());
expectedGrandChildUpdate = grandChild.rect();
// Clip with parent's mask.
expectedGrandChildUpdate &= topLevelMask.translated(-grandChild.mapTo(&topLevel, QPoint()));
QTRY_COMPARE(grandChild.paintedRegion, expectedGrandChildUpdate);
// Child update.
RESET_WIDGETS;
child.update();
QTest::qWait(10);
QTRY_COMPARE(topLevel.paintedRegion, QRegion());
expectedChildUpdate = child.rect();
// Clip with parent's mask.
expectedChildUpdate &= topLevelMask.translated(-child.pos());
expectedChildUpdate -= grandChild.geometry(); // Subtract opaque children.
QTRY_COMPARE(child.paintedRegion, expectedChildUpdate);
QTRY_COMPARE(grandChild.paintedRegion, QRegion());
// GrandChild update.
CLEAR_MASK(topLevel);
grandChild.update();
QTest::qWait(10);
QTRY_COMPARE(topLevel.paintedRegion, QRegion());
QTRY_COMPARE(child.paintedRegion, QRegion());
QTRY_COMPARE(grandChild.paintedRegion, QRegion(grandChild.rect())); // Full update.
}
#if defined(Q_WS_X11) || defined(Q_WS_WIN) || defined(Q_WS_QWS) || defined(Q_WS_QPA)
void tst_QWidget::syntheticEnterLeave()
{
class MyWidget : public QWidget
{
public:
MyWidget(QWidget *parent = 0) : QWidget(parent), numEnterEvents(0), numLeaveEvents(0) {}
void enterEvent(QEvent *) { ++numEnterEvents; }
void leaveEvent(QEvent *) { ++numLeaveEvents; }
int numEnterEvents;
int numLeaveEvents;
};
QCursor::setPos(QPoint(0,0));
MyWidget window;
window.setWindowFlags(Qt::WindowStaysOnTopHint);
window.resize(200, 200);
MyWidget *child1 = new MyWidget(&window);
child1->setPalette(Qt::blue);
child1->setAutoFillBackground(true);
child1->resize(200, 200);
child1->setCursor(Qt::OpenHandCursor);
MyWidget *child2 = new MyWidget(&window);
child2->resize(200, 200);
MyWidget *grandChild = new MyWidget(child2);
grandChild->setPalette(Qt::red);
grandChild->setAutoFillBackground(true);
grandChild->resize(200, 200);
grandChild->setCursor(Qt::WaitCursor);
window.show();
window.raise();
#ifdef Q_WS_X11
qt_x11_wait_for_window_manager(&window);
#endif
QTest::qWait(300);
#define RESET_EVENT_COUNTS \
window.numEnterEvents = 0; \
window.numLeaveEvents = 0; \
child1->numEnterEvents = 0; \
child1->numLeaveEvents = 0; \
child2->numEnterEvents = 0; \
child2->numLeaveEvents = 0; \
grandChild->numEnterEvents = 0; \
grandChild->numLeaveEvents = 0;
// Position the cursor in the middle of the window.
const QPoint globalPos = window.mapToGlobal(QPoint(100, 100));
QCursor::setPos(globalPos); // Enter child2 and grandChild.
QTest::qWait(300);
#ifdef Q_OS_WINCE_WM
QSKIP("Windows Mobile has no proper cursor support", SkipAll);
#endif
QCOMPARE(window.numLeaveEvents, 0);
QCOMPARE(child2->numLeaveEvents, 0);
QCOMPARE(grandChild->numLeaveEvents, 0);
QCOMPARE(child1->numLeaveEvents, 0);
// This event arrives asynchronously
QTRY_COMPARE(window.numEnterEvents, 1);
QCOMPARE(child2->numEnterEvents, 1);
QCOMPARE(grandChild->numEnterEvents, 1);
QCOMPARE(child1->numEnterEvents, 0);
RESET_EVENT_COUNTS;
child2->hide(); // Leave child2 and grandChild, enter child1.
QCOMPARE(window.numLeaveEvents, 0);
QCOMPARE(child2->numLeaveEvents, 1);
QCOMPARE(grandChild->numLeaveEvents, 1);
QCOMPARE(child1->numLeaveEvents, 0);
QCOMPARE(window.numEnterEvents, 0);
QCOMPARE(child2->numEnterEvents, 0);
QCOMPARE(grandChild->numEnterEvents, 0);
QCOMPARE(child1->numEnterEvents, 1);
RESET_EVENT_COUNTS;
child2->show(); // Leave child1, enter child2 and grandChild.
QCOMPARE(window.numLeaveEvents, 0);
QCOMPARE(child2->numLeaveEvents, 0);
QCOMPARE(grandChild->numLeaveEvents, 0);
QCOMPARE(child1->numLeaveEvents, 1);
QCOMPARE(window.numEnterEvents, 0);
QCOMPARE(child2->numEnterEvents, 1);
QCOMPARE(grandChild->numEnterEvents, 1);
QCOMPARE(child1->numEnterEvents, 0);
RESET_EVENT_COUNTS;
delete child2; // Enter child1 (and do not send leave events to child2 and grandChild).
QCOMPARE(window.numLeaveEvents, 0);
QCOMPARE(child1->numLeaveEvents, 0);
QCOMPARE(window.numEnterEvents, 0);
QCOMPARE(child1->numEnterEvents, 1);
}
void tst_QWidget::taskQTBUG_4055_sendSyntheticEnterLeave()
{
#ifdef Q_OS_WINCE_WM
QSKIP("Windows Mobile has no proper cursor support", SkipAll);
#endif
class SELParent : public QWidget
{
public:
SELParent(QWidget *parent = 0): QWidget(parent) { }
void mousePressEvent(QMouseEvent *) { child->show(); }
QWidget *child;
};
class SELChild : public QWidget
{
public:
SELChild(QWidget *parent = 0) : QWidget(parent), numEnterEvents(0), numMouseMoveEvents(0) {}
void enterEvent(QEvent *) { ++numEnterEvents; }
void mouseMoveEvent(QMouseEvent *event)
{
QCOMPARE(event->button(), Qt::NoButton);
QCOMPARE(event->buttons(), Qt::MouseButtons(Qt::NoButton));
++numMouseMoveEvents;
}
void reset() { numEnterEvents = numMouseMoveEvents = 0; }
int numEnterEvents, numMouseMoveEvents;
};
QCursor::setPos(QPoint(0,0));
SELParent parent;
parent.resize(200, 200);
SELChild child(&parent);
child.resize(200, 200);
parent.show();
#ifdef Q_WS_X11
qt_x11_wait_for_window_manager(&parent);
#endif
QTest::qWait(150);
QCursor::setPos(child.mapToGlobal(QPoint(100, 100)));
// Make sure the cursor has entered the child.
QTRY_VERIFY(child.numEnterEvents > 0);
child.hide();
child.reset();
child.show();
// Make sure the child gets enter event and no mouse move event.
QTRY_COMPARE(child.numEnterEvents, 1);
QCOMPARE(child.numMouseMoveEvents, 0);
child.hide();
child.reset();
child.setMouseTracking(true);
child.show();
// Make sure the child gets enter event and mouse move event.
// Note that we verify event->button() and event->buttons()
// in SELChild::mouseMoveEvent().
QTRY_COMPARE(child.numEnterEvents, 1);
QCOMPARE(child.numMouseMoveEvents, 1);
// Sending synthetic enter/leave trough the parent's mousePressEvent handler.
parent.child = &child;
child.hide();
child.reset();
QTest::mouseClick(&parent, Qt::LeftButton);
// Make sure the child gets enter event and one mouse move event.
QTRY_COMPARE(child.numEnterEvents, 1);
QCOMPARE(child.numMouseMoveEvents, 1);
child.hide();
child.reset();
child.setMouseTracking(false);
QTest::mouseClick(&parent, Qt::LeftButton);
// Make sure the child gets enter event and no mouse move event.
QTRY_COMPARE(child.numEnterEvents, 1);
QCOMPARE(child.numMouseMoveEvents, 0);
}
#endif
void tst_QWidget::windowFlags()
{
QWidget w;
w.setWindowFlags(w.windowFlags() | Qt::FramelessWindowHint);
QVERIFY(w.windowFlags() & Qt::FramelessWindowHint);
}
void tst_QWidget::initialPosForDontShowOnScreenWidgets()
{
{ // Check default position.
const QPoint expectedPos(0, 0);
QWidget widget;
widget.setAttribute(Qt::WA_DontShowOnScreen);
widget.winId(); // Make sure create_sys is called.
QCOMPARE(widget.pos(), expectedPos);
QCOMPARE(widget.geometry().topLeft(), expectedPos);
}
{ // Explicitly move to a position.
const QPoint expectedPos(100, 100);
QWidget widget;
widget.setAttribute(Qt::WA_DontShowOnScreen);
widget.move(expectedPos);
widget.winId(); // Make sure create_sys is called.
QCOMPARE(widget.pos(), expectedPos);
QCOMPARE(widget.geometry().topLeft(), expectedPos);
}
}
#ifdef Q_WS_X11
void tst_QWidget::paintOutsidePaintEvent()
{
QWidget widget;
widget.resize(200, 200);
QWidget child1(&widget);
child1.resize(100, 100);
child1.setPalette(Qt::red);
child1.setAutoFillBackground(true);
QWidget child2(&widget);
child2.setGeometry(50, 50, 100, 100);
child2.setPalette(Qt::blue);
child2.setAutoFillBackground(true);
widget.show();
QTest::qWaitForWindowShown(&widget);
QTest::qWait(60);
const QPixmap before = QPixmap::grabWindow(widget.winId());
// Child 1 should be clipped by child 2, so nothing should change.
child1.setAttribute(Qt::WA_PaintOutsidePaintEvent);
QPainter painter(&child1);
painter.fillRect(child1.rect(), Qt::red);
painter.end();
XSync(QX11Info::display(), false); // Flush output buffer.
QTest::qWait(60);
const QPixmap after = QPixmap::grabWindow(widget.winId());
QCOMPARE(before, after);
}
#endif
class MyEvilObject : public QObject
{
Q_OBJECT
public:
MyEvilObject(QWidget *widgetToCrash) : QObject(), widget(widgetToCrash)
{
connect(widget, SIGNAL(destroyed(QObject *)), this, SLOT(beEvil(QObject *)));
delete widget;
}
QWidget *widget;
private slots:
void beEvil(QObject *) { widget->update(0, 0, 150, 150); }
};
void tst_QWidget::updateOnDestroyedSignal()
{
QWidget widget;
QWidget *child = new QWidget(&widget);
child->resize(100, 100);
child->setAutoFillBackground(true);
child->setPalette(Qt::red);
widget.show();
#ifdef Q_WS_X11
qt_x11_wait_for_window_manager(&widget);
#endif
QTest::qWait(200);
// Please do not crash.
MyEvilObject evil(child);
QTest::qWait(200);
}
void tst_QWidget::toplevelLineEditFocus()
{
testWidget->hide();
QLineEdit w;
w.show();
QTest::qWaitForWindowShown(&w);
QTest::qWait(20);
QTRY_COMPARE(QApplication::activeWindow(), (QWidget*)&w);
QTRY_COMPARE(QApplication::focusWidget(), (QWidget*)&w);
}
void tst_QWidget::focusWidget_task254563()
{
//having different visibility for widget is important
QWidget top;
top.show();
QWidget container(&top);
QWidget *widget = new QWidget(&container);
widget->show();
widget->setFocus(); //set focus (will set the focus widget up to the toplevel to be 'widget')
container.setFocus();
delete widget; // will call clearFocus but that doesn't help
QVERIFY(top.focusWidget() != widget); //dangling pointer
}
void tst_QWidget::destroyBackingStore()
{
#ifdef QT_BUILD_INTERNAL
UpdateWidget w;
w.reset();
w.show();
QTest::qWaitForWindowShown(&w);
QApplication::processEvents();
QTRY_VERIFY(w.numPaintEvents > 0);
w.reset();
w.update();
qt_widget_private(&w)->topData()->backingStore.create(&w);
w.update();
QApplication::processEvents();
#ifdef Q_WS_QWS
QApplication::processEvents();
#endif
QCOMPARE(w.numPaintEvents, 1);
// Check one more time, because the second time around does more caching.
w.update();
QApplication::processEvents();
QCOMPARE(w.numPaintEvents, 2);
#else
QSKIP("Test case relies on developer build (AUTOTEST_EXPORT)", SkipAll);
#endif
}
// Helper function
QWidgetBackingStore* backingStore(QWidget &widget)
{
QWidgetBackingStore *backingStore = 0;
#ifdef QT_BUILD_INTERNAL
if (QTLWExtra *topExtra = qt_widget_private(&widget)->maybeTopData())
backingStore = topExtra->backingStore.data();
#endif
return backingStore;
}
// Wait for a condition to be true, timing out after 1 second
// This is used following calls to QWidget::show() and QWidget::hide(), which are
// expected to asynchronously trigger native window visibility events.
#define WAIT_AND_VERIFY(condition) \
do { \
QTime start = QTime::currentTime(); \
while (!(condition) && (start.elapsed() < 1000)) { \
qApp->processEvents(); \
QTest::qWait(50); \
} \
if (!QTest::qVerify((condition), #condition, "", __FILE__, __LINE__)) \
return; \
} while (0)
void tst_QWidget::destroyBackingStoreWhenHidden()
{
#ifndef QT_BUILD_INTERNAL
QSKIP("Test step requires access to Q_AUTOTEST_EXPORT", SkipAll);
#endif
#ifndef Q_OS_SYMBIAN
QSKIP("Only Symbian destroys backing store when native window becomes invisible", SkipAll);
#endif
testWidget->hide();
QTest::qWait(1000);
// 1. Single top-level QWidget
{
QWidget w;
w.setAutoFillBackground(true);
w.setPalette(Qt::yellow);
w.setGeometry(0, 0, 100, 100);
w.show();
QTest::qWaitForWindowShown(&w);
QVERIFY(0 != backingStore(w));
w.hide();
WAIT_AND_VERIFY(0 == backingStore(w));
w.show();
QTest::qWaitForWindowShown(&w);
QVERIFY(0 != backingStore(w));
}
// 2. Two top-level widgets
{
QWidget w1;
w1.setGeometry(0, 0, 100, 100);
w1.setAutoFillBackground(true);
w1.setPalette(Qt::red);
w1.show();
QTest::qWaitForWindowShown(&w1);
QVERIFY(0 != backingStore(w1));
QWidget w2;
w2.setGeometry(w1.geometry());
w1.setAutoFillBackground(true);
w1.setPalette(Qt::blue);
w2.show();
QTest::qWaitForWindowShown(&w2);
QVERIFY(0 != backingStore(w2));
// Check that w1 deleted its backing store when obscured by w2
QVERIFY(0 == backingStore(w1));
w2.move(w2.pos() + QPoint(10, 10));
// Check that w1 recreates its backing store when partially revealed
WAIT_AND_VERIFY(0 != backingStore(w1));
}
// 3. Native child widget
{
QWidget parent;
parent.setGeometry(0, 0, 100, 100);
parent.setAutoFillBackground(true);
parent.setPalette(Qt::yellow);
QWidget child(&parent);
child.setAutoFillBackground(true);
child.setPalette(Qt::green);
QVBoxLayout layout(&parent);
layout.setContentsMargins(10, 10, 10, 10);
layout.addWidget(&child);
parent.setLayout(&layout);
child.winId();
parent.show();
QTest::qWaitForWindowShown(&parent);
// Check that child window does not obscure parent window
QVERIFY(!parent.visibleRegion().subtracted(child.visibleRegion()).isEmpty());
// Native child widget should share parent's backing store
QWidgetBackingStore *const parentBs = backingStore(parent);
QVERIFY(0 != parentBs);
QVERIFY(0 == backingStore(child));
// Set margins to zero so that child widget totally obscures parent
layout.setContentsMargins(0, 0, 0, 0);
WAIT_AND_VERIFY(parent.visibleRegion().subtracted(child.visibleRegion()).isEmpty());
// Backing store should remain unchanged despite child window obscuring
// parent window
QVERIFY(parentBs == backingStore(parent));
QVERIFY(0 == backingStore(child));
}
// 4. Alien child widget which is made full-screen
{
QWidget parent;
parent.setGeometry(0, 0, 100, 100);
parent.setAutoFillBackground(true);
parent.setPalette(Qt::red);
QWidget child(&parent);
child.setAutoFillBackground(true);
child.setPalette(Qt::blue);
QVBoxLayout layout(&parent);
layout.setContentsMargins(10, 10, 10, 10);
layout.addWidget(&child);
parent.setLayout(&layout);
parent.show();
QTest::qWaitForWindowShown(&parent);
// Check that child window does not obscure parent window
QVERIFY(!parent.visibleRegion().subtracted(child.visibleRegion()).isEmpty());
// Native child widget should share parent's backing store
QVERIFY(0 != backingStore(parent));
QVERIFY(0 == backingStore(child));
// Make child widget full screen
child.setWindowFlags((child.windowFlags() | Qt::Window) ^ Qt::SubWindow);
child.setWindowState(child.windowState() | Qt::WindowFullScreen);
child.show();
QTest::qWaitForWindowShown(&child);
// Check that child window obscures parent window
QVERIFY(parent.visibleRegion().subtracted(child.visibleRegion()).isEmpty());
// Now that extent of child widget goes beyond parent's extent,
// a new backing store should be created for the child widget.
QVERIFY(0 != backingStore(child));
// Parent is obscured, therefore its backing store should be destroyed
QVERIFY(0 == backingStore(parent));
// Disable full screen
child.setWindowFlags(child.windowFlags() ^ (Qt::Window | Qt::SubWindow));
child.setWindowState(child.windowState() ^ Qt::WindowFullScreen);
child.show();
QTest::qWaitForWindowShown(&child);
// Check that parent is now visible again
QVERIFY(!parent.visibleRegion().subtracted(child.visibleRegion()).isEmpty());
// Native child widget should once again share parent's backing store
QVERIFY(0 != backingStore(parent));
QVERIFY(0 == backingStore(child));
}
// 5. Native child widget which is made full-screen
{
QWidget parent;
parent.setGeometry(0, 0, 100, 100);
parent.setAutoFillBackground(true);
parent.setPalette(Qt::red);
QWidget child(&parent);
child.setAutoFillBackground(true);
child.setPalette(Qt::blue);
QWidget grandChild(&child);
grandChild.setAutoFillBackground(true);
grandChild.setPalette(Qt::yellow);
QVBoxLayout layout(&parent);
layout.setContentsMargins(10, 10, 10, 10);
layout.addWidget(&child);
parent.setLayout(&layout);
QVBoxLayout childLayout(&child);
childLayout.setContentsMargins(10, 10, 10, 10);
childLayout.addWidget(&grandChild);
child.setLayout(&childLayout);
// Ensure that this widget and all its ancestors are native
grandChild.winId();
parent.show();
QTest::qWaitForWindowShown(&parent);
// Check that child window does not obscure parent window
QVERIFY(!parent.visibleRegion().subtracted(child.visibleRegion()).isEmpty());
// Native child widget should share parent's backing store
QVERIFY(0 != backingStore(parent));
QVERIFY(0 == backingStore(child));
QVERIFY(0 == backingStore(grandChild));
// Make child widget full screen
child.setWindowFlags((child.windowFlags() | Qt::Window) ^ Qt::SubWindow);
child.setWindowState(child.windowState() | Qt::WindowFullScreen);
child.show();
// Paint into the child to ensure that it gets a backing store
QPainter painter(&child);
painter.fillRect(QRect(0, 0, 90, 90), Qt::white);
QTest::qWaitForWindowShown(&child);
// Ensure that 'window hidden' event is received by parent
qApp->processEvents();
// Check that child window obscures parent window
QVERIFY(parent.visibleRegion().subtracted(child.visibleRegion() + grandChild.visibleRegion()).isEmpty());
// Now that extent of child widget goes beyond parent's extent,
// a new backing store should be created for the child widget.
QVERIFY(0 != backingStore(child));
// Parent is obscured, therefore its backing store should be destroyed
QVERIFY(0 == backingStore(parent));
// Disable full screen
child.setWindowFlags(child.windowFlags() ^ (Qt::Window | Qt::SubWindow));
child.setWindowState(child.windowState() ^ Qt::WindowFullScreen);
child.show();
QTest::qWaitForWindowShown(&child);
// Check that parent is now visible again
QVERIFY(!parent.visibleRegion().subtracted(child.visibleRegion() + grandChild.visibleRegion()).isEmpty());
// Native child widget should once again share parent's backing store
QVERIFY(0 != backingStore(parent));
QVERIFY(0 == backingStore(child));
QVERIFY(0 == backingStore(grandChild));
}
// 6. Partial reveal followed by full reveal
{
QWidget upper;
upper.setAutoFillBackground(true);
upper.setPalette(Qt::red);
upper.setGeometry(50, 50, 100, 100);
QWidget lower;
lower.setAutoFillBackground(true);
lower.setPalette(Qt::green);
lower.setGeometry(50, 50, 100, 100);
lower.show();
QTest::qWaitForWindowShown(&lower);
upper.show();
QTest::qWaitForWindowShown(&upper);
upper.raise();
QVERIFY(0 != backingStore(upper));
QVERIFY(0 == backingStore(lower));
// Check that upper obscures lower
QVERIFY(lower.visibleRegion().subtracted(upper.visibleRegion()).isEmpty());
// Partially reveal lower
upper.move(100, 100);
// Completely reveal lower
upper.hide();
// Hide lower widget - this should cause its backing store to be deleted
lower.hide();
// Check that backing store was deleted
WAIT_AND_VERIFY(0 == backingStore(lower));
}
// 7. Reparenting of visible native child widget
{
QWidget parent1;
parent1.setAutoFillBackground(true);
parent1.setPalette(Qt::green);
parent1.setGeometry(50, 50, 100, 100);
QWidget *child = new QWidget(&parent1);
child->winId();
child->setAutoFillBackground(true);
child->setPalette(Qt::red);
child->setGeometry(10, 10, 30, 30);
QWidget parent2;
parent2.setAutoFillBackground(true);
parent2.setPalette(Qt::blue);
parent2.setGeometry(150, 150, 100, 100);
parent1.show();
QTest::qWaitForWindowShown(&parent1);
QVERIFY(0 != backingStore(parent1));
parent2.show();
QTest::qWaitForWindowShown(&parent2);
QVERIFY(0 != backingStore(parent2));
child->setParent(&parent2);
child->setGeometry(10, 10, 30, 30);
child->show();
parent1.hide();
WAIT_AND_VERIFY(0 == backingStore(parent1));
parent2.hide();
WAIT_AND_VERIFY(0 == backingStore(parent2));
}
}
#undef WAIT_AND_VERIFY
void tst_QWidget::rectOutsideCoordinatesLimit_task144779()
{
#ifdef Q_OS_WINCE_WM
QSKIP( "Tables of 5000 elements do not make sense on Windows Mobile.", SkipAll);
#endif
QApplication::setOverrideCursor(Qt::BlankCursor); //keep the cursor out of screen grabs
QWidget main(0,Qt::FramelessWindowHint); //don't get confused by the size of the window frame
QPalette palette;
palette.setColor(QPalette::Window, Qt::red);
main.setPalette(palette);
QDesktopWidget desktop;
QRect desktopDimensions = desktop.availableGeometry(&main);
QSize mainSize(400, 400);
mainSize = mainSize.boundedTo(desktopDimensions.size());
main.resize(mainSize);
QWidget *offsetWidget = new QWidget(&main);
offsetWidget->setGeometry(0, -(15000 - mainSize.height()), mainSize.width(), 15000);
// big widget is too big for the coordinates, it must be limited by wrect
// if wrect is not at the right position because of offsetWidget, bigwidget
// is not painted correctly
QWidget *bigWidget = new QWidget(offsetWidget);
bigWidget->setGeometry(0, 0, mainSize.width(), 50000);
palette.setColor(QPalette::Window, Qt::green);
bigWidget->setPalette(palette);
bigWidget->setAutoFillBackground(true);
main.show();
QTest::qWaitForWindowShown(&main);
QPixmap correct(main.size());
correct.fill(Qt::green);
QTRY_COMPARE(QPixmap::grabWindow(main.winId()).toImage().convertToFormat(QImage::Format_RGB32),
correct.toImage().convertToFormat(QImage::Format_RGB32));
QApplication::restoreOverrideCursor();
}
void tst_QWidget::inputFocus_task257832()
{
QLineEdit *widget = new QLineEdit;
QInputContext *context = widget->inputContext();
if (!context)
QSKIP("No input context", SkipSingle);
widget->setFocus();
widget->winId(); // make sure, widget has been created
context->setFocusWidget(widget);
QCOMPARE(context->focusWidget(), static_cast<QWidget*>(widget));
widget->setReadOnly(true);
QVERIFY(!context->focusWidget());
delete widget;
}
void tst_QWidget::setGraphicsEffect()
{
// Check that we don't have any effect by default.
QWidget *widget = new QWidget;
QVERIFY(!widget->graphicsEffect());
// SetGet check.
QPointer<QGraphicsEffect> blurEffect = new QGraphicsBlurEffect;
widget->setGraphicsEffect(blurEffect);
QCOMPARE(widget->graphicsEffect(), static_cast<QGraphicsEffect *>(blurEffect));
// Ensure the existing effect is deleted when setting a new one.
QPointer<QGraphicsEffect> shadowEffect = new QGraphicsDropShadowEffect;
widget->setGraphicsEffect(shadowEffect);
QVERIFY(!blurEffect);
QCOMPARE(widget->graphicsEffect(), static_cast<QGraphicsEffect *>(shadowEffect));
blurEffect = new QGraphicsBlurEffect;
// Ensure the effect is uninstalled when setting it on a new target.
QWidget *anotherWidget = new QWidget;
anotherWidget->setGraphicsEffect(blurEffect);
widget->setGraphicsEffect(blurEffect);
QVERIFY(!anotherWidget->graphicsEffect());
QVERIFY(!shadowEffect);
// Ensure the existing effect is deleted when deleting the widget.
delete widget;
QVERIFY(!blurEffect);
delete anotherWidget;
// Ensure the effect is uninstalled when deleting it
widget = new QWidget;
blurEffect = new QGraphicsBlurEffect;
widget->setGraphicsEffect(blurEffect);
delete blurEffect;
QVERIFY(!widget->graphicsEffect());
// Ensure the existing effect is uninstalled and deleted when setting a null effect
blurEffect = new QGraphicsBlurEffect;
widget->setGraphicsEffect(blurEffect);
widget->setGraphicsEffect(0);
QVERIFY(!widget->graphicsEffect());
QVERIFY(!blurEffect);
delete widget;
}
void tst_QWidget::activateWindow()
{
// Test case for task 260685
// Create first mainwindow and set it active
QMainWindow* mainwindow = new QMainWindow();
QLabel* label = new QLabel(mainwindow);
mainwindow->setCentralWidget(label);
mainwindow->setVisible(true);
mainwindow->activateWindow();
QTest::qWaitForWindowShown(mainwindow);
qApp->processEvents();
QTRY_VERIFY(mainwindow->isActiveWindow());
// Create second mainwindow and set it active
QMainWindow* mainwindow2 = new QMainWindow();
QLabel* label2 = new QLabel(mainwindow2);
mainwindow2->setCentralWidget(label2);
mainwindow2->setVisible(true);
mainwindow2->activateWindow();
qApp->processEvents();
QTRY_VERIFY(!mainwindow->isActiveWindow());
QTRY_VERIFY(mainwindow2->isActiveWindow());
// Revert first mainwindow back to visible active
mainwindow->setVisible(true);
mainwindow->activateWindow();
qApp->processEvents();
QTRY_VERIFY(mainwindow->isActiveWindow());
QTRY_VERIFY(!mainwindow2->isActiveWindow());
}
void tst_QWidget::openModal_taskQTBUG_5804()
{
class Widget : public QWidget
{
public:
Widget(QWidget *parent) : QWidget(parent)
{
}
~Widget()
{
QMessageBox msgbox;
QTimer::singleShot(10, &msgbox, SLOT(accept()));
msgbox.exec(); //open a modal dialog
}
};
QWidget *win = new QWidget;
new Widget(win);
win->show();
QTest::qWaitForWindowShown(win);
delete win;
}
#ifdef Q_OS_SYMBIAN
void tst_QWidget::cbaVisibility()
{
// Test case for task 261048
// Create first mainwindow in fullsreen and activate it
QMainWindow* mainwindow = new QMainWindow();
QLabel* label = new QLabel(mainwindow);
mainwindow->setCentralWidget(label);
mainwindow->setWindowState(Qt::WindowFullScreen);
mainwindow->setVisible(true);
mainwindow->activateWindow();
qApp->processEvents();
QVERIFY(mainwindow->isActiveWindow());
QVERIFY(QDesktopWidget().availableGeometry().size() == mainwindow->size());
// Create second mainwindow in maximized and activate it
QMainWindow* mainwindow2 = new QMainWindow();
QLabel* label2 = new QLabel(mainwindow2);
mainwindow2->setCentralWidget(label2);
mainwindow2->setWindowState(Qt::WindowMaximized);
mainwindow2->setVisible(true);
mainwindow2->activateWindow();
qApp->processEvents();
QVERIFY(!mainwindow->isActiveWindow());
QVERIFY(mainwindow2->isActiveWindow());
QVERIFY(QDesktopWidget().availableGeometry().size() == mainwindow2->size());
// Verify window decorations i.e. status pane and CBA are visible.
CEikStatusPane* statusPane = CEikonEnv::Static()->AppUiFactory()->StatusPane();
QVERIFY(statusPane->IsVisible());
CEikButtonGroupContainer* buttonGroup = CEikButtonGroupContainer::Current();
QVERIFY(buttonGroup->IsVisible());
}
void tst_QWidget::fullScreenWindowModeTransitions()
{
QWidget widget;
QVBoxLayout *layout = new QVBoxLayout;
QPushButton *button = new QPushButton("test Button");
layout->addWidget(button);
widget.setLayout(layout);
widget.show();
const QRect normalGeometry = widget.normalGeometry();
const QRect fullScreenGeometry = qApp->desktop()->screenGeometry(&widget);
const QRect maximumScreenGeometry = qApp->desktop()->availableGeometry(&widget);
CEikStatusPane *statusPane = CEikonEnv::Static()->AppUiFactory()->StatusPane();
CEikButtonGroupContainer *buttonGroup = CEikButtonGroupContainer::Current();
//Enter
widget.showNormal();
widget.showFullScreen();
QCOMPARE(widget.geometry(), fullScreenGeometry);
QVERIFY(!buttonGroup->IsVisible());
QVERIFY(!statusPane->IsVisible());
widget.showMaximized();
widget.showFullScreen();
QCOMPARE(widget.geometry(), fullScreenGeometry);
QVERIFY(!buttonGroup->IsVisible());
QVERIFY(!statusPane->IsVisible());
widget.showMinimized();
widget.showFullScreen();
QCOMPARE(widget.geometry(), fullScreenGeometry);
QVERIFY(!buttonGroup->IsVisible());
QVERIFY(!statusPane->IsVisible());
//Exit
widget.showFullScreen();
widget.showNormal();
QCOMPARE(widget.geometry(), normalGeometry);
QVERIFY(buttonGroup->IsVisible());
QVERIFY(statusPane->IsVisible());
widget.showFullScreen();
widget.showMaximized();
QCOMPARE(widget.geometry(), maximumScreenGeometry);
QVERIFY(buttonGroup->IsVisible());
QVERIFY(statusPane->IsVisible());
widget.showFullScreen();
widget.showMinimized();
QCOMPARE(widget.geometry(), fullScreenGeometry);
QVERIFY(!buttonGroup->IsVisible());
QVERIFY(!statusPane->IsVisible());
}
void tst_QWidget::maximizedWindowModeTransitions()
{
QWidget widget;
QVBoxLayout *layout = new QVBoxLayout;
QPushButton *button = new QPushButton("test Button");
layout->addWidget(button);
widget.setLayout(layout);
widget.show();
const QRect normalGeometry = widget.normalGeometry();
const QRect fullScreenGeometry = qApp->desktop()->screenGeometry(&widget);
const QRect maximumScreenGeometry = qApp->desktop()->availableGeometry(&widget);
CEikStatusPane *statusPane = CEikonEnv::Static()->AppUiFactory()->StatusPane();
CEikButtonGroupContainer *buttonGroup = CEikButtonGroupContainer::Current();
//Enter
widget.showNormal();
widget.showMaximized();
QCOMPARE(widget.geometry(), maximumScreenGeometry);
QVERIFY(buttonGroup->IsVisible());
QVERIFY(statusPane->IsVisible());
widget.showFullScreen();
widget.showMaximized();
QCOMPARE(widget.geometry(), maximumScreenGeometry);
QVERIFY(buttonGroup->IsVisible());
QVERIFY(statusPane->IsVisible());
widget.showMinimized();
widget.showMaximized();
QCOMPARE(widget.geometry(), maximumScreenGeometry);
QVERIFY(buttonGroup->IsVisible());
QVERIFY(statusPane->IsVisible());
//Exit
widget.showMaximized();
widget.showNormal();
QCOMPARE(widget.geometry(), normalGeometry);
QVERIFY(buttonGroup->IsVisible());
QVERIFY(statusPane->IsVisible());
widget.showMaximized();
widget.showFullScreen();
QCOMPARE(widget.geometry(), fullScreenGeometry);
QVERIFY(!buttonGroup->IsVisible());
QVERIFY(!statusPane->IsVisible());
widget.showMaximized();
widget.showMinimized();
// Since showMinimized hides window decoration availableGeometry gives different value
// than with decoration visible. Altual size does not really matter since widget is invisible.
QCOMPARE(widget.geometry(), qApp->desktop()->availableGeometry(&widget));
QVERIFY(!buttonGroup->IsVisible());
QVERIFY(!statusPane->IsVisible());
}
void tst_QWidget::minimizedWindowModeTransitions()
{
QWidget widget;
QVBoxLayout *layout = new QVBoxLayout;
QPushButton *button = new QPushButton("test Button");
layout->addWidget(button);
widget.setLayout(layout);
widget.show();
const QRect normalGeometry = widget.normalGeometry();
const QRect fullScreenGeometry = qApp->desktop()->screenGeometry(&widget);
const QRect maximumScreenGeometry = qApp->desktop()->availableGeometry(&widget);
CEikStatusPane *statusPane = CEikonEnv::Static()->AppUiFactory()->StatusPane();
CEikButtonGroupContainer *buttonGroup = CEikButtonGroupContainer::Current();
//Enter
widget.showNormal();
widget.showMinimized();
QCOMPARE(widget.geometry(), normalGeometry);
QVERIFY(!buttonGroup->IsVisible());
QVERIFY(!statusPane->IsVisible());
widget.showFullScreen();
widget.showMinimized();
QCOMPARE(widget.geometry(), fullScreenGeometry);
QVERIFY(!buttonGroup->IsVisible());
QVERIFY(!statusPane->IsVisible());
widget.showMaximized();
widget.showMinimized();
// Since showMinimized hides window decoration availableGeometry gives different value
// than with decoration visible. Altual size does not really matter since widget is invisible.
QCOMPARE(widget.geometry(), qApp->desktop()->availableGeometry(&widget));
QVERIFY(!buttonGroup->IsVisible());
QVERIFY(!statusPane->IsVisible());
//Exit
widget.showMinimized();
widget.showNormal();
QCOMPARE(widget.geometry(), normalGeometry);
QVERIFY(buttonGroup->IsVisible());
QVERIFY(statusPane->IsVisible());
widget.showMinimized();
widget.showFullScreen();
QCOMPARE(widget.geometry(), fullScreenGeometry);
QVERIFY(!buttonGroup->IsVisible());
QVERIFY(!statusPane->IsVisible());
widget.showMinimized();
widget.showMaximized();
QCOMPARE(widget.geometry(), maximumScreenGeometry);
QVERIFY(buttonGroup->IsVisible());
QVERIFY(statusPane->IsVisible());
}
void tst_QWidget::normalWindowModeTransitions()
{
QWidget widget;
QVBoxLayout *layout = new QVBoxLayout;
QPushButton *button = new QPushButton("test Button");
layout->addWidget(button);
widget.setLayout(layout);
widget.show();
const QRect normalGeometry = widget.normalGeometry();
const QRect fullScreenGeometry = qApp->desktop()->screenGeometry(&widget);
const QRect maximumScreenGeometry = qApp->desktop()->availableGeometry(&widget);
CEikStatusPane *statusPane = CEikonEnv::Static()->AppUiFactory()->StatusPane();
CEikButtonGroupContainer *buttonGroup = CEikButtonGroupContainer::Current();
//Enter
widget.showMaximized();
widget.showNormal();
QCOMPARE(widget.geometry(), normalGeometry);
QVERIFY(buttonGroup->IsVisible());
QVERIFY(statusPane->IsVisible());
widget.showFullScreen();
widget.showNormal();
QCOMPARE(widget.geometry(), normalGeometry);
QVERIFY(buttonGroup->IsVisible());
QVERIFY(statusPane->IsVisible());
widget.showMinimized();
widget.showNormal();
QCOMPARE(widget.geometry(), normalGeometry);
QVERIFY(buttonGroup->IsVisible());
QVERIFY(statusPane->IsVisible());
//Exit
widget.showNormal();
widget.showMaximized();
QCOMPARE(widget.geometry(), maximumScreenGeometry);
QVERIFY(buttonGroup->IsVisible());
QVERIFY(statusPane->IsVisible());
widget.showNormal();
widget.showFullScreen();
QCOMPARE(widget.geometry(), fullScreenGeometry);
QVERIFY(!buttonGroup->IsVisible());
QVERIFY(!statusPane->IsVisible());
widget.showNormal();
widget.showMinimized();
QCOMPARE(widget.geometry(), normalGeometry);
QVERIFY(!buttonGroup->IsVisible());
QVERIFY(!statusPane->IsVisible());
}
void tst_QWidget::focusSwitchClosesPopupMenu()
{
QMainWindow mainWindow;
QAction action("Test action", &mainWindow);
mainWindow.menuBar()->addAction(&action);
mainWindow.show();
QT_TRAP_THROWING(CEikonEnv::Static()->AppUiFactory()->MenuBar()->TryDisplayMenuBarL());
QVERIFY(CEikonEnv::Static()->AppUiFactory()->MenuBar()->IsDisplayed());
// Close the popup by opening a new window.
QMainWindow mainWindow2;
QAction action2("Test action", &mainWindow2);
mainWindow2.menuBar()->addAction(&action2);
mainWindow2.show();
QVERIFY(!CEikonEnv::Static()->AppUiFactory()->MenuBar()->IsDisplayed());
QT_TRAP_THROWING(CEikonEnv::Static()->AppUiFactory()->MenuBar()->TryDisplayMenuBarL());
QVERIFY(CEikonEnv::Static()->AppUiFactory()->MenuBar()->IsDisplayed());
// Close the popup by switching focus.
mainWindow.activateWindow();
QVERIFY(!CEikonEnv::Static()->AppUiFactory()->MenuBar()->IsDisplayed());
}
#endif
class InputContextTester : public QInputContext
{
Q_OBJECT
public:
QString identifierName() { return QString(); }
bool isComposing() const { return false; }
QString language() { return QString(); }
void reset() { ++resets; }
int resets;
};
void tst_QWidget::focusProxyAndInputMethods()
{
InputContextTester *inputContext = new InputContextTester;
QWidget *toplevel = new QWidget(0, Qt::X11BypassWindowManagerHint);
toplevel->setAttribute(Qt::WA_InputMethodEnabled, true);
toplevel->setInputContext(inputContext); // ownership is transferred
QWidget *child = new QWidget(toplevel);
child->setFocusProxy(toplevel);
child->setAttribute(Qt::WA_InputMethodEnabled, true);
toplevel->setFocusPolicy(Qt::WheelFocus);
child->setFocusPolicy(Qt::WheelFocus);
QVERIFY(!child->hasFocus());
QVERIFY(!toplevel->hasFocus());
toplevel->show();
QTest::qWaitForWindowShown(toplevel);
QApplication::setActiveWindow(toplevel);
QVERIFY(toplevel->hasFocus());
QVERIFY(child->hasFocus());
// verify that toggling input methods on the child widget
// correctly propagate to the focus proxy's input method
// and that the input method gets the focus proxy passed
// as the focus widget instead of the child widget.
// otherwise input method queries go to the wrong widget
QCOMPARE(inputContext->focusWidget(), toplevel);
child->setAttribute(Qt::WA_InputMethodEnabled, false);
QVERIFY(!inputContext->focusWidget());
child->setAttribute(Qt::WA_InputMethodEnabled, true);
QCOMPARE(inputContext->focusWidget(), toplevel);
child->setEnabled(false);
QVERIFY(!inputContext->focusWidget());
child->setEnabled(true);
QCOMPARE(inputContext->focusWidget(), toplevel);
delete toplevel;
}
#ifdef QT_BUILD_INTERNAL
class scrollWidgetWBS : public QWidget
{
public:
void deleteBackingStore()
{
static_cast<QWidgetPrivate*>(d_ptr.data())->topData()->backingStore.destroy();
}
void enableBackingStore()
{
if (!static_cast<QWidgetPrivate*>(d_ptr.data())->maybeBackingStore()) {
static_cast<QWidgetPrivate*>(d_ptr.data())->topData()->backingStore.create(this);
static_cast<QWidgetPrivate*>(d_ptr.data())->invalidateBuffer(this->rect());
repaint();
}
}
};
#endif
void tst_QWidget::scrollWithoutBackingStore()
{
#ifdef QT_BUILD_INTERNAL
scrollWidgetWBS scrollable;
scrollable.resize(100,100);
QLabel child(QString("@"),&scrollable);
child.resize(50,50);
scrollable.show();
QTest::qWaitForWindowShown(&scrollable);
scrollable.scroll(50,50);
QCOMPARE(child.pos(),QPoint(50,50));
scrollable.deleteBackingStore();
scrollable.scroll(-25,-25);
QCOMPARE(child.pos(),QPoint(25,25));
scrollable.enableBackingStore();
QCOMPARE(child.pos(),QPoint(25,25));
#else
QSKIP("Test case relies on developer build (AUTOTEST_EXPORT)", SkipAll);
#endif
}
void tst_QWidget::taskQTBUG_7532_tabOrderWithFocusProxy()
{
QWidget w;
w.setFocusPolicy(Qt::TabFocus);
QWidget *fp = new QWidget(&w);
fp->setFocusPolicy(Qt::TabFocus);
w.setFocusProxy(fp);
QWidget::setTabOrder(&w, fp);
// In debug mode, no assertion failure means it's alright.
}
void tst_QWidget::movedAndResizedAttributes()
{
#if defined (Q_OS_MAC) || defined(Q_WS_QWS) || defined(Q_OS_SYMBIAN)
QEXPECT_FAIL("", "FixMe, QTBUG-8941 and QTBUG-8977", Abort);
QVERIFY(false);
#else
QWidget w;
w.show();
QVERIFY(!w.testAttribute(Qt::WA_Moved));
QVERIFY(!w.testAttribute(Qt::WA_Resized));
w.setWindowState(Qt::WindowFullScreen);
QVERIFY(!w.testAttribute(Qt::WA_Moved));
QVERIFY(!w.testAttribute(Qt::WA_Resized));
w.setWindowState(Qt::WindowMaximized);
QVERIFY(!w.testAttribute(Qt::WA_Moved));
QVERIFY(!w.testAttribute(Qt::WA_Resized));
w.setWindowState(Qt::WindowMinimized);
QVERIFY(!w.testAttribute(Qt::WA_Moved));
QVERIFY(!w.testAttribute(Qt::WA_Resized));
w.showNormal();
QVERIFY(!w.testAttribute(Qt::WA_Moved));
QVERIFY(!w.testAttribute(Qt::WA_Resized));
w.showMaximized();
QVERIFY(!w.testAttribute(Qt::WA_Moved));
QVERIFY(!w.testAttribute(Qt::WA_Resized));
w.showFullScreen();
QVERIFY(!w.testAttribute(Qt::WA_Moved));
QVERIFY(!w.testAttribute(Qt::WA_Resized));
w.showNormal();
w.move(10,10);
QVERIFY(w.testAttribute(Qt::WA_Moved));
#if defined(Q_OS_WIN)
QEXPECT_FAIL("", "FixMe, QTBUG-8911", Abort);
#endif
QVERIFY(!w.testAttribute(Qt::WA_Resized));
w.resize(100, 100);
QVERIFY(w.testAttribute(Qt::WA_Moved));
QVERIFY(w.testAttribute(Qt::WA_Resized));
#endif
}
void tst_QWidget::childAt()
{
QWidget parent(0, Qt::FramelessWindowHint);
parent.resize(200, 200);
QWidget *child = new QWidget(&parent);
child->setPalette(Qt::red);
child->setAutoFillBackground(true);
child->setGeometry(20, 20, 160, 160);
QWidget *grandChild = new QWidget(child);
grandChild->setPalette(Qt::blue);
grandChild->setAutoFillBackground(true);
grandChild->setGeometry(-20, -20, 220, 220);
QVERIFY(!parent.childAt(19, 19));
QVERIFY(!parent.childAt(180, 180));
QCOMPARE(parent.childAt(20, 20), grandChild);
QCOMPARE(parent.childAt(179, 179), grandChild);
grandChild->setAttribute(Qt::WA_TransparentForMouseEvents);
QCOMPARE(parent.childAt(20, 20), child);
QCOMPARE(parent.childAt(179, 179), child);
grandChild->setAttribute(Qt::WA_TransparentForMouseEvents, false);
child->setMask(QRect(50, 50, 60, 60));
QVERIFY(!parent.childAt(69, 69));
QVERIFY(!parent.childAt(130, 130));
QCOMPARE(parent.childAt(70, 70), grandChild);
QCOMPARE(parent.childAt(129, 129), grandChild);
child->setAttribute(Qt::WA_MouseNoMask);
QCOMPARE(parent.childAt(69, 69), grandChild);
QCOMPARE(parent.childAt(130, 130), grandChild);
child->setAttribute(Qt::WA_MouseNoMask, false);
grandChild->setAttribute(Qt::WA_TransparentForMouseEvents);
QCOMPARE(parent.childAt(70, 70), child);
QCOMPARE(parent.childAt(129, 129), child);
grandChild->setAttribute(Qt::WA_TransparentForMouseEvents, false);
grandChild->setMask(QRect(80, 80, 40, 40));
QCOMPARE(parent.childAt(79, 79), child);
QCOMPARE(parent.childAt(120, 120), child);
QCOMPARE(parent.childAt(80, 80), grandChild);
QCOMPARE(parent.childAt(119, 119), grandChild);
grandChild->setAttribute(Qt::WA_MouseNoMask);
QCOMPARE(parent.childAt(79, 79), grandChild);
QCOMPARE(parent.childAt(120, 120), grandChild);
}
#ifdef Q_WS_MAC
void tst_QWidget::childAt_unifiedToolBar()
{
QLabel *label = new QLabel(QLatin1String("foo"));
QToolBar *toolBar = new QToolBar;
toolBar->addWidget(new QLabel("dummy"));
toolBar->addWidget(label);
QMainWindow mainWindow;
mainWindow.addToolBar(toolBar);
mainWindow.show();
// Calculate the top-left corner of the tool bar and the label (in mainWindow's coordinates).
QPoint labelTopLeft = label->mapTo(&mainWindow, QPoint());
QPoint toolBarTopLeft = toolBar->mapTo(&mainWindow, QPoint());
QCOMPARE(mainWindow.childAt(toolBarTopLeft), static_cast<QWidget *>(toolBar));
QCOMPARE(mainWindow.childAt(labelTopLeft), static_cast<QWidget *>(label));
// Enable unified tool bars.
mainWindow.setUnifiedTitleAndToolBarOnMac(true);
QTest::qWait(50);
// The tool bar is now in the "non-client" area of QMainWindow, i.e.
// outside the mainWindow's rect(), and since mapTo et al. doesn't work
// in that case (see commit 35667fd45ada49269a5987c235fdedfc43e92bb8),
// we use mapToGlobal/mapFromGlobal to re-calculate the corners.
QPoint oldToolBarTopLeft = toolBarTopLeft;
toolBarTopLeft = mainWindow.mapFromGlobal(toolBar->mapToGlobal(QPoint()));
QVERIFY(toolBarTopLeft != oldToolBarTopLeft);
QVERIFY(toolBarTopLeft.y() < 0);
labelTopLeft = mainWindow.mapFromGlobal(label->mapToGlobal(QPoint()));
QCOMPARE(mainWindow.childAt(toolBarTopLeft), static_cast<QWidget *>(toolBar));
QCOMPARE(mainWindow.childAt(labelTopLeft), static_cast<QWidget *>(label));
}
#ifdef QT_MAC_USE_COCOA
void tst_QWidget::taskQTBUG_11373()
{
QMainWindow * myWindow = new QMainWindow();
QWidget * center = new QWidget();
myWindow -> setCentralWidget(center);
QWidget * drawer = new QWidget(myWindow, Qt::Drawer);
drawer -> hide();
QCOMPARE(drawer->isVisible(), false);
myWindow -> show();
myWindow -> raise();
// The drawer shouldn't be visible now.
QCOMPARE(drawer->isVisible(), false);
myWindow -> setWindowState(Qt::WindowFullScreen);
myWindow -> setWindowState(Qt::WindowNoState);
// The drawer should still not be visible, since we haven't shown it.
QCOMPARE(drawer->isVisible(), false);
}
#endif // QT_MAC_USE_COCOA
#endif
void tst_QWidget::taskQTBUG_17333_ResizeInfiniteRecursion()
{
QTableView tb;
const char *s = "border: 1px solid;";
tb.setStyleSheet(s);
tb.show();
QTest::qWaitForWindowShown(&tb);
tb.setGeometry(QRect(100, 100, 0, 100));
// No crash, it works.
}
void tst_QWidget::nativeChildFocus()
{
QWidget w;
QLayout *layout = new QVBoxLayout;
w.setLayout(layout);
QLineEdit *p1 = new QLineEdit;
QLineEdit *p2 = new QLineEdit;
layout->addWidget(p1);
layout->addWidget(p2);
p1->setObjectName("p1");
p2->setObjectName("p2");
w.show();
w.activateWindow();
p1->setFocus();
p1->setAttribute(Qt::WA_NativeWindow);
p2->setAttribute(Qt::WA_NativeWindow);
QApplication::processEvents();
QTest::qWaitForWindowShown(&w);
QCOMPARE(QApplication::activeWindow(), &w);
QCOMPARE(QApplication::focusWidget(), static_cast<QWidget*>(p1));
}
QTEST_MAIN(tst_QWidget)
#include "tst_qwidget.moc"
Reference in New Issue View Git Blame Copy Permalink