- Implement waitForWindowExposed() for toplevel windows.
- Implement waitForWindowShown(QWidget *) and mark as
deprecated in line with waitForWindowShown(QWindow*).
- Use in tests.
- Simplify tests (collapse waitForExposed, setActive
into setActiveWindow, waitForActive), remove most
hard-coded timeouts.
- Stabilize graphicsview tests by using waitForWindowActive.
Change-Id: Ic7c061e2745b36f71a715ee4e47c0346b11a91e8
Reviewed-by: Jason McDonald <jason.mcdonald@nokia.com>
}
-#ifdef Q_WS_X11
-extern void qt_x11_wait_for_window_manager(QWidget *w);
-#endif
-
QT_END_NAMESPACE
QT_END_HEADER
\sa QTest::qSleep()
*/
-/*! \fn bool QTest::qWaitForWindowShown(QWidget *window)
- \since 4.6
+/*! \fn bool QTest::qWaitForWindowExposed(QWindow *window, int timeout)
+ \since 5.0
- Waits until the \a window is shown on the screen. This is mainly useful for
- asynchronous systems like X11, where a window will be mapped to screen some
- time after being asked to show itself on the screen. Returns true.
+ Waits for \a timeout milliseconds or until the \a window is exposed.
+ Returns true if \c window is exposed within \a timeout milliseconds, otherwise returns false.
- Example:
- \snippet code/src_qtestlib_qtestcase.cpp 24
+ This is mainly useful for asynchronous systems like X11, where a window will be mapped to screen some
+ time after being asked to show itself on the screen.
+
+ \sa QTest::qWaitForWindowActive(), QWindow::isExposed()
+*/
+
+/*! \fn bool QTest::qWaitForWindowActive(QWindow *window, int timeout)
+ \since 5.0
+
+ Waits for \a timeout milliseconds or until the \a window is active.
+
+ Returns true if \c window is active within \a timeout milliseconds, otherwise returns false.
+
+ \sa QTest::qWaitForWindowExposed(), QWindow::isActive()
*/
/*! \fn bool QTest::qWaitForWindowShown(QWindow *window, int timeout)
\since 5.0
+ \deprecated
- Waits for \a timeout milliseconds or until the \a window is shown on the screen.
- This is mainly useful for asynchronous systems like X11, where a window will be mapped to screen some
- time after being asked to show itself on the screen.
+ Waits for \a timeout milliseconds or until the \a window is exposed.
+ Returns true if \c window is exposed within \a timeout milliseconds, otherwise returns false.
- Returns true if \c window is show in \a timout milliseconds, otherwise returns false.
+ This function does the same as qWaitForWindowExposed().
\sa QTest::qWaitForWindowActive(), QTest::qWaitForWindowExposed()
*/
-/*! \fn bool QTest::qWaitForWindowActive(QWindow *window, int timeout)
+/*! \fn bool QTest::qWaitForWindowExposed(QWidget *widget, int timeout)
\since 5.0
- Waits for \a timeout milliseconds or until the \a window is active.
+ Waits for \a timeout milliseconds or until the \a widget's window is exposed.
+ Returns true if \c widget's window is exposed within \a timeout milliseconds, otherwise returns false.
- Returns true if \c window is active in \a timout milliseconds, otherwise returns false.
+ This is mainly useful for asynchronous systems like X11, where a window will be mapped to screen some
+ time after being asked to show itself on the screen.
- \sa QTest::qWaitForWindowActive(), QTest::qWaitForWindowShown(), QWindow::isActive()
+ \sa QTest::qWaitForWindowActive()
*/
-/*! \fn bool QTest::qWaitForWindowExposed(QWindow *window, int timeout)
+/*! \fn bool QTest::qWaitForWindowActive(QWidget *widget, int timeout)
\since 5.0
- Waits for \a timeout milliseconds or until the \a window is exposed.
- Returns true if \c window is exposed in \a timout milliseconds, otherwise returns false.
+ Waits for \a timeout milliseconds or until the \a widget's window is active.
+
+ Returns true if \c widget's window is active within \a timeout milliseconds, otherwise returns false.
+
+ \sa QTest::qWaitForWindowExposed(), QWidget::isActiveWindow()
+*/
+
+/*! \fn bool QTest::qWaitForWindowShown(QWidget *widget, int timeout)
+ \since 5.0
+ \deprecated
+
+ Waits for \a timeout milliseconds or until the \a widget's window is exposed.
+ Returns true if \c widget's window is exposed within \a timeout milliseconds, otherwise returns false.
+
+ This function does the same as qWaitForWindowExposed().
- \sa QTest::qWaitForWindowShown(), QTest::qWaitForWindowExposed(), QWindow::isExposed()
+ Example:
+ \snippet code/src_qtestlib_qtestcase.cpp 24
+
+ \sa QTest::qWaitForWindowActive(), QTest::qWaitForWindowExposed()
*/
/*!
#include <QtCore/qcoreapplication.h>
#include <QtCore/qelapsedtimer.h>
#include <QtGui/QWindow>
+#ifdef QT_WIDGETS_LIB
+# include <QtWidgets/QWidget>
+#endif
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
-
-class QWidget;
-
namespace QTest
{
inline static void qWait(int ms)
} while (timer.elapsed() < ms);
}
- inline static bool qWaitForWindowShown(QWidget *window)
- {
- Q_UNUSED(window);
- qWait(200);
- return true;
- }
-
inline static bool qWaitForWindowActive(QWindow *window, int timeout = 1000)
{
QElapsedTimer timer;
return window->isExposed();
}
+#ifdef QT_WIDGETS_LIB
+ inline static bool qWaitForWindowActive(QWidget *widget, int timeout = 1000)
+ {
+ if (QWindow *window = widget->windowHandle())
+ return qWaitForWindowActive(window, timeout);
+ return false;
+ }
+
+ inline static bool qWaitForWindowExposed(QWidget *widget, int timeout = 1000)
+ {
+ if (QWindow *window = widget->windowHandle())
+ return qWaitForWindowExposed(window, timeout);
+ return false;
+ }
+#endif
+
#if QT_DEPRECATED_SINCE(6, 0)
QT_DEPRECATED inline static bool qWaitForWindowShown(QWindow *window, int timeout = 1000)
{
return qWaitForWindowExposed(window, timeout);
}
+
+# ifdef QT_WIDGETS_LIB
+ QT_DEPRECATED inline static bool qWaitForWindowShown(QWidget *widget, int timeout = 1000)
+ {
+ return qWaitForWindowExposed(widget, timeout);
+ }
+# endif // QT_WIDGETS_LIB
#endif // QT_DEPRECATED_SINCE(6, 0)
}
QWidget w;
w.resize(640, 480);
w.show();
- QTest::qWait(100);
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&w);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&w));
QVERIFY(QPixmap::grabWindow(w.winId()).isNull() == false);
QWidget child(&w);
child.setPalette(Qt::red);
child.setAutoFillBackground(true);
child.show();
- QTest::qWait(100);
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&child);
-#endif
-
- QPixmap grabWindowPixmap = QPixmap::grabWindow(child.winId());
- QPixmap grabWidgetPixmap = QPixmap::grabWidget(&child);
- lenientCompare(grabWindowPixmap, grabWidgetPixmap);
+ QTest::qWait(20);
+ const QPixmap grabWidgetPixmap = QPixmap::grabWidget(&child);
+ const WId childWinId = child.winId(); // Create native child
+ QVERIFY(QTest::qWaitForWindowExposed(child.windowHandle()));
+ const QPixmap grabWindowPixmap = QPixmap::grabWindow(childWinId);
+ QVERIFY(lenientCompare(grabWindowPixmap, grabWidgetPixmap));
#endif
}
scene.addWidget(widget)->setPos(0, 0);
QGraphicsView view(&scene);
+ // Use Qt::Tool as fully decorated windows have a minimum width of 160 on Windows.
+ view.setWindowFlags(view.windowFlags() | Qt::Tool);
view.setBackgroundBrush(Qt::white);
#ifdef Q_WS_QWS
view.setWindowFlags(Qt::FramelessWindowHint);
QGLWidget *viewport = new QGLWidget;
view.setViewport(viewport);
view.show();
+ qApp->setActiveWindow(&view);
if (!viewport->isValid())
return;
scene.setSceneRect(view.viewport()->rect());
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&view);
-#endif
- QTest::qWait(500);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
QImage image = viewport->grabFrameBuffer();
QImage expected = image;
{
QGLWidget* w = new QGLWidget(QGLFormat(QGL::AlphaChannel));
w->show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(w);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(w));
delete w;
}
w.resize(256, 128);
w.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&w);
-#endif
- QTest::qWait(200);
+ QVERIFY(QTest::qWaitForWindowExposed(&w));
QVERIFY(w.beginOk);
QVERIFY(w.engineType == QPaintEngine::OpenGL || w.engineType == QPaintEngine::OpenGL2);
w.resize(100, 100);
w.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&w);
-#endif
- QTest::qWait(200);
+ QVERIFY(QTest::qWaitForWindowExposed(&w));
QVERIFY(w.widgetPainterBeginOk);
QVERIFY(w.fboPainterBeginOk);
grandParentWidget.setGeometry(0, 100, 200, 200);
grandParentWidget.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(widget);
- qt_x11_wait_for_window_manager(&parentWidget);
-#endif
- QTest::qWait(200);
+ QVERIFY(QTest::qWaitForWindowExposed(widget));
+ QVERIFY(QTest::qWaitForWindowExposed(&grandParentWidget));
QVERIFY(parentWidget.children().count() == 1); // The layout
// Now both widgets should be created & shown, time to re-parent:
parentLayout.addWidget(widget);
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&parentWidget);
-#endif
- QTest::qWait(200);
+ QVERIFY(QTest::qWaitForWindowExposed(&grandParentWidget));
QVERIFY(parentWidget.children().count() == 2); // Layout & glwidget
QVERIFY(parentWidget.children().contains(widget));
- QVERIFY(widget->height() > 30);
+ QTRY_VERIFY(widget->height() > 30);
delete widget;
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&parentWidget);
-#endif
- QTest::qWait(200);
+ QVERIFY(QTest::qWaitForWindowExposed(&grandParentWidget));
QVERIFY(parentWidget.children().count() == 1); // The layout
widget = new GLWidget;
parentLayout.addWidget(widget);
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&parentWidget);
-#endif
- QTest::qWait(200);
+ QVERIFY(QTest::qWaitForWindowExposed(&grandParentWidget));
QVERIFY(parentWidget.children().count() == 2); // Layout & glwidget
QVERIFY(parentWidget.children().contains(widget));
glw.resize(300, 300);
glw.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&glw);
-#endif
- QTest::qWait(200);
+ QVERIFY(QTest::qWaitForWindowExposed(&glw));
QImage reference(300, 300, QImage::Format_RGB32);
QPainter referencePainter(&reference);
glw.resize(220, 220);
glw.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&glw);
-#endif
- QTest::qWait(200);
+ QVERIFY(QTest::qWaitForWindowExposed(&glw));
QImage reference(glw.size(), QImage::Format_RGB32);
QPainter referencePainter(&reference);
QMainWindow *mw = new QMainWindow;
mw->resize(300, 200);
mw->show(); // triggers layout
+ qApp->setActiveWindow(mw);
QLatin1String name = QLatin1String("I am the main window");
mw->setWindowTitle(name);
- QTest::qWaitForWindowShown(mw);
+ QVERIFY(QTest::qWaitForWindowActive(mw));
// The order of events is not really that important.
QAccessibleEvent show(mw, QAccessible::ObjectShow);
QMdiArea mdiArea;
mdiArea.show();
qApp->setActiveWindow(&mdiArea);
-#if defined(Q_OS_UNIX)
- QCoreApplication::processEvents();
- QTest::qWait(150);
-#endif
+ QVERIFY(QTest::qWaitForWindowActive(&mdiArea));
+
const int subWindowCount = 5;
for (int i = 0; i < subWindowCount; ++i) {
QNonNativeFileDialog fd(0,QString("Test it"),startPath);
fd.setOptions(QFileDialog::DontUseNativeDialog);
fd.show();
+ QVERIFY(QTest::qWaitForWindowExposed(&fd));
QVERIFY(fd.isVisible());
QFileSystemModel *model = qFindChild<QFileSystemModel*>(&fd, "qt_filesystem_model");
QVERIFY(model);
QGraphicsView view(&scene);
view.show();
- QTest::qWaitForWindowShown(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
QTRY_VERIFY(item->numRepaints > 0);
item->reset();
view.showFullScreen();
else
view.show();
- QTest::qWaitForWindowShown(&view);
+ qApp->setActiveWindow(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
QTRY_VERIFY(item->nbPaint >= 1);
item->nbPaint = 0;
QGraphicsView view(&scene);
view.show();
- QTest::qWaitForWindowShown(&view);
+ qApp->setActiveWindow(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
QTRY_VERIFY(child->nbPaint >= 1);
CustomEffect *effect = new CustomEffect;
scene->addItem(item);
view = new QGraphicsView(scene);
view->show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(view);
-#endif
- QTest::qWait(200);
+ QVERIFY(QTest::qWaitForWindowActive(view));
}
void tst_QGraphicsEffectSource::cleanupTestCase()
QGraphicsView view(&scene);
QApplication::setActiveWindow(&view);
view.show();
- QTest::qWaitForWindowShown(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
item->setFocus();
QTRY_VERIFY(item->hasFocus());
QCOMPARE(view.inputMethodHints(), item->inputMethodHints());
QGraphicsView view(&scene);
view.setFixedSize(200, 200);
view.show();
- QTest::qWait(250);
+ QApplication::setActiveWindow(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
{
QHelpEvent helpEvent(QEvent::ToolTip, view.viewport()->rect().topLeft(),
view.viewport()->mapToGlobal(view.viewport()->rect().topLeft()));
QGraphicsView view(&scene);
view.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&view);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&view));
+
QApplication::processEvents();
#ifdef Q_WS_QWS
QApplication::sendPostedEvents(); //glib workaround
QGraphicsScene scene;
QGraphicsView view(&scene);
view.show();
- QTest::qWaitForWindowShown(&view);
- QTest::qWait(150);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
EventTester *tester = new EventTester;
scene.addItem(tester);
QGraphicsView view(&scene);
view.show();
QApplication::setActiveWindow(&view);
- QTest::qWaitForWindowShown(&view);
- QTest::qWait(25);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
QGraphicsTextItem *text1 = scene.addText(QLatin1String("Text1"));
QGraphicsTextItem *text2 = scene.addText(QLatin1String("Text2"));
view.showFullScreen();
else
view.show();
- QTest::qWaitForWindowShown(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
QTRY_VERIFY(view.repaints >= 1);
#define RESET_REPAINT_COUNTERS \
MyGraphicsView view(&scene);
view.show();
- QTest::qWaitForWindowShown(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
QTRY_VERIFY(view.repaints > 0);
view.reset();
rect->translate(0, 50);
QGraphicsView view(&scene);
view.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&view);
-#endif
-
+ QVERIFY(QTest::qWaitForWindowExposed(&view));
rect->translate(0, 100);
QTransform x;
x.translate(0, 150);
QWidget widget;
widget.setLayout(layout);
widget.show();
- QTest::qWaitForWindowShown(&widget);
- QTest::qWait(2000);
+ QVERIFY(QTest::qWaitForWindowActive(&widget));
QTRY_VERIFY(scene.isActive());
topLevel.resize(300, 300);
topLevel.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&view);
-#endif
- QTest::qWait(100);
+ QVERIFY(QTest::qWaitForWindowExposed(&topLevel));
EventTester *item = new EventTester;
scene.addItem(item);
MyGraphicsView view(&scene);
view.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&view);
-#endif
- QTest::qWait(100);
+ QVERIFY(QTest::qWaitForWindowExposed(&view));
EventTester *parent = new EventTester;
EventTester *child = new EventTester(parent);
MyGraphicsView view(&scene);
view.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&view);
-#endif
- QTest::qWait(200);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
view.reset();
QRectF brect = item->boundingRect();
scene.addItem(item2);
QGraphicsView view(&scene);
+ // Use Qt::Tool as fully decorated windows have a minimum width of 160 on Windows.
+ view.setWindowFlags(view.windowFlags() | Qt::Tool);
view.setResizeAnchor(QGraphicsView::NoAnchor);
view.setTransformationAnchor(QGraphicsView::NoAnchor);
view.resize(120, 100);
view.setFrameStyle(0);
view.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&view);
-#endif
+ qApp->setActiveWindow(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
QTest::qWait(100);
_paintedItems.clear();
QGraphicsView view(&scene);
view.show();
- QTest::qWaitForWindowShown(&view);
+ qApp->setActiveWindow(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
QTRY_VERIFY(!_paintedItems.isEmpty());
_paintedItems.clear();
QGraphicsView view(&scene);
view.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&view);
-#endif
- QTest::qWait(100);
+ QVERIFY(QTest::qWaitForWindowExposed(&view));
// Confuse the BSP with dummy items.
QGraphicsRectItem *dummy = new QGraphicsRectItem(0, 0, 20, 20);
QGraphicsView view(&scene, &toplevel);
toplevel.resize(300, 300);
toplevel.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&toplevel);
-#endif
- QTest::qWait(100);
+ QVERIFY(QTest::qWaitForWindowExposed(&toplevel));
// Confuse the BSP with dummy items.
QGraphicsRectItem *dummy = new QGraphicsRectItem(0, 0, 20, 20);
QGraphicsView view(&scene);
view.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&view);
-#endif
- QTest::qWait(125);
+ QVERIFY(QTest::qWaitForWindowExposed(&view));
delete rect;
MyGraphicsView view(&scene);
view.setFrameStyle(0);
view.show();
- QTest::qWaitForWindowShown(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
QTRY_VERIFY(view.repaints > 0);
view.reset();
view.showFullScreen();
else
view.show();
- QTest::qWaitForWindowShown(&view);
+ qApp->setActiveWindow(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
QTRY_VERIFY(view.repaints > 0);
// test case #1
view.showFullScreen();
else
view.show();
- QTest::qWaitForWindowShown(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
view.reset();
parentGreen->setOpacity(1.0);
scene.addItem(parentGreen);
origView.show();
- QTest::qWaitForWindowShown(&origView);
+ QVERIFY(QTest::qWaitForWindowActive(&origView));
origView.setGeometry(origView.width() + 20, 20,
origView.width(), origView.height());
QTRY_COMPARE(origView.repaints, 1);
view.show();
-
- QTest::qWaitForWindowShown(&view);
+ qApp->setActiveWindow(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
view.reset();
origView.reset();
QGraphicsScene scene;
QGraphicsView view(&scene);
view.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&view);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&view));
QPointer<SubQGraphicsProxyWidget> proxy = new SubQGraphicsProxyWidget;
SubQGraphicsProxyWidget parentProxy;
scene.addItem(proxy);
QGraphicsView view(&scene);
view.show();
QApplication::setActiveWindow(&view);
- QTest::qWaitForWindowShown(&view);
- QTRY_COMPARE(QApplication::activeWindow(), (QWidget*)&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
if (hasScene) {
scene.addItem(proxy);
proxy->show();
QApplication::setActiveWindow(&view);
view.activateWindow();
view.setFocus();
- QTest::qWaitForWindowShown(&view);
+ QTest::qWaitForWindowActive(&view);
QTRY_VERIFY(view.isVisible());
QTRY_COMPARE(QApplication::activeWindow(), (QWidget*)&view);
//do not let the window manager move the window while we are moving the mouse on it
view.setWindowFlags(Qt::X11BypassWindowManagerHint);
view.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&view);
-#endif
+ QApplication::setActiveWindow(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
SubQGraphicsProxyWidget *proxy = new SubQGraphicsProxyWidget;
EventLogger *widget = new EventLogger;
QGraphicsScene scene;
QGraphicsView view(&scene);
view.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&view);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&view));
WheelWidget *wheelWidget = new WheelWidget();
wheelWidget->setFixedSize(400, 400);
View view(&scene);
view.show();
- QTest::qWaitForWindowShown(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
QTRY_VERIFY(view.npaints >= 1);
QTest::qWait(20);
widget->paintEventRegion = QRegion();
window.show();
QApplication::setActiveWindow(&window);
window.activateWindow();
- QTest::qWaitForWindowShown(&window);
- QTRY_COMPARE(QApplication::activeWindow(), &window);
+ QVERIFY(QTest::qWaitForWindowActive(&window));
leftDial->setFocus();
QApplication::processEvents();
QGraphicsView view(&scene);
view.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&view);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&view));
box->showPopup();
QGraphicsView view(&scene);
view.setFixedSize(200, 200);
view.show();
- QTest::qWaitForWindowShown(&view);
+ QApplication::setActiveWindow(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
{
QHelpEvent helpEvent(QEvent::ToolTip, view.viewport()->rect().topLeft(),
view.viewport()->mapToGlobal(view.viewport()->rect().topLeft()));
QApplication::setActiveWindow(&view);
view.show();
- QTest::qWaitForWindowShown(&view);
- QApplication::sendPostedEvents();
- QTRY_VERIFY(view.isActiveWindow());
+ QVERIFY(QTest::qWaitForWindowActive(&view));
+ QVERIFY(view.isActiveWindow());
qRegisterMetaType<QList<QRectF> >("QList<QRectF>");
QSignalSpy signalSpy(&scene, SIGNAL(changed(const QList<QRectF> &)));
QGraphicsView view(&scene);
view.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&view);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&view));
QMimeData data;
data.setText("hei");
QGraphicsProxyWidget *proxy = scene.addWidget(new QPushButton("Hello World"));
View view(&scene);
view.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&view);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&view));
QTRY_VERIFY(view.npaints > 0);
// Wait a bit to clear all pending paint events
QTest::qWait(10);
lineEdit->setAttribute(Qt::WA_InputMethodEnabled, true);
QGraphicsProxyWidget *proxy = scene.addWidget(w);
view.show();
- QTest::qWaitForWindowShown(&view);
- QTRY_VERIFY(!(proxy->flags() & QGraphicsItem::ItemAcceptsInputMethod));
+ QVERIFY(QTest::qWaitForWindowActive(&view));
+ QVERIFY(!(proxy->flags() & QGraphicsItem::ItemAcceptsInputMethod));
lineEdit->setFocus();
QVERIFY((proxy->flags() & QGraphicsItem::ItemAcceptsInputMethod));
}
view.setFrameStyle(0);
view.resize(300, 300);
view.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&view);
-#endif
QApplication::setActiveWindow(&view);
- QTRY_COMPARE(QApplication::activeWindow(), (QWidget*)&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
QVERIFY(!proxy->hasFocus());
QVERIFY(!proxy->widget()->hasFocus());
QGraphicsView view(&scene);
view.setFixedSize(150, 150);
view.show();
- QTest::qWaitForWindowShown(view.windowHandle());
+ QApplication::setActiveWindow(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
QTest::mouseMove(view.viewport(), QPoint(-1, -1));
{
QMouseEvent moveEvent(QEvent::MouseMove, view.mapFromScene(hoverItem->scenePos() + QPointF(20, 20)), Qt::NoButton, 0, 0);
view.rotate(10);
view.scale(1.7, 1.7);
view.show();
- QTest::qWaitForWindowShown(&view);
- QTest::qWait(70);
+ qApp->setActiveWindow(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMouseMove);
mouseEvent.setScenePos(QPointF(-1000, -1000));
CustomView view;
view.setScene(&scene);
view.show();
- QTest::qWaitForWindowShown(&view);
+ qApp->setActiveWindow(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
QTRY_VERIFY(view.repaints >= 1);
view.repaints = 0;
widget.show();
qApp->setActiveWindow(&widget);
widget.activateWindow();
- QTest::qWait(125);
+ QVERIFY(QTest::qWaitForWindowActive(&widget));
dial1->setFocus();
QVERIFY(dial1->hasFocus());
widget.show();
qApp->setActiveWindow(&widget);
widget.activateWindow();
- QTest::qWaitForWindowShown(&widget);
- QApplication::processEvents();
+ QVERIFY(QTest::qWaitForWindowActive(&widget));
dial1->setFocus();
QTRY_VERIFY(dial1->hasFocus());
view.show();
QApplication::setActiveWindow(&view);
view.setFocus();
- QTest::qWaitForWindowShown(&view);
- QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&view));
+ QVERIFY(QTest::qWaitForWindowActive(&view));
+ QCOMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&view));
inputContext.m_resetCallCount = 0;
inputContext.m_commitCallCount = 0;
toplevel1.show();
QApplication::setActiveWindow(&toplevel1);
- QTest::qWaitForWindowShown(&toplevel1);
- QTRY_COMPARE(QApplication::activeWindow(), &toplevel1);
+ QVERIFY(QTest::qWaitForWindowActive(&toplevel1));
+ QCOMPARE(QApplication::activeWindow(), &toplevel1);
QVERIFY(!scene1.isActive()); //it is hidden;
QVERIFY(scene2.isActive());
toplevel1.show();
QApplication::setActiveWindow(&toplevel1);
- QApplication::processEvents();
- QTRY_COMPARE(QApplication::activeWindow(), &toplevel1);
+ QVERIFY(QTest::qWaitForWindowActive(&toplevel1));
+ QCOMPARE(QApplication::activeWindow(), &toplevel1);
QTRY_VERIFY(scene1.isActive());
QTRY_VERIFY(!scene2.isActive());
toplevel2.show();
QApplication::setActiveWindow(&toplevel2);
- QTest::qWaitForWindowShown(&toplevel2);
- QTRY_COMPARE(QApplication::activeWindow(), &toplevel2);
+ QVERIFY(QTest::qWaitForWindowActive(&toplevel2));
+ QCOMPARE(QApplication::activeWindow(), &toplevel2);
QVERIFY(scene1.isActive());
QVERIFY(!scene2.isActive());
topLevelView.show();
QApplication::setActiveWindow(&topLevelView);
topLevelView.setFocus();
- QTest::qWaitForWindowShown(&topLevelView);
- QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&topLevelView));
+ QVERIFY(QTest::qWaitForWindowActive(&topLevelView));
+ QCOMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&topLevelView));
QVERIFY(!scene1.isActive());
QVERIFY(!scene2.isActive());
QVERIFY(!scene2.hasFocus());
QApplication::setActiveWindow(&toplevel2);
- QTRY_COMPARE(QApplication::activeWindow(), &toplevel2);
+ QVERIFY(QTest::qWaitForWindowActive(&toplevel2));
QVERIFY(!scene1.isActive());
QVERIFY(scene2.isActive());
CustomView view;
view.setScene(&scene);
view.show();
- QTest::qWaitForWindowShown(&view);
+ qApp->setActiveWindow(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
// NB! The parent has the ItemHasNoContents flag set, which means
// the parent itself doesn't generate any update requests, only the
QGraphicsView view(&scene);
view.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&view);
-#endif
- QTest::qWait(250);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
+ qApp->setActiveWindow(&view);
scene.clear();
// Make sure the index is re-generated after QGraphicsScene::clear();
SOURCES += tst_qgraphicsview.cpp tst_qgraphicsview_2.cpp
DEFINES += QT_NO_CAST_TO_ASCII
+
+mac:CONFIG+=insignificant_test # QTBUG-26580
view.setFixedSize(300, 300);
QCOMPARE(item->events.size(), 0);
view.show();
- QTest::qWaitForWindowShown(&view);
view.activateWindow();
+ QVERIFY(QTest::qWaitForWindowActive(&view));
- QApplication::processEvents();
QTRY_COMPARE(item->events.size(), 1); // activate
QPoint itemPoint = view.mapFromScene(item->scenePos());
view.setFrameStyle(0);
view.resize(300, 300);
view.show();
- QTest::qWaitForWindowShown(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
QTRY_VERIFY(rect->numPaints > 0);
rect->numPaints = 0;
// Show the view, and initialize our test.
view.show();
- QTest::qWaitForWindowShown(&view);
+ qApp->setActiveWindow(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
QTRY_VERIFY(!view.lastUpdateRegions.isEmpty());
view.lastUpdateRegions.clear();
view.rotate(45);
view.scale(1.5, 1.5);
view.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&view);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&view));
// Make sure the view is repainted; otherwise the tests below will fail.
view.viewport()->repaint();
view.setVerticalScrollBarPolicy(vbarpolicy);
view.show();
+ QVERIFY(QTest::qWaitForWindowExposed(&view));
QCOMPARE(view.horizontalScrollBar()->minimum(), hmin);
QCOMPARE(view.verticalScrollBar()->minimum(), vmin);
QGraphicsScene scene(0, 0, 200, 200);
QGraphicsView view(&scene);
view.show();
- QTest::qWaitForWindowShown(&view);
+ qApp->setActiveWindow(&view);
+ QVERIFY(QTest::qWaitForWindowShown(&view));
EventSpy updateSpy(view.viewport(), QEvent::Paint);
QCOMPARE(updateSpy.count(), 0);
QCOMPARE(spy.count(), 0);
view->show();
- QTest::qWaitForWindowShown(view);
+ qApp->setActiveWindow(view);
+ QVERIFY(QTest::qWaitForWindowActive(view));
QTRY_VERIFY(spy.count() >= 1);
spy.reset();
CustomView view;
view.setScene(&scene);
view.show();
- QTest::qWaitForWindowShown(&view);
+ qApp->setActiveWindow(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
+
QTRY_VERIFY(item->paints > 0);
item->paints = 0;
view.setFrameStyle(0);
view.resize(200, 200);
view.show();
- QTest::qWaitForWindowShown(&view) ;
+ qApp->setActiveWindow(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
QTRY_VERIFY(rect->numPaints > 0);
// Calculate expected update region for the rect.
CustomView view(&scene);
view.show();
- QTest::qWaitForWindowShown(&view);
+ qApp->setActiveWindow(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
QTRY_VERIFY(view.painted);
view.lastUpdateRegions.clear();
CustomView view(&scene);
view.show();
- QTest::qWaitForWindowShown(&view);
+ qApp->setActiveWindow(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
QTRY_VERIFY(view.painted);
view.lastUpdateRegions.clear();
QVERIFY(view.testAttribute(Qt::WA_InputMethodEnabled));
view.show();
- QTest::qWaitForWindowShown(&view);
QApplication::setActiveWindow(&view);
- QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&view));
+ QVERIFY(QTest::qWaitForWindowActive(&view));
+ QCOMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&view));
QGraphicsItem *item1 = new QGraphicsRectItem;
item1->setFlags(QGraphicsItem::ItemIsFocusable | QGraphicsItem::ItemAcceptsInputMethod);
VpGraphicsView view(&scene);
view.setWindowFlags(Qt::X11BypassWindowManagerHint);
view.show();
-
- QTest::qWaitForWindowShown(&view);
- QTest::qWait(50);
+ qApp->setActiveWindow(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
QPoint mouseViewPos(20, 20);
sendMouseMove(view.viewport(), mouseViewPos);
view.setWindowFlags(view.windowFlags()|Qt::X11BypassWindowManagerHint);
view.scale(4.15, 4.15);
view.show();
- QTest::qWaitForWindowShown(&view);
+ qApp->setActiveWindow(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
view.viewport()->repaint(10,10,20,20);
QApplication::processEvents();
QCursor::setPos(1,1);
view.show();
- QTest::qWaitForWindowShown(&view);
+ qApp->setActiveWindow(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
QPoint pos = view.viewport()->mapToGlobal(view.mapFromScene(item->mapToScene(10, 10)));
QCursor::setPos(pos);
view.setFixedSize(40, 40);
view.show();
- QTest::qWaitForWindowShown(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
scene.setFocusItem(item);
view.setFocus();
QGraphicsScene scene;
QGraphicsView view(&scene);
view.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&view);
-#endif
QApplication::setActiveWindow(&view);
- QTRY_COMPARE(QApplication::activeWindow(), (QWidget*)&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
view.setAlignment(Qt::AlignTop | Qt::AlignLeft);
SubQGraphicsWidget *widget = new SubQGraphicsWidget;
if (underMouse) {
view.resize(300, 300);
view.show();
- QTest::qWaitForWindowShown(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
sendMouseMove(view.viewport(), view.mapFromScene(widget->mapToScene(widget->boundingRect().center())));
}
QGraphicsScene scene;
QGraphicsView view(&scene);
view.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&view);
-#endif
QApplication::setActiveWindow(&view);
- QTRY_COMPARE(QApplication::activeWindow(), (QWidget*)&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
QGraphicsWidget *lastItem = 0;
QTest::ignoreMessage(QtWarningMsg, "QGraphicsWidget::setTabOrder(0, 0) is undefined");
QGraphicsView view(&scene);
view.show();
QApplication::setActiveWindow(&view);
- QTest::qWaitForWindowShown(&view);
- QTRY_COMPARE(QApplication::activeWindow(), (QWidget*)&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
{
// parent/child focus
scene.addItem(w1_2);
window->show();
QApplication::setActiveWindow(window);
- QTest::qWaitForWindowShown(window);
+ QVERIFY(QTest::qWaitForWindowActive(window));
lineEdit->setFocus();
QTRY_VERIFY(lineEdit->hasFocus());
QGraphicsScene scene;
QGraphicsView view(&scene);
view.show();
- QTest::qWaitForWindowExposed(view.windowHandle());
QApplication::setActiveWindow(&view);
- QTRY_COMPARE(QApplication::activeWindow(), (QWidget*)&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
// delete item in focus chain with no focus and verify chain
SubQGraphicsWidget *parent = new SubQGraphicsWidget(0, Qt::Window);
QGraphicsView view(&scene);
view.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&view);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&view));
QTRY_VERIFY(!scene.itemAt(25, 25));
widget->setGeometry(0, 112, 360, 528);
QGraphicsView view(&scene);
view.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&view);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&view));
QSizeF initialSize = widget->size();
widget->resize(initialSize);
view->show();
window->setGeometry(0, 0, 70, 70);
- QTest::qWaitForWindowShown(view);
+ QVERIFY(QTest::qWaitForWindowActive(view));
{ // here we go - simulate a interactive resize of the window
QTest::mouseMove(view, view->mapFromScene(71, 71)); // bottom right corner
view.showFullScreen();
else
view.show();
- QTest::qWaitForWindowShown(&view);
+ qApp->setActiveWindow(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
scene.addItem(widget);
dummyView->setWindowFlags(Qt::X11BypassWindowManagerHint);
EventSpy paintSpy(dummyView->viewport(), QEvent::Paint);
dummyView->show();
- QTest::qWaitForWindowShown(dummyView);
+ qApp->setActiveWindow(dummyView);
+ QVERIFY(QTest::qWaitForWindowActive(dummyView));
const int expectedRepaintCount = paintSpy.count();
delete dummyView;
dummyView = 0;
QGraphicsView view(&scene);
view.setWindowFlags(view.windowFlags()|Qt::X11BypassWindowManagerHint);
view.show();
- QTest::qWaitForWindowShown(&view);
+ qApp->setActiveWindow(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
#if defined(Q_OS_WIN) || defined(UBUNTU_LUCID)
QEXPECT_FAIL("", "QTBUG-20778", Abort);
QMouseEvent event(QEvent::MouseMove, pos, widget->mapToGlobal(pos), Qt::NoButton, 0, 0);
QCursor::setPos(widget->mapToGlobal(pos));
qApp->processEvents();
-#if defined(Q_WS_X11)
- qt_x11_wait_for_window_manager(widget);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(widget));
QApplication::sendEvent(widget, &event);
}
widget.show();
view.show();
-#if defined(Q_WS_X11)
- qt_x11_wait_for_window_manager(&widget);
- qt_x11_wait_for_window_manager(&view);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&widget));
+ QVERIFY(QTest::qWaitForWindowExposed(&view));
widget.dragAndDrop(&view, dropAction);
if (model.dropAction() == dropAction
view.setFixedSize(size, size);
view.move(int(size * 1.5), int(size * 1.5));
view.show();
-#if defined(Q_WS_X11)
- qt_x11_wait_for_window_manager(&view);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&view));
view.dragAndDrop(view.visualRect(parent).center(),
view.visualRect(child).center());
}
}
v.show();
+ QVERIFY(QTest::qWaitForWindowExposed(&v));
#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&v);
QCursor::setPos(v.geometry().center());
QApplication::syncX();
#endif
TestItemDelegate *delegate = new TestItemDelegate(&table);
table.setItemDelegate(delegate);
table.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&table);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&table));
QTableWidgetItem *item = new QTableWidgetItem;
item->setText(itemText);
TestItemDelegate delegate;
table.setItemDelegate(&delegate);
table.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&table);
-#endif
QApplication::setActiveWindow(&table);
- QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget*>(&table));
+ QVERIFY(QTest::qWaitForWindowActive(&table));
QVariant value;
switch ((QVariant::Type)type) {
QListView view;
view.setModel(&model);
view.show();
- QTest::qWait(30);
+ qApp->setActiveWindow(&view);
+ QVERIFY(QTest::qWaitForWindowActive(&view));
+
// QCOMPARE(view.currentIndex() , model.index(0,0));
QTest::keyClick(&view, Qt::Key_K);
// Make sure the widget gets the first full repaint. On
// some WMs, we'll get two (first inactive exposure, then
// active exposure.
- QTest::qWaitForWindowShown(&widget);
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&widget);
-#endif
- QApplication::processEvents();
- QTest::qWait(500);
+ QVERIFY(QTest::qWaitForWindowActive(&topLevel));
QSize itemSize = widget.visualItemRect(widget.item(0)).size();
QVERIFY(!itemSize.isEmpty());
new QListWidgetItem(QLatin1String("completer"), &listWidget);
listWidget.show();
listWidget.setCurrentItem(item);
- QTest::qWaitForWindowShown(&listWidget);
+ qApp->setActiveWindow(&listWidget);
+ QVERIFY(QTest::qWaitForWindowActive(&listWidget));
listWidget.setFocus();
QCOMPARE(qApp->focusWidget(), &listWidget);
treeView->setModel(model);
topLevel->show();
treeView->resize(50,50);
-
- QTest::qWaitForWindowShown(treeView);
- qApp->processEvents();
+ qApp->setActiveWindow(topLevel);
+ QVERIFY(QTest::qWaitForWindowActive(topLevel));
QList<QStandardItem *> projlist;
for (int k = 0; k < 10; ++k)
view.resize(200, view.visualRect(model.index(0,0)).height()*10);
topLevel.show();
QApplication::setActiveWindow(&topLevel);
- QTest::qWaitForWindowShown(&topLevel);
- QTRY_VERIFY(topLevel.isActiveWindow());
+ QVERIFY(QTest::qWaitForWindowActive(&topLevel));
+ QVERIFY(topLevel.isActiveWindow());
view.setCurrentIndex(model.index(1, 0));
QTest::keyClick(view.viewport(), Qt::Key_Up);
testWidget = new CustomTreeWidget();
testWidget->show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(testWidget);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(testWidget));
}
void tst_QTreeWidget::cleanupTestCase()
QTreeWidget tree;
populate(&tree, topLevelItems, new TreeItem(QStringList() << "1" << "2"));
tree.show();
- QTest::qWaitForWindowShown(&tree);
+ QVERIFY(QTest::qWaitForWindowActive(&tree));
QSignalSpy itemChangedSpy(
&tree, SIGNAL(itemChanged(QTreeWidgetItem*,int)));
app.alert(&widget, 100);
widget.show();
widget2.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&widget);
- qt_x11_wait_for_window_manager(&widget2);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&widget));
+ QVERIFY(QTest::qWaitForWindowExposed(&widget2));
QTest::qWait(100);
app.alert(&widget, -1);
app.alert(&widget, 250);
w.setLayout(&form);
form.addRow("Label", new QPushButton(&w));
w.show();
-/*#if defined(Q_WS_X11)
- qt_x11_wait_for_window_manager(&w); // wait for the show
-#endif*/
+ QVERIFY(QTest::qWaitForWindowExposed(&w));
int l, t, r, b;
form.getContentsMargins(&l, &t, &r, &b);
QRect geom = form.geometry();
}
m_toplevel->show();
-#if defined(Q_WS_X11)
- qt_x11_wait_for_window_manager(m_toplevel); // wait for the show
-#endif
- QTest::qWait(40);
+ QVERIFY(QTest::qWaitForWindowExposed(m_toplevel));
m_toplevel->adjustSize();
QTest::qWait(240); // wait for the implicit adjustSize
// If the following fails we might have to wait longer.
widget->setParent(&toplevel);
widget->resize(widget->sizeHint());
toplevel.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&toplevel); // wait for the show
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&toplevel));
QLayout *layout = widget->layout();
QVERIFY(layout);
w.setLayout(&grid);
grid.addWidget(new QPushButton(&w));
w.show();
-#if defined(Q_WS_X11)
- qt_x11_wait_for_window_manager(&w); // wait for the show
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&w));
int l, t, r, b;
grid.getContentsMargins(&l, &t, &r, &b);
QRect geom = grid.geometry();
layout->addWidget(other1);
layout->addWidget(other2);
myBox.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&myBox);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&myBox));
setupShortcut(other1, "ActiveWindow", TriggerSlot1, QKeySequence("Alt+1"), Qt::WindowShortcut);
setupShortcut(other2, "Focus", TriggerSlot2, QKeySequence("Alt+2"), Qt::WidgetShortcut);
other2->activateWindow();
other2->setFocus(); // ###
qApp->syncX();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(other2);
-#endif
- QTest::qWait(100);
- QCOMPARE(qApp->activeWindow(), other2->window());
+ QTRY_COMPARE(qApp->activeWindow(), other2->window());
QCOMPARE(qApp->focusWidget(), (QWidget *)other2);
currentResult = NoResult;
QCOMPARE(other2->toPlainText(), QString(""));
clearAllShortcuts();
- delete other1;
- delete other2;
- edit->activateWindow();
- qApp->syncX();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(edit);
-#endif
- QTest::qWait(100);
}
// ------------------------------------------------------------------
parent.setGeometry(desktopDimensions);
parent.setPalette(Qt::red);
parent.show();
- QTest::qWaitForWindowShown(&parent);
+ qApp->setActiveWindow(&parent);
+ QVERIFY(QTest::qWaitForWindowActive(&parent));
QTest::qWait(10);
const QPoint tlwOffset = parent.geometry().topLeft();
w1.resize(200, 200);
w1.show();
- QTest::qWaitForWindowShown(&w1);
+ QVERIFY(QTest::qWaitForWindowExposed(&w1));
w2.resize(200,200);
w2.show();
- QTest::qWaitForWindowShown(&w2);
-
- QTest::qWait(100);
+ QVERIFY(QTest::qWaitForWindowExposed(&w2));
QApplication::setActiveWindow(&w1);
w1.activateWindow();
- QApplication::processEvents();
- QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&w1));
+ QVERIFY(QTest::qWaitForWindowActive(&w1));
+ QCOMPARE(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));
+ QVERIFY(QTest::qWaitForWindowActive(&w2));
+ QCOMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&w2));
QTest::mouseClick(&w2, Qt::LeftButton);
QTRY_COMPARE(QApplication::focusWidget(), (QWidget *)0);
w1.activateWindow();
QApplication::setActiveWindow(&w1);
- QApplication::processEvents();
- QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&w1));
+ QVERIFY(QTest::qWaitForWindowActive(&w1));
+ QCOMPARE(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));
+ QVERIFY(QTest::qWaitForWindowActive(&w2));
+ QCOMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&w2));
QTest::mouseClick(&w2, Qt::LeftButton);
QTRY_COMPARE(QApplication::focusWidget(), (QWidget *)0);
}
QWidget window;
UpdateWidget widget(&window);
window.show();
- QTest::qWaitForWindowShown(&window);
+ qApp->setActiveWindow(&window);
+ QVERIFY(QTest::qWaitForWindowActive(&window));
QTRY_VERIFY(widget.numPaintEvents > 0);
widget.reset();
UpdateWidget topLevel;
topLevel.resize(150, 150);
topLevel.show();
- QTest::qWaitForWindowShown(&topLevel);
+ qApp->setActiveWindow(&topLevel);
+ QVERIFY(QTest::qWaitForWindowActive(&topLevel));
QTRY_VERIFY(topLevel.numPaintEvents > 0);
topLevel.reset();
toplevel->show();
QTest::qWaitForWindowShown(toplevel);
QApplication::setActiveWindow(toplevel);
+ QVERIFY(QTest::qWaitForWindowActive(toplevel));
QVERIFY(toplevel->hasFocus());
QVERIFY(child->hasFocus());
wid4->setObjectName("wid4");
w.show();
- QTest::qWait(100);
+ qApp->setActiveWindow(&w);
+ QVERIFY(QTest::qWaitForWindowActive(&w));
QColor normalToolTip = qApp->palette().toolTipBase().color();
QList<QWidget *> widgets;
edit.setCompleter(completer);
edit.show();
edit.setFocus();
-
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&edit);
-#endif
- QTest::qWait(10);
QApplication::setActiveWindow(&edit);
- QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&edit));
+ QVERIFY(QTest::qWaitForWindowActive(&edit));
QTest::keyClick(&edit, 'i');
QCOMPARE(edit.completer()->currentCompletion(), QString("iota"));
edit.setCompleter(&completer);
edit.show();
edit.setFocus();
-
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&edit);
-#endif
-
- QTest::qWait(10);
QApplication::setActiveWindow(&edit);
- QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&edit));
+ QVERIFY(QTest::qWaitForWindowActive(&edit));
QTest::keyClick(&edit, 'r');
QTest::keyClick(edit.completer()->popup(), Qt::Key_Down);
edit.show();
QApplication::setActiveWindow(&edit);
- QTest::qWaitForWindowShown(&edit);
- QTRY_VERIFY(QApplication::activeWindow() == &edit);
+ QVERIFY(QTest::qWaitForWindowActive(&edit));
+ QCOMPARE(QApplication::activeWindow(), &edit);
edit.setFocus();
QTRY_VERIFY(edit.hasFocus());
correctBox.addItems(finalContent);
correctBox.show();
- QCoreApplication::processEvents();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&box);
- qt_x11_wait_for_window_manager(&correctBox);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&box));
+ QVERIFY(QTest::qWaitForWindowExposed(&correctBox));
// box should be resized to the same size as correctBox
QTRY_COMPARE(box.size(), correctBox.size());
mw.addDockWidget(Qt::LeftDockWidgetArea, &dw);
mw.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mw);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mw));
QVERIFY(!dw.isFloating());
QLineEdit *ledit = new QLineEdit;
dw->setWidget(ledit);
mw.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mw);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mw));
qApp->processEvents();
dw->setFloating(true);
delete ledit;
mw.addDockWidget(Qt::LeftDockWidgetArea, dw);
dw->setFloating(true);
mw.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mw);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mw));
QCOMPARE(dw->widget()->size(), dw->widget()->sizeHint());
//and now we try to test if the contents margin is taken into account
dw->widget()->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
dw->setFloating(false);
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mw);
-#endif
- QTest::qWait(100); //leave time processing events
+ QVERIFY(QTest::qWaitForWindowExposed(&mw));
+ qApp->processEvents(); //leave time processing events
const QSize oldSize = dw->size();
dw->setContentsMargins(margin, margin, margin, margin);
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mw);
-#endif
- QTest::qWait(100); //leave time processing events
+ QVERIFY(QTest::qWaitForWindowExposed(&mw));
+ qApp->processEvents(); //leave time processing events
//widget size shouldn't have changed
QCOMPARE(dw->widget()->size(), dw->widget()->sizeHint());
spinbox.activateWindow();
spinbox.setFocus();
QApplication::setActiveWindow(&spinbox);
- QTest::qWaitForWindowShown(&spinbox);
+ QVERIFY(QTest::qWaitForWindowActive(&spinbox));
+ QCOMPARE(static_cast<QWidget *>(&spinbox), QApplication::activeWindow());
QTRY_VERIFY(spinbox.hasFocus());
- QTRY_COMPARE(static_cast<QWidget *>(&spinbox), QApplication::activeWindow());
QCOMPARE(spinbox.text(), spinbox.locale().toString(spinbox.value()));
spinbox.lineEdit()->setCursorPosition(2); //just after the first thousand separator
QTest::keyClick(static_cast<QWidget *>(0), Qt::Key_0); // let's insert a 0
QLineEdit lineEdit(&box);
box.show();
QApplication::setActiveWindow(&box);
+ QVERIFY(QTest::qWaitForWindowActive(&box));
box.setFocus();
- QTest::qWait(250);
QTRY_COMPARE(qApp->focusWidget(), static_cast<QWidget*>(&lineEdit));
}
mw.show();
QApplication::setActiveWindow(&mw);
mw.activateWindow();
- QTest::qWaitForWindowShown(&mw);
- QTRY_COMPARE(&mw, QApplication::activeWindow());
+ QVERIFY(QTest::qWaitForWindowActive(&mw));
+ QCOMPARE(&mw, QApplication::activeWindow());
QSignalSpy editingFinishedSpy(le1, SIGNAL(editingFinished()));
QLineEdit lineEdit;
lineEdit.setMaxLength(5);
lineEdit.show();
-#ifdef Q_WS_X11
- // to be safe and avoid failing setFocus with window managers
- qt_x11_wait_for_window_manager(&lineEdit);
-#endif
+ QTest::qWaitForWindowExposed(&lineEdit); // to be safe and avoid failing setFocus with window managers
lineEdit.setFocus();
QSignalSpy changedSpy(&lineEdit, SIGNAL(textChanged(QString)));
QTest::qWait(200);
le.addAction(&action);
le.show();
- QTest::qWaitForWindowShown(&le);
QApplication::setActiveWindow(&le);
+ QVERIFY(QTest::qWaitForWindowActive(&le));
le.setFocus();
QTRY_VERIFY(le.hasFocus());
mdiArea.addSubWindow(new QWidget);
QCOMPARE(spy.count(), 0);
mdiArea.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mdiArea);
-#endif
- QTest::qWaitForWindowShown(&mdiArea);
mdiArea.activateWindow();
- QTest::qWait(100);
+ QVERIFY(QTest::qWaitForWindowActive(&mdiArea));
QTRY_COMPARE(spy.count(), 5);
QCOMPARE(mdiArea.activeSubWindow(), mdiArea.subWindowList().back());
spy.clear();
mdiArea.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mdiArea);
-#endif
- QTest::qWait(100);
+ QVERIFY(QTest::qWaitForWindowExposed(&mdiArea));
QTRY_COMPARE(spy.count(), 1);
QCOMPARE(mdiArea.activeSubWindow(), activeSubWindow);
spy.clear();
// Check that we only emit _one_ signal and the active window
// is unchanged after showMinimized/showNormal.
mdiArea.showMinimized();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mdiArea);
-#elif defined (Q_OS_MAC)
+#if defined (Q_OS_MAC)
if (!macHasAccessToWindowsServer())
QEXPECT_FAIL("", "showMinimized doesn't really minimize if you don't have access to the server", Abort);
#endif
- QTest::qWait(10);
+ QVERIFY(QTest::qWaitForWindowExposed(&mdiArea));
#if defined(Q_WS_QWS)
QEXPECT_FAIL("", "task 168682", Abort);
#endif
QCOMPARE(mdiArea.currentSubWindow(), activeSubWindow);
spy.clear();
+ // For this test, the QMdiArea widget must be active after minimizing and
+ // showing it again. QMdiArea has no active sub window if it is inactive itself.
+ qApp->setActiveWindow(&mdiArea);
mdiArea.showNormal();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mdiArea);
-#endif
- QTest::qWait(100);
+ QVERIFY(QTest::qWaitForWindowActive(&mdiArea));
QTRY_COMPARE(spy.count(), 1);
QCOMPARE(mdiArea.activeSubWindow(), activeSubWindow);
spy.clear();
mainWindow.addDockWidget(Qt::LeftDockWidgetArea, dockWidget);
mainWindow.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mainWindow);
-#endif
-
qApp->setActiveWindow(&mainWindow);
+ QVERIFY(QTest::qWaitForWindowActive(&mainWindow));
QCOMPARE(mdiArea->activeSubWindow(), subWindow);
QCOMPARE(qApp->focusWidget(), (QWidget *)subWindowLineEdit);
QLineEdit dummyTopLevel;
dummyTopLevel.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&dummyTopLevel);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&dummyTopLevel));
qApp->setActiveWindow(&dummyTopLevel);
QCOMPARE(mdiArea->activeSubWindow(), subWindow);
{
QMdiArea mdiArea;
mdiArea.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mdiArea);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mdiArea));
for (int i = 0; i < 5; ++i)
mdiArea.addSubWindow(new QLineEdit)->show();
QLineEdit dummyTopLevel;
dummyTopLevel.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&dummyTopLevel);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&dummyTopLevel));
// Move focus to another top-level and check that we still
// have an active window.
QMdiArea workspace(&topLevel);
workspace.resize(800, 600);
topLevel.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&workspace);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&topLevel));
{ // addSubWindow with large widget
QCOMPARE(workspace.subWindowList().count(), 0);
if (PlatformQuirks::isAutoMaximizing())
workspace.setWindowFlags(workspace.windowFlags() | Qt::X11BypassWindowManagerHint);
workspace.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&workspace);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&workspace));
const int windowCount = 10;
for (int i = 0; i < windowCount; ++i) {
QCOMPARE(vBar->minimum(), 0);
workspace.tileSubWindows();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&workspace);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&workspace));
qApp->processEvents();
QTRY_VERIFY(workspace.size() != QSize(150, 150));
QMdiArea workspace;
workspace.resize(400, 400);
workspace.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&workspace);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&workspace));
const int windowCount = 10;
QList<QMdiSubWindow *> windows;
QWidget topLevel;
QMdiArea workspace(&topLevel);
topLevel.show();
-#if defined(Q_WS_X11)
- qt_x11_wait_for_window_manager(&workspace);
-#endif
- QTest::qWait(100);
+ QVERIFY(QTest::qWaitForWindowExposed(&topLevel));
workspace.resize(startSize, startSize);
workspace.setOption(QMdiArea::DontMaximizeSubWindowOnActivation);
QSize workspaceSize = workspace.size();
{
QMdiArea mdiArea;
mdiArea.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mdiArea);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mdiArea));
qApp->setActiveWindow(&mdiArea);
// Add one maximized window.
mdiArea.resize(window3->minimumSizeHint().width() * 3, 400);
mdiArea.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mdiArea);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mdiArea));
QCOMPARE(window1->geometry().topLeft(), QPoint(0, 0));
QCOMPARE(window2->geometry().topLeft(), window1->geometry().topRight() + QPoint(1, 0));
QMdiSubWindow *subWindow = mdiArea->addSubWindow(new QWidget);
mainWindow.setCentralWidget(mdiArea);
mainWindow.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mainWindow);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mainWindow));
subWindow->showMaximized();
QVERIFY(subWindow->isMaximized());
QMdiArea mdiArea;
QMdiSubWindow *subWindow = mdiArea.addSubWindow(new QWidget);
mdiArea.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mdiArea);
-#endif
- QTest::qWaitForWindowShown(&mdiArea);
+ QVERIFY(QTest::qWaitForWindowActive(&mdiArea));
#ifndef Q_OS_WINCE
int time = 250;
int time = 1000;
#endif
- QTest::qWait(time);
-
EventSpy timerEventSpy(subWindow, QEvent::Timer);
QCOMPARE(timerEventSpy.count(), 0);
QMdiSubWindow *subWindow2 = mdiArea.addSubWindow(new QWidget);
mdiArea.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mdiArea);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mdiArea));
qApp->processEvents();
QScrollBar *hbar = mdiArea.horizontalScrollBar();
// We still shouldn't get any scroll bars.
mdiArea.resize(mdiArea.size() - QSize(20, 20));
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mdiArea);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mdiArea));
qApp->processEvents();
QVERIFY(subWindow1->isMaximized());
QVERIFY(!hbar->isVisible());
QCOMPARE(mdiArea.subWindowList(activationOrder), subWindows);
mdiArea.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mdiArea);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mdiArea));
for (int i = 0; i < subWindows.count(); ++i) {
mdiArea.activateNextSubWindow();
subWindows << mdiArea.addSubWindow(new QLineEdit);
mdiArea.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mdiArea);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mdiArea));
qApp->setActiveWindow(&mdiArea);
QWidget *focusWidget = subWindows.back()->widget();
}
mdiArea.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mdiArea);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mdiArea));
QMdiSubWindow *activeSubWindow = mdiArea.activeSubWindow();
const QList<QMdiSubWindow *> subWindows = mdiArea.subWindowList();
QMdiArea mdiArea;
mdiArea.addSubWindow(new QWidget);
mdiArea.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mdiArea);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mdiArea));
// Default.
QCOMPARE(mdiArea.tabShape(), QTabWidget::Rounded);
QMdiArea mdiArea;
mdiArea.addSubWindow(new QWidget);
mdiArea.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mdiArea);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mdiArea));
// Make sure there are no margins.
mdiArea.setContentsMargins(0, 0, 0, 0);
mdiArea.addSubWindow(new QWidget);
mdiArea.addSubWindow(new QWidget);
mdiArea.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mdiArea);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mdiArea));
// No native widgets.
QVERIFY(!mdiArea.viewport()->internalWinId());
(void)nativeWidget->winId();
mdiArea.addSubWindow(nativeWidget);
mdiArea.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mdiArea);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mdiArea));
// The viewport and all the sub-windows must be native.
QVERIFY(mdiArea.viewport()->internalWinId());
mdiArea.addSubWindow(new QWidget);
mdiArea.addSubWindow(new QWidget);
mdiArea.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mdiArea);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mdiArea));
QMdiSubWindow *nativeSubWindow = mdiArea.subWindowList().last();
QVERIFY(!nativeSubWindow->internalWinId());
mdiArea.addSubWindow(new QWidget);
mdiArea.addSubWindow(new QWidget);
mdiArea.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mdiArea);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mdiArea));
const QGLContext *context = glViewport->context();
if (!context || !context->isValid())
#endif
QT_BEGIN_NAMESPACE
-#if defined(Q_WS_X11)
-extern void qt_x11_wait_for_window_manager(QWidget *w);
-#endif
#if !defined(Q_WS_WIN)
extern bool qt_tab_all_widgets;
#endif
QMdiSubWindow *subWindow1 = mdiArea.addSubWindow(new QWidget);
subWindow1->setMinimumSize(1000, 1000);
mdiArea.show();
-#if defined(Q_WS_X11)
- qt_x11_wait_for_window_manager(&mdiArea);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mdiArea));
QCOMPARE(subWindow1->size(), QSize(1000, 1000));
// Check that we respect the minimum size set on the internal widget.
QMdiSubWindow *window = qobject_cast<QMdiSubWindow *>(workspace.addSubWindow(new QLineEdit));
window->show();
workspace.show();
-#if defined(Q_WS_X11)
- qt_x11_wait_for_window_manager(&workspace);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&workspace));
QWidget *testWidget = 0;
for (int iteration = 0; iteration < 2; ++iteration) {
window->setParent(0);
window->showNormal();
-#if defined(Q_WS_X11)
- qt_x11_wait_for_window_manager(window);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(window));
qApp->processEvents();
spy.clear();
window->resize(300, 300);
qApp->processEvents();
workspace.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&workspace);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&workspace));
QVERIFY(!window->isShaded());
QVERIFY(!window->isMaximized());
qApp->processEvents();
workspace.show();
window->show();
-#if defined(Q_WS_X11)
- qt_x11_wait_for_window_manager(&workspace);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&workspace));
QRect originalGeometry = window->geometry();
QVERIFY(QMetaObject::invokeMethod(window, slot.data()));
qApp->processEvents();
workspace.resize(workspaceSize);
workspace.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&workspace);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&workspace));
QWidget *mouseReceiver = 0;
if (window->style()->inherits("QMacStyle"))
qApp->processEvents();
workspace.show();
window->show();
-#if defined(Q_WS_X11)
- qt_x11_wait_for_window_manager(&workspace);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&workspace));
window->setWindowFlags(windowType | customFlags);
QCOMPARE(window->windowType(), expectedWindowType);
QMdiArea *mdiArea = new QMdiArea;
mainWindow.setCentralWidget(mdiArea);
mainWindow.show();
-#if defined(Q_WS_X11)
- qt_x11_wait_for_window_manager(&mainWindow);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mainWindow));
QMdiSubWindow *window = mdiArea->addSubWindow(new QTextEdit);
window->show();
QMenuBar *menuBar = mainWindow.menuBar();
mainWindow.setCentralWidget(tabWidget);
mainWindow.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mainWindow);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mainWindow));
QVERIFY(!menuBar->cornerWidget(Qt::TopRightCorner));
QMdiSubWindow *subWindow = mdiArea->addSubWindow(new QTextEdit);
QMdiArea mdiArea;
QMdiSubWindow *subWindow = mdiArea.addSubWindow(new QTextEdit);
mdiArea.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mdiArea);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mdiArea));
subWindow->showMaximized();
QVERIFY(subWindow->isMaximized());
textEdit->hide();
QMdiSubWindow *subWindow = mdiArea.addSubWindow(textEdit);
mdiArea.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mdiArea);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mdiArea));
QVERIFY(subWindow->isVisible());
QVERIFY(!textEdit->isVisible());
QMdiArea mdiArea;
mdiArea.setGeometry(0, 0, 640, 480);
mdiArea.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mdiArea);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mdiArea));
const QSize minimumSize = QSize(250, 150);
const QSize maximumSize = QSize(300, 200);
mainWindow.setCentralWidget(mdiArea);
QMenuBar *menuBar = mainWindow.menuBar();
mainWindow.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mainWindow);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mainWindow));
qApp->processEvents();
QMdiArea mdiArea;
QPointer<QMdiSubWindow> subWindow = mdiArea.addSubWindow(new QWidget);
mdiArea.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mdiArea);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mdiArea));
subWindow->showSystemMenu();
QTest::qWait(200);
subWindow->resize(300, 100);
subWindow->setWindowTitle(QLatin1String("Window title"));
mdiArea.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mdiArea);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mdiArea));
+
const QFont originalFont = QApplication::font("QMdiSubWindowTitleBar");
QStyleOptionTitleBar opt;
QMdiSubWindow *subWindow = mdiArea->addSubWindow(new QWidget);
mainWindow.setCentralWidget(mdiArea);
mainWindow.show();
-#if defined(Q_WS_X11)
- qt_x11_wait_for_window_manager(&mainWindow);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mainWindow));
// QMdiSubWindow will now try to show its buttons in the menu bar.
// Without checking that the menu bar is actually a QMenuBar
{
QMdiArea mdiArea;
mdiArea.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mdiArea);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mdiArea));
QMdiSubWindow *sub1 = mdiArea.addSubWindow(new QTextEdit);
sub1->showMinimized();
QVERIFY(menu->isTearOffEnabled());
widget.show();
- QTest::qWaitForWindowShown(&widget);
widget.activateWindow();
+ QVERIFY(QTest::qWaitForWindowActive(&widget));
menu->popup(QPoint(0,0));
QTest::qWait(50);
QVERIFY(!menu->isTearOffMenuVisible());
QAction * a = menubar.addAction( "&a" );
menubar.show();
- QTest::qWaitForWindowShown(&menubar);
QApplication::setActiveWindow(&menubar);
+ QVERIFY(QTest::qWaitForWindowActive(&menubar));
menubar.setActiveAction(m);
QCOMPARE(menubar.activeAction(), m);
QTest::keyClick(static_cast<QWidget *>(0), Qt::Key_Right);
pbar.setMaximum(10);
pbar.setFormat("%v");
pbar.show();
- QTest::qWaitForWindowShown(&pbar);
-
- QApplication::processEvents();
+ QVERIFY(QTest::qWaitForWindowActive(&pbar));
// No repaint when setting minimum to the current minimum
pbar.repainted = false;
void changeEvent(QEvent *event)
{
QWidget::changeEvent(event);
- if (isWindow() && event->type() == QEvent::WindowStateChange) {
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(this);
-#endif
- }
+ if (isWindow() && event->type() == QEvent::WindowStateChange)
+ QVERIFY(QTest::qWaitForWindowExposed(this));
}
};
spin.setMaximum(100);
spin.setValue(50);
topWidget.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&topWidget);
-#endif
- QTest::qWait(100);
//make sure we have the focus (even if editingFinished fails)
qApp->setActiveWindow(&topWidget);
topWidget.activateWindow();
+ QVERIFY(QTest::qWaitForWindowActive(&topWidget));
spin.setFocus();
QTest::keyClick(&spin, Qt::Key_Return);
QPointer<QStatusBar> statusBar = mainWindow.statusBar();
QVERIFY(statusBar);
mainWindow.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mainWindow);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mainWindow));
QTRY_VERIFY(statusBar->isVisible());
QPointer<QSizeGrip> sizeGrip = qFindChild<QSizeGrip *>(statusBar);
#ifndef Q_OS_MAC // Work around Lion fullscreen issues on CI system - QTQAINFRA-506
mainWindow.showFullScreen();
#endif
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&mainWindow);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&mainWindow));
qApp->processEvents();
mainWindow.setStatusBar(new QStatusBar(&mainWindow));
statusbar.setSizeGripEnabled(true);
main.setStatusBar(&statusbar);
main.showMaximized();
- QTest::qWaitForWindowShown(&main);
+ QVERIFY(QTest::qWaitForWindowActive(&main));
#ifndef Q_OS_MAC
QVERIFY(!statusbar.findChild<QSizeGrip*>()->isVisible());
#endif
main.showNormal();
- QTest::qWaitForWindowShown(&main);
+ QVERIFY(QTest::qWaitForWindowExposed(&main));
QVERIFY(statusbar.findChild<QSizeGrip*>()->isVisible());
main.showFullScreen();
- QTest::qWaitForWindowShown(&main);
+ QVERIFY(QTest::qWaitForWindowExposed(&main));
QVERIFY(!statusbar.findChild<QSizeGrip*>()->isVisible());
}
tb.addAction(&action4);
tb.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&tb);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&tb));
QList<QToolBarExtension *> extensions = tb.findChildren<QToolBarExtension *>();
tb.addAction(&action4);
tb.show();
-#ifdef Q_WS_X11
- qt_x11_wait_for_window_manager(&tb);
-#endif
+ QVERIFY(QTest::qWaitForWindowExposed(&tb));
QList<QToolBarExtension *> extensions = tb.findChildren<QToolBarExtension *>();
projects / profile / ivi / qtbase.git / commitdiff