Defer Resize Event due to expensive resize method.

AliSot2000

Hi there

I wanted to check that I've correctly identified a dead end in my development. The main point is this: I have an application that has a table which contains a lot of images (~a few hundereds) and when you perform a resizeEvent, the GUI lags a bit.

To prevent that from happening, I've added a QTimer, that is triggered by the resize event and only once the timer exits, the resize action is performed. However, it is possible for the timer to trigger, even when you're still resizing. As soon as the mouse stops moving, there are no longer resizeEvents emitted which causes the timer to exit and trigger a resize.

I've already set the timeout to the more conservative side of about 500ms but I find it a bit annoying that I have to rely on timers and heuristics when I could (!) possibly do it differently.

I've tinkered around with different solutions, looked at questions on this and other forums and also asked ChatGPT but the problem seems to be the following.
The resizing of the MainWindow in conjunction with the detecting the mousePressEvent for resizing Windows is happening in the Desktop Environemnt. When I'm trying to access the pressed mouse buttons during the ResizeEvent, they are reported as not pressed. I assume the mouseDown on the resize trigger of the Windows is handled in the Desktop Environment and the resizing of the Window then triggeres a ResizeEvent in the QT Application but the application is never "sees" the mouse doing anything.

Is there a way to detect if the LMB is pressed during a ResizeEvent? Because it doesn't seem to be the case.

Here's a simple example to test:

from PyQt6.QtCore import Qt, QSize
from PyQt6.QtGui import QResizeEvent
from PyQt6.QtWidgets import QApplication, QMainWindow, QLabel


class DelayedLabel(QLabel):
    perform_resize: bool = False

    def resizeEvent(self, a0):
        """
        Handle resize event
        """
        if self.perform_resize:
            super().resizeEvent(a0)


class CustomMainWindow(QMainWindow):
    def __init__(self):
        super().__init__()

        self.table_widget = DelayedLabel()
        self.setCentralWidget(self.table_widget)

        self.resize_event_buffer_old = None
        self.resize_event_buffer_new = None
        self.last_resize_event = None

    def resizeEvent(self, a0):
        """
        Custom handling of Resize Event
        """
        if not self.table_widget.perform_resize:
            self.resize_event_buffer_old = QSize(a0.oldSize())
            self.resize_event_buffer_new = QSize(a0.size())

        application = QApplication.instance()
        print(application.mouseButtons())

    def mousePressEvent(self, a0):
        """
        Check it's a LMB event
        """
        # Left button is down, means we don't update the widget
        if a0.button() == Qt.MouseButton.LeftButton:
            self.table_widget.perform_resize = False
            print(f"Mouse Pressed")

    def mouseReleaseEvent(self, a0):
        """
        Check it's a LMB event'
        """
        # Left button is up, means we do update the widget
        if a0.button() == Qt.MouseButton.LeftButton:
            self.table_widget.perform_resize = True
            print(f"Mouse Released")

            # Submit the event again
            if self.resize_event_buffer_new is not None and self.resize_event_buffer_old is not None:
                print(f"Sending Custom Event")
                new_event = QResizeEvent(self.resize_event_buffer_new, self.resize_event_buffer_old)
                self.table_widget.resizeEvent(new_event)

                self.resize_event_buffer_new = self.resize_event_buffer_old = None


if __name__ == "__main__":
    app = QApplication([])
    window = CustomMainWindow()
    window.show()
    app.exec()

You should observe that when pressing on on the trigger for resizing, nothing happens and when you release after having resized the window also nothing happens.

SGaist

Hi and welcome to devnet,

Did you already consider using the updates enabled properly ?

SimonSchroeder

@AliSot2000 said in Defer Resize Event due to expensive resize method.:

Is there a way to detect if the LMB is pressed during a ResizeEvent? Because it doesn't seem to be the case.

Most likely resizing a (top-level) window is done by the underlying OS/window manager and thus Qt does not know anything about the mouse. This is why you only a resize event, but no mouse event. (At least, that is my guess.)

There is a common trick using two timers, though the second timer is usually used to not delay the function call indefinitely (which you don't seem to need in your case). So, using a single timer is okay. However, you need to make sure that you reuse the same timer and reset it, so that the timeout is further delayed until there no more interactions.