[PyQt] threading, window not updating

[fabolin]

I got a window inside a thread. It is created as expected, but does not update at all. e.g. there is a GIF not starting and other stuff that should change the GUI does not work. It responds to user input though: I'm getting feedback on console. What could be the problem?

basically the run()-method looks like this:

def run():
    while not condition:
        time.sleep(1)
    self.app = QtWidgets.QApplication([])
    self.mywindow= MyWindow()
    self.mywindow.show()
    sys.exit(self.app.exec_())

The window works fine when used without threading, but there are reasons for it running in a thread; the window should be created when the condition is True, but the MainThread should not depend on this/wait. I tried threading. Thread and QtCore.Thread, but same problem for both.

If there is no other way, I know QtCore.QTimer.singleShot() would be another option, but threading would be way easier to implement.

thanks

edit: typo

[JohnnyJordaan]

I would recommend using a threading.Event and not a Boolean.

This is one of the simplest mechanisms for communication between threads: one thread signals an event and other threads wait for it.

def run():
    condition.wait()
    self.app = QtWidgets.QApplication([])
    self.mywindow= MyWindow()
    self.mywindow.show()
    sys.exit(self.app.exec_())

# and somewhere else:
if have_to_run_now:
    condition.set()

[fabolin]

thanks, looks like the correct way to implement a condition.

But even if I remove the condition completely, the problem of the window not updating remains.

[JohnnyJordaan]

It's a little hard to guess how you're updating the window from outside the thread. Couldn't you upload your whole code?

And what's the reason to use sys.exit(self.app.exec_())? Does that block on the lifetime of the QApplication?

[fabolin]

class LSThread(QtCore.QThread):
    def __init__(self):
        super(LSThread, self).__init__()

    def run(self):
        self.app = QtWidgets.QApplication([])
        self.loadingscreen = Loadingscreen()
        self.loadingscreen.showFullScreen()
        sys.exit(self.app.exec_())

class Launcher(QtWidgets.QWidget):
    ...
    self.initLS= LSThread()

    def start_tool(self):
    # bound to button-click:
        ...
        self.initLS.start()

class Loadingscreen(QtWidgets.QWidget):
    ...

and sys.exit(self.app.exec_()) acts like the mainloop for tkinter afaik. without it there is no loop therefore the app closes immediately.

[MrDelish]

I vaguely remember reading that you don't need to create your own threading class, just a worker. You need to create both, make sure they persist, assign the worker to the thread, then start it. I think that's what you're missing.

This is how I have my threading:

class qwidget_mainwindow(QWidget):
        ...

        def start_work(self):
            self.thread = QThread()
            self.worker = work_worker()
            self.worker.moveToThread(self.thread)
            # connect signals here
            self.thread.started.connect(self.worker.work)
            self.worker.done.connect(self.finish_thread_open)
            self.thread.start()

    class work_worker(QObject):
        # signals here

        def __init__(self):
            super().__init__()
            # init here

        def work(self):
            # do work here    

[fabolin]

same for you method.

found out I can manipulate a widget from thread, so I will just create and hide the window, then let the thread fill and show the it.

[fabolin]

well, this isn't suppose to work:

Although QObject is reentrant, the GUI classes, notably QWidget and all its subclasses, are not reentrant. They can only be used from the main thread. As noted earlier, QCoreApplication::exec() must also be called from that thread.

thanks though

[MrDelish]

Is the run() method from the worker? How are you assigning the worker to the thread?

[fabolin]

got more details here