QWidget showFullScreen produces multiple resizeEvents

Question

I have a QT application written in python using PySide and I stumbled across a little problem regarding the showFullScreen method of the QGLWidget (although the problem occurs with every other widget too):

The problem is, that the widget doesn't have its 'final' resolution after the program returns from showFullScreen. The switch seems to be triggered asynchronously between 5 and 10 milliseconds later.

This is a problem for me because I have to do some layout calculations which depend on the widget's size after it is shown.

Below is a little reproducer which subclasses QGLWidget. Using this reproducer you will take notice, that resizeEvent will be called twice after showFullScreen.

I'm looking for a convinient way of knowing which resizeEvent is the 'final' one, or a way of knowing, when the widget really is in fullscreen mode. Is there maybe any signals I could connect to?

Thanks a lot for any help on this.

#!/usr/bin/python

import sys
from PySide.QtGui import QApplication
from PySide.QtCore import QTimer
from PySide.QtOpenGL import QGLWidget

class TestWidget(QGLWidget):
    def __init__(self, parent=None):
        super(TestWidget, self).__init__(parent)
        self._timer = QTimer()
        self._timer.setInterval(5)
        self._timer.timeout.connect(self.showsize)
        self._timer.start()

    def resizeEvent(self, event):
        print "Resize event:", event.size().width(), event.size().height()

    def showsize(self):
        w = widget.size().width()
        print "Timer: ", w, widget.size().height()
        if w == 1680:
           self._timer.stop()

if __name__ == "__main__":
    app = QApplication(sys.argv)
    widget = TestWidget()
    widget.showFullScreen()
    print "After showFullScreen:", widget.size().width(), widget.size().height()
    # this will always be 640 480...1680 1050 is what I'm expecting
    app.exec_()

Answer 1

One possibility is to check that if the resize event is spontaneous or not. From limited testing here (using Qt C++ on Linux), the second resize event is spontaneous, while the first one is not.

You could do your calculations only when the event is spontaneous.

Note: I'm not sure how portable this is, it might depend on your window manager/windowing system.