Wie du sehen wirst, habe ich die »QCoreApplication()«-Klasse gegen »QApplication« ausgetauscht. Damit das Beispiel nicht nur mit fünf Elementen aus einer Liste arbeitet, habe ich wieder die »xrange()« herangeholt. Das Beispiel soll ja auch seine Arbeit demonstrieren. Auch habe ich die »moveToThread()«-Methode herangezogen, damit die Arbeit auch in ein Thread verschoben wird. Oder sollte ich das nicht machen?
Was mir allerdings auffällt. Die GUI ruckelt zunächst einmal nicht. Das ist schon mal super. Aber der QTimer "stößt" die Arbeit ziemlich langsam an, oder etwa nicht? Ehe die 10.000 Items nun durchlaufen wurden, vergehen fast 2 Minuten. Ich habe mit der Stoppuhr meines Smartphones gemessen. Ist ein Bisschen zu "langsam" oder?
Code: Alles auswählen
import sys
from PyQt4.QtCore import QTimer, QObject, pyqtSignal, \
QThread, Qt
from PyQt4.QtGui import QDialog, QLabel, QPushButton, \
QApplication, QVBoxLayout, QTreeWidget, QTreeWidgetItem
def output(text):
print "Output:", text
class Counter(QObject):
notify_progress = pyqtSignal(str)
notify_item = pyqtSignal(object)
finish_progress = pyqtSignal()
fire_label = pyqtSignal(int)
def __init__(self, parent=None):
QObject.__init__(self, parent)
self.element = self.my_gen()
self.timer = QTimer()
# assoziiert increment() mit TIMEOUT Ereignis
self.timer.setSingleShot(False)
self.timer.timeout.connect(self.increment)
self.timer.start()
def my_gen(self):
count = 0
for name in xrange(10000):
count += 1
self.fire_label.emit(count)
yield name
def increment(self):
try:
self.notify_item.emit(next(self.element))
except StopIteration:
self.notify_progress.emit('Break the loop')
self.finish_progress.emit()
self.timer.stop()
def stop(self):
self.notify_progress.emit('Stop the loop')
self.timer.stop()
class MyCustomDialog(QDialog):
finish = pyqtSignal()
def __init__(self, parent=None):
QDialog.__init__(self, parent)
layout = QVBoxLayout(self)
self.tree = QTreeWidget(self)
self.label = QLabel(self)
self.pushButton_start = QPushButton("Start", self)
self.pushButton_stopp = QPushButton("Stopp", self)
self.pushButton_close = QPushButton("Close", self)
layout.addWidget(self.label)
layout.addWidget(self.tree)
layout.addWidget(self.pushButton_start)
layout.addWidget(self.pushButton_stopp)
layout.addWidget(self.pushButton_close)
self.pushButton_start.clicked.connect(self.on_start)
self.pushButton_stopp.clicked.connect(self.on_finish)
self.pushButton_close.clicked.connect(self.close)
def fill_tree_widget(self, i):
parent = QTreeWidgetItem(self.tree)
self.tree.addTopLevelItem(parent)
parent.setText(0, unicode(i))
parent.setCheckState(0, Qt.Unchecked)
parent.setFlags(parent.flags() | Qt.ItemIsTristate | Qt.ItemIsUserCheckable)
def on_label(self, i):
self.label.setText("Result: {}".format(i))
def on_start(self):
self.tree.clear()
self.label.clear()
task_thread = QThread(self)
task_thread.work = Counter()
task_thread.work.fire_label.connect(self.on_label)
task_thread.work.notify_progress.connect(output)
task_thread.work.notify_item.connect(self.fill_tree_widget)
task_thread.work.finish_progress.connect(task_thread.quit)
self.finish.connect(task_thread.work.stop)
task_thread.work.moveToThread(task_thread)
#task_thread.started.connect(task_thread.work)
task_thread.finished.connect(task_thread.deleteLater)
task_thread.start()
def on_finish(self):
self.finish.emit()
def main():
app = QApplication(sys.argv)
window = MyCustomDialog()
window.resize(600, 400)
window.show()
sys.exit(app.exec_())
if __name__ == "__main__":
main()
). Und falls Du die Lust noch nicht verloren hast, kannste mit dem Wissen ja mal einen Threadpool mit Workerthreads bauen, welchen man Arbeit zuschanzen kann 