OpenFFBoard-configurator/errors.py at master · mlkood/OpenFFBoard-configurator · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
from base_ui import WidgetUI
from PyQt5.QtWidgets import QDialog,QTableWidgetItem ,QHeaderView
from PyQt5.QtWidgets import QMessageBox,QVBoxLayout,QCheckBox,QButtonGroup,QPushButton,QLabel,QSpinBox,QComboBox
from PyQt5.QtCore import QAbstractTableModel,Qt,QModelIndex


class ErrorsModel(QAbstractTableModel):
    def __init__(self,parent):
        super(ErrorsModel, self).__init__()
        self.parent = parent
        self.errors = []
        self.header = ["Code", "Level","Info"]

    def data(self, index, role):
        if role == Qt.DisplayRole:
            idx = index.row()

            d = self.errors[idx]

            if(index.column() == 0):
                return d["code"]
            elif(index.column() == 1):
                return d["level"]
            elif(index.column() == 2):
                return d["info"]
            else:
                return None

    def headerData(self,section,orientation,role):
        if role == Qt.DisplayRole:
            if orientation == Qt.Horizontal:
                return self.header[section]


    def getHeader(self):
        return self.header

    def rowCount(self, index):
        return len(self.errors)

    def columnCount(self, index):
        return len(self.header)

    def clearErrors(self):
        self.beginResetModel()
        self.errors.clear()
        self.endResetModel()

    def errorCount(self):
        return len(self.errors)

    def addError(self,error):
        errcnt = len(self.errors)
        self.beginInsertRows(QModelIndex(),errcnt,errcnt)
        self.errors.append(error)
        self.endInsertRows()

    def setErrors(self,errors):
        self.beginResetModel()
        self.errors = errors
        self.endResetModel()

class ErrorsDialog(QDialog):
    def __init__(self,main=None):
        QDialog.__init__(self, main)
        self.main = main
        self.ui = ErrorsUI(main,self)
        self.layout = QVBoxLayout()
        self.layout.setContentsMargins(0,0,0,0)
        self.layout.addWidget(self.ui)
        self.setLayout(self.layout)
        self.setWindowTitle("Errors")

class ErrorsUI(WidgetUI):

    def __init__(self, main=None,parent = None):
        WidgetUI.__init__(self, parent,'errors.ui')
        self.main = main
        self.parent = parent
        main.comms.serialRegisterCallback("Err",self.errorCallback)
        self.pushButton_refresh.clicked.connect(self.readErrors)
        self.pushButton_clearAll.clicked.connect(self.clearErrors)
        self.errors = ErrorsModel(self.tableView)
        self.tableView.setModel(self.errors)
        header = self.tableView.horizontalHeader()
        header.setStretchLastSection(True)


    def clearErrors(self):
        self.main.comms.serialWrite("errorsclr\n")
        self.readErrors()

    def showEvent(self, a0):
        self.tableView.resizeColumnsToContents()
        #self.readErrors()

    def readErrors(self):
        if(self.isEnabled):
            self.main.comms.serialGetAsync("errors",self.errorCallback)

    def errorCallback(self,errorstring):
        self.parent.show()
        errors = []
        for errorline in errorstring.split("\n"):
            e = errorline.split(":")
            if(len(e) < 3):
                continue
            error = {"code":e[0], "level":e[1], "info":e[2]}
            errors.append(error)
        self.errors.setErrors(errors)
        self.tableView.resizeColumnsToContents()