~garyvdm/+junk/thread-test

#!/usr/bin/env python

import sys

import threading

import time

from PyQt4 import QtCore, QtGui

main_event_loop = None

main_tread = threading.currentThread()

gui_thread = None

def runs_in_gui_thread(func):

    def runs_in_gui_thread_decorate(*args, **kargs):

        run_in_thread(gui_thread, gui_thread.app, func, *args, **kargs)

    return runs_in_gui_thread_decorate

def runs_in_main_thread(func):

    def runs_in_main_thread_decorate(*args, **kargs):

        run_in_thread(main_tread, main_event_loop, func, *args, **kargs)

    return runs_in_main_thread_decorate

def run_in_thread(thread, signal_object, func, *args, **kargs):

    current_thread = threading.currentThread()

    if not current_thread == thread:

        print 'Signal sent from %s to %s to run %s' % (

            current_thread.name, thread.name, func.__name__)

        signal_object.emit(QtCore.SIGNAL("run_func"), func, args, kargs)

    else:

        func(*args, **kargs)

def run_func(func, args, kargs):

    func(*args, **kargs)

class GUIThread(threading.Thread):

    app = None

    app_created = threading.Event()

    main_event_loop = None

    def __init__(self, main_event_loop_created,

                 start_func, start_func_args, start_func_kargs,

                 *args, **kargs):

        threading.Thread.__init__(self, *args, **kargs)

        self.main_event_loop_created = main_event_loop_created

        self.start_func = start_func

        self.start_func_args = start_func_args

        self.start_func_kargs = start_func_kargs

    def run(self):

        # uncomment to test for a slow QApplication start

        #time.sleep(3)

        self.app = QtGui.QApplication(sys.argv)

        self.app_created.set()

        self.app.connect(self.app, QtCore.SIGNAL('run_func'), run_func)

        main_event_loop_created.wait()

        # Not setting the return val for this func results in the window not

        # showing. I don't understand why. It is possible to have a list

        # of windows work.

        win = self.start_func(*self.start_func_args, **self.start_func_kargs)

        ret = self.app.exec_()

        self.main_event_loop.exit(ret)

        del self.app

def command_run():

    print_where()

    win = CommandWindow()

    win.show()

    return win

def print_where():

    func_name = sys._getframe(1).f_code.co_name

    thread_name = threading.currentThread().name

    print '%s in %s' % (func_name, thread_name)

class CommandWindow(QtGui.QLabel):

    def __init__(self, *args, **kargs):

        QtGui.QLabel.__init__(self, *args, **kargs)

        self.resize(QtCore.QSize(300, 20))

    def show(self):

        QtGui.QWidget.show(self)

        self.load()

    @runs_in_main_thread

    def load(self):

        print_where()

        self.get_text()

    @runs_in_main_thread

    def get_text(self):

        print_where()

        self.got_text('Hello World.')

    @runs_in_gui_thread

    def got_text(self, text):

        print_where()

        self.setText(text)

if __name__ == '__main__':

    main_event_loop_created = threading.Event()

    gui_thread = GUIThread(main_event_loop_created, command_run, [], {}, name='GUIThread')

    gui_thread.start()

    # We don't want to create this event loop before the app is created in

    # the gui thread.

    gui_thread.app_created.wait()

    # this fails because it's not in the GUI Thread

    #win = QtGui.QWidget()

    #win.show()

    main_event_loop = QtCore.QEventLoop()

    main_event_loop.connect(main_event_loop, QtCore.SIGNAL('run_func'), run_func)

    main_event_loop_created.set()

    gui_thread.main_event_loop = main_event_loop

    ret = main_event_loop.exec_()

    gui_thread.join()

    sys.exit(ret)