在pyqt4滚动区域python中显示长循环函数

Question

I am designing a GUI and as part of the GUI I want to retrieve data in a special way and display it on the scrollarea. However I am not sure how to do that, I have defined the database retrieval function as cpu_alert, however how do I put the result (rows) in the scroll area? Please take a look at the code.

from PyQt4 import QtCore, QtGui
import ui_intex_server_monitorui as intex
from PyQt4 import Qt
import sys
import os
import MySQLdb as mdb

class MyMain(QtGui.QMainWindow, intex.Ui_MainWindow):
    def __init__(self, parent=None):
        super(MyMain, self).__init__(parent)
        self.setupUi(self)  

        #Exit Button
        self.connect(self.pushButton_2, QtCore.SIGNAL('clicked()'),
            self.close)
        #Refresh Button here#
        self.testdata = QtGui.QListWidget(self)
        layout = self.scrollArea_10
        layout.setWidget(self.testdata)
        self.testdata.addItem(self.cpu_alert.rows)

def cpu_alert():
    control = True

    while (control == True):

        f = open("connection_cpu.txt","r")
        a = f.read()
        con = mdb.connect('server', 'user', 'pass', 'db')

        if a == "CPU Overload":
            with con: 
                cur = con.cursor()
                cur.execute("""SELECT *
                               FROM cpu_alert
                               WHERE date = (SELECT MAX(date) FROM cpu_alert)""")
                rows = str(cur.fetchone())
                rows = rows.strip("()" "''")
                open("connection_cpu.txt","w").close()
      return rows


def main():
   app = QtGui.QApplication(sys.argv)
   app.setStyle(QtGui.QStyleFactory.create("plastique"))
   main_window = MyMain()
   main_window.show()
   app.exec_()

if __name__ == '__main__':
   main()

Answer 1

First let me start by addressing how you are checking to see if there is a new update available. If you were to call this cpu_alert method, you would enter a busy loop in the main thread and block much of your GUI functionality. Furthermore, there is nothing limiting this busy loop so it will spin extremely fast on your file. Assuming checking the file for content is the approach you intend to use, it needs to be in a separate thread. The thread will loop on the file and sleep a reasonable amount. If it finds the text it needs, then it can emit a signal. This signal would then connect to the slot that updates your table.

But lets keep this even simpler, since all you are doing to check is quickly read a file. Because it does not take much time, we can use a QTimer. The timer will fire and call the checker. If the checker finds and update it can either call the table update directly or to make it more robust you just emit a signal.

Here is a complete example which I will break down afterwards:

from PyQt4 import QtGui, QtCore, QtSql
import time

class Window(QtGui.QDialog):

    update_ready = QtCore.pyqtSignal()

    def __init__(self):
        super(Window, self).__init__()

        self.layout = QtGui.QVBoxLayout(self)
        self.table = QtGui.QTableView()
        self.layout.addWidget(self.table)

        self.db = QtSql.QSqlDatabase.addDatabase("QMYSQL")
        self.db.setHostName("server")
        self.db.setDatabaseName("db")
        self.db.setUserName("user")
        self.db.setPassword("pass")
        self.db.open()

        self.model = QtSql.QSqlTableModel(self, self.db)
        self.model.setTable("cpu_alert")
        self.model.setEditStrategy(self.model.OnManualSubmit)
        self.model.setQuery(QtSql.QSqlQuery("""
            SELECT *
            FROM cpu_alert
            WHERE date = (SELECT MAX(date) FROM cpu_alert)"""))
        self.model.select()

        self.table.setModel(self.model)

        self.button = QtGui.QPushButton("Select")
        self.layout.addWidget(self.button)

        self.button.clicked.connect(self.model.select)
        self.update_ready.connect(self.model.select)

        self.timer = QtCore.QTimer()
        self.timer.timeout.connect(self.cpu_alert_checker)
        # check every second
        self.timer.start(1000*1)

        # this is only for the temp time test
        self._now = time.time()

    def cpu_alert_checker(self):
        # You would do whatever check you want 
        # in this function
        if time.time() - self._now > 5:
            print "Update ready!"
            # emit this signal if the table should refresh
            self.update_ready.emit()
            self._now = time.time()

Instead of needing to do the raw driver query, you can use the built in QSql to create a model that automatically drives your table. There are a bunch of options to set how the table and model should show each row. But I am leaving it pretty basic.

I create a button and connect it to the select() on the sql model. I also create the QTimer, and set its timeout to call your cpu_alert_checker(). We start the timer so that every second it will fire. You can adjust this speed to your taste.

When the timeout fires, the code in the cpu_alert_checker runs. I simply put a time counter in there as a place holder to make testing easier to see. When the time passes 5 seconds it will fire and reset. You see we have defined a custom signal called update_ready. We can emit on that, and connect to that. It makes your checker more robust because it doesn't have to directly know about that able. It can just notify your app that something is ready.

I hope this example helps you out. It is a lot easier to manage this way I think. If your checker were doing a lot more heavy work, it would need to be moved to a QThread to not block the main thread.