python类QTableWidgetItem()的实例源码

def add_point(point):
    global w
    if w.point_now is None:
        w.point_now = point
        w.point_lock = point
        add_row(w)
        i = w.table.rowCount() - 1
        item_x = QTableWidgetItem("{0}".format(point.x()))
        item_y = QTableWidgetItem("{0}".format(point.y()))
        w.table.setItem(i, 0, item_x)
        w.table.setItem(i, 1, item_y)
    else:
        w.edges.append([w.point_now.x(), w.point_now.y(),
                        point.x(), point.y()])
        w.point_now = point
        add_row(w)
        i = w.table.rowCount() - 1
        item_x = QTableWidgetItem("{0}".format(point.x()))
        item_y = QTableWidgetItem("{0}".format(point.y()))
        w.table.setItem(i, 0, item_x)
        w.table.setItem(i, 1, item_y)
        item_x = w.table.item(i-1, 0)
        item_y = w.table.item(i-1, 1)
        w.scene.addLine(point.x(), point.y(), float(item_x.text()), float(item_y.text()), w.pen)
    #print(w.edges)

def open_sheet(self):
        #self.check_change = False
        path = ('./contacts.csv', 'CSV(*.csv)')
        print(path)
        if path[0] != '':
            with open(path[0], newline='') as csv_file:
                self.table_contacts.setRowCount(0)
                self.table_contacts.setColumnCount(5)
                my_file = csv.reader(csv_file, delimiter=',', quotechar='|')
                for row_data in my_file:
                    row = self.table_contacts.rowCount()
                    self.table_contacts.insertRow(row)
                    if len(row_data) > 10:
                        self.table_contacts.setColumnCount(len(row_data))
                    for column, stuff in enumerate(row_data):
                        item = QTableWidgetItem(stuff)
                        self.table_contacts.setItem(row, column, item)
        #self.check_change = True
        print(self.table_contacts.rowCount())

def update(self):
        """
        update the table with updated fit parameters
        """

        # If the fit is not done, clear the parameters
        if not self._fit.fitter.fit_success or len(self._fit.experiments) == 0:
            self.clear()
            return

        # Grab fit results from csv
        self._csv_to_table()

        self.setRowCount(len(self._data))
        self.setColumnCount(len(self._data[0]))
        self.setHorizontalHeaderLabels(self._col_name)

        # load fit data into the table
        for i, row in enumerate(self._data):
            for j, col in enumerate(row):
                item = QW.QTableWidgetItem(col)
                self.setItem(i, j, item)

def _makewidget(val, center=False):
    """ Small helper function that builds a TableWidgetItem and sets up the font the way we want"""
    out = QtWidgets.QTableWidgetItem(str(val))
    out.setFlags(Qt.ItemIsEnabled)
    out.setFont(monospace)
    if(center):
        out.setTextAlignment(Qt.AlignCenter)
    return out

def __init__(self):
        QtWidgets.QMainWindow.__init__(self)
        Ui_MainWindow.__init__(self)
        self.setupUi(self)

        self.__register__ = None
        self.__attendance____ = None

        self.btn_Register.clicked.connect(self.Register)
        self.btn_Attendance.clicked.connect(self.Attendance)
        self.btnSearch.clicked.connect(self.Search)
        self.report_date.setDate(QtCore.QDate.currentDate())

        cursor = connection.cursor()
        sql = "Select * from attendance"
        cursor.execute(sql)

        result = cursor.fetchall()
        rows = len(result)
        if rows <= 0:
            QMessageBox.about(self, "No Data", "No Attendance has been recorded yet")
        else:
            self.tableWidget.setRowCount(rows)
            self.tableWidget.setColumnCount(3)
            header_labels = ['Matric Number', 'Date', 'Status']
            self.tableWidget.setHorizontalHeaderLabels(header_labels)

            for count in range(0, rows):
                self.tableWidget.setItem(count, 0,
                                         QTableWidgetItem(str(result[count]["matric_num"].encode('ascii', 'ignore'))))
                self.tableWidget.setItem(count, 1, QTableWidgetItem(result[count]["dte"].encode('ascii', 'ignore')))
                self.tableWidget.setItem(count, 2, QTableWidgetItem(result[count]["status"].encode('ascii', 'ignore')))

def add_bars(win):
    if len(win.edges) == 0:
        QMessageBox.warning(win, "????????!", "?? ?????? ??????????!")
        return
    win.pen.setColor(red)
    w.lines.append([[win.edges[0].x() - 15, win.edges[0].y() - 15],
                    [win.edges[1].x() - 15, win.edges[1].y() - 15]])
    add_row(w.table_bars)
    i = w.table_bars.rowCount() - 1
    item_b = QTableWidgetItem("[{0}, {1}]".format(win.edges[0].x() - 15 , win.edges[0].y() - 15))
    item_e = QTableWidgetItem("[{0}, {1}]".format(win.edges[1].x() - 15, win.edges[1].y() - 15))
    w.table_bars.setItem(i, 0, item_b)
    w.table_bars.setItem(i, 1, item_e)
    w.scene.addLine(win.edges[0].x() - 15, win.edges[0].y() - 15, win.edges[1].x() - 15, win.edges[1].y() - 15, w.pen)

    win.pen.setColor(red)
    w.lines.append([[win.edges[0].x() + 15, win.edges[0].y() + 15],
                    [win.edges[1].x() + 15, win.edges[1].y() + 15]])
    add_row(w.table_bars)
    i = w.table_bars.rowCount() - 1
    item_b = QTableWidgetItem("[{0}, {1}]".format(win.edges[0].x() + 15, win.edges[0].y() + 15))
    item_e = QTableWidgetItem("[{0}, {1}]".format(win.edges[1].x() + 15, win.edges[1].y() + 15))
    w.table_bars.setItem(i, 0, item_b)
    w.table_bars.setItem(i, 1, item_e)
    w.scene.addLine(win.edges[0].x() + 15, win.edges[0].y() + 15, win.edges[1].x() + 15, win.edges[1].y() + 15, w.pen)

def add_point(point):
    global w
    if w.point_now is None:
        w.point_now = point
        w.point_lock = point
        add_row(w)
        i = w.table.rowCount() - 1
        item_x = QTableWidgetItem("{0}".format(point.x()))
        item_y = QTableWidgetItem("{0}".format(point.y()))
        w.table.setItem(i, 0, item_x)
        w.table.setItem(i, 1, item_y)
    else:
        w.edges.append([w.point_now.x(), w.point_now.y(),
                        point.x(), point.y()])
        w.point_now = point
        add_row(w)
        i = w.table.rowCount() - 1
        item_x = QTableWidgetItem("{0}".format(point.x()))
        item_y = QTableWidgetItem("{0}".format(point.y()))
        w.table.setItem(i, 0, item_x)
        w.table.setItem(i, 1, item_y)
        item_x = w.table.item(i-1, 0)
        item_y = w.table.item(i-1, 1)
        w.scene.addLine(point.x(), point.y(), float(item_x.text()), float(item_y.text()), w.pen)
    #print(w.edges)

def createTable(self):
        q = LatestQuakes()
        c = 0

        self.tableWidget = QTableWidget()
        self.tableWidget.setVerticalHeaderLabels(('Row 1', 'Row 2', 'Row 3'))
        self.tableWidget.setRowCount(30)
        self.tableWidget.setColumnCount(7)
        self.tableWidget.setColumnWidth(0, 30)
        self.tableWidget.setColumnWidth(1, 160)

        for quake in q.work():
            self.tableWidget.setItem(c, 0, QTableWidgetItem(quake["text"]))
            self.tableWidget.setItem(c, 1, QTableWidgetItem(quake["name"]))
            self.tableWidget.setItem(c, 2, QTableWidgetItem(quake["time"]))
            self.tableWidget.setItem(c, 3, QTableWidgetItem(quake["hours"]))
            self.tableWidget.setItem(c, 4, QTableWidgetItem(quake["deep"]))
            self.tableWidget.setItem(c, 5, QTableWidgetItem(quake["longitude"][0]))
            self.tableWidget.setItem(c, 6, QTableWidgetItem(quake["latitude"][0]))
            c = c + 1

        self.tableWidget.move(0, 0)
        # table selection change
        # self.tableWidget.doubleClicked.connect(self.on_click)

def createTable(self):
       # Create table
        self.tableWidget = QTableWidget()
        self.tableWidget.setRowCount(4)
        self.tableWidget.setColumnCount(2)
        self.tableWidget.setItem(0,0, QTableWidgetItem("Cell (1,1)"))
        self.tableWidget.setItem(0,1, QTableWidgetItem("Cell (1,2)"))
        self.tableWidget.setItem(1,0, QTableWidgetItem("Cell (2,1)"))
        self.tableWidget.setItem(1,1, QTableWidgetItem("Cell (2,2)"))
        self.tableWidget.setItem(2,0, QTableWidgetItem("Cell (3,1)"))
        self.tableWidget.setItem(2,1, QTableWidgetItem("Cell (3,2)"))
        self.tableWidget.setItem(3,0, QTableWidgetItem("Cell (4,1)"))
        self.tableWidget.setItem(3,1, QTableWidgetItem("Cell (4,2)"))
        self.tableWidget.move(0,0)

        # table selection change
        self.tableWidget.doubleClicked.connect(self.on_click)

def open_sheet(self):
        self.check_change = False
        path = QFileDialog.getOpenFileName(self, 'Open CSV', os.getenv('HOME'), 'CSV(*.csv)')
        if path[0] != '':
            with open(path[0], newline='') as csv_file:
                self.setRowCount(0)
                self.setColumnCount(10)
                my_file = csv.reader(csv_file, delimiter=',', quotechar='|')
                for row_data in my_file:
                    row = self.rowCount()
                    self.insertRow(row)
                    if len(row_data) > 10:
                        self.setColumnCount(len(row_data))
                    for column, stuff in enumerate(row_data):
                        item = QTableWidgetItem(stuff)
                        self.setItem(row, column, item)
        self.check_change = True

def open_sheet(self):
        self.check_change = False
        path = QFileDialog.getOpenFileName(self, 'Open CSV', os.getenv('HOME'), 'CSV(*.csv)')
        if path[0] != '':
            with open(path[0], newline='') as csv_file:
                self.setRowCount(0)
                self.setColumnCount(10)
                my_file = csv.reader(csv_file, dialect='excel')
                for row_data in my_file:
                    row = self.rowCount()
                    self.insertRow(row)
                    if len(row_data) > 10:
                        self.setColumnCount(len(row_data))
                    for column, stuff in enumerate(row_data):
                        item = QTableWidgetItem(stuff)
                        self.setItem(row, column, item)
        self.check_change = True

def _makewidget(val, center=False):
    """ Small helper function that builds a TableWidgetItem and sets up the font the way we want"""
    out = QtWidgets.QTableWidgetItem(str(val))
    out.setFlags(Qt.ItemIsEnabled)
    out.setFont(monospace)
    if(center):
        out.setTextAlignment(Qt.AlignCenter)
    return out

def fwChanged(self, flag = False):
        if not self.currentlyLoading:
            if self.currentFertName != "":
                if flag:
                    val = self.spinRef[self.currentFertName].value()
                else:
                    val = self.uiFert.spinFW.value()
                Wolke.Char.fertigkeiten[self.currentFertName].wert = val
                Wolke.Char.fertigkeiten[self.currentFertName].aktualisieren()
                self.uiFert.spinPW.setValue(Wolke.Char.fertigkeiten[self.currentFertName].probenwert)
                self.uiFert.spinPWT.setValue(Wolke.Char.fertigkeiten[self.currentFertName].probenwertTalent)
                self.modified.emit()
                #self.uiFert.tableWidget.setItem(self.rowRef[self.currentFertName],1,QtWidgets.QTableWidgetItem(str(Wolke.Char.fertigkeiten[self.currentFertName].wert)))
                if flag:
                    self.uiFert.spinFW.setValue(val)
                else:
                    self.spinRef[self.currentFertName].setValue(val)

def fwChanged(self, flag = False):
        if not self.currentlyLoading:
            if self.currentFertName != "":
                if flag:
                    val = self.spinRef[self.currentFertName].value()
                else:
                    val = self.uiFert.spinFW.value()
                Wolke.Char.übernatürlicheFertigkeiten[self.currentFertName].wert = val
                Wolke.Char.übernatürlicheFertigkeiten[self.currentFertName].aktualisieren()
                self.uiFert.spinPW.setValue(Wolke.Char.übernatürlicheFertigkeiten[self.currentFertName].probenwertTalent)
                #self.uiFert.spinPWT.setValue(Wolke.Char.übernatürlicheFertigkeiten[self.currentFertName].probenwertTalent)
                self.modified.emit()
                #self.uiFert.tableWidget.setItem(self.rowRef[self.currentFertName],1,QtWidgets.QTableWidgetItem(str(Wolke.Char.übernatürlicheFertigkeiten[self.currentFertName].wert)))
                if flag:
                    self.uiFert.spinFW.setValue(val)
                else:
                    self.spinRef[self.currentFertName].setValue(val)

def tab_set_value(tab,y,x,value):
    if type(tab.cellWidget(y, x))==QComboBox:
        tab.cellWidget(y, x).blockSignals(True)
        tab.cellWidget(y, x).setCurrentIndex(tab.cellWidget(y, x).findText(value))
        tab.cellWidget(y, x).blockSignals(False)
    elif type(tab.cellWidget(y, x))==QComboBoxLang:
        tab.cellWidget(y, x).blockSignals(True)
        tab.cellWidget(y, x).setCurrentIndex(tab.cellWidget(y, x).findText(value))
        tab.cellWidget(y, x).blockSignals(False)
    elif type(tab.cellWidget(y,x))==gpvdm_select:
        tab.cellWidget(y, x).blockSignals(True)
        tab.cellWidget(y, x).setText(value)
        tab.cellWidget(y, x).blockSignals(False)
    elif type(tab.cellWidget(y,x))==gtkswitch:
        tab.cellWidget(y, x).blockSignals(True)
        tab.cellWidget(y, x).set_value(str2bool(value))
        tab.cellWidget(y, x).blockSignals(False)
    else:
        item = QTableWidgetItem(str(value))
        tab.setItem(y,x,item)

def insert_row(self,i,file_name,token,path,value):
        self.tab.blockSignals(True)
        self.tab.insertRow(i)

        item = QTableWidgetItem(file_name)
        self.tab.setItem(i,0,item)

        item = QTableWidgetItem(token)
        self.tab.setItem(i,1,item)


        self.item = gpvdm_select()
        self.item.setText(path)
        self.item.button.clicked.connect(self.callback_show_list)

        self.tab.setCellWidget(i,2,self.item)

        item = QTableWidgetItem(value)
        self.tab.setItem(i,3,item)
        self.tab.blockSignals(False)

def begin_search(self, root_path, file_type, ignore_case, keyword):
        counts = 0
        for root, dirs, files in os.walk(root_path):
            for each_file in files:
                if is_valid_file_type(each_file, file_type):
                    path = root + os.sep + each_file
                    line_content = search_keyword_infile(path, keyword, ignore_case)
                    if line_content:
                        self.result_table.insertRow(counts)

                        content_path = QTableWidgetItem(".{}".format(path[len(root_path):]))
                        self.result_table.setItem(counts, 0, content_path)

                        content = QTableWidgetItem(line_content.strip())
                        self.result_table.setItem(counts, 1, content)

                        counts += 1
                        self.result_table.setRowCount(counts)

        self.state_label.setText("????")

def add_input_action(self):
        self.inputs_table.setRowCount(self.inputs_table.rowCount()+1)
        i = self.inputs_table.rowCount()-1
        type_combo = QtWidgets.QComboBox()
        type_combo.addItems(["REG", "MEM"])
        action_combo = QtWidgets.QComboBox()
        action_combo.addItems(["DEFAULT", "PATCH", "CONC", "SYMB", "IGNORE"])
        when_combo = QtWidgets.QComboBox()
        when_combo.addItems(["BEFORE", "AFTER"])
        info = [type_combo, QtWidgets.QTableWidgetItem(), QtWidgets.QTableWidgetItem(), QtWidgets.QTableWidgetItem(),
                action_combo, when_combo]

        for col_id, widget in enumerate(info):
            if isinstance(widget, QtWidgets.QTableWidgetItem):
                self.inputs_table.setItem(i, col_id, widget)
            else:
                self.inputs_table.setCellWidget(i, col_id, widget)
        return i

def kullaniciListesi(self):
        try:
            kisiler = json.load(open(self.json_file, "r"))

        except:
            kisiler = []

        self.kullanici_listesi.clearContents()
        self.kullanici_listesi.setRowCount(len(kisiler))

        satir = 0
        for kisi in kisiler:
            telefon = QTableWidgetItem(kisi.get("telefon"))
            isim = QTableWidgetItem(kisi.get("isim"))
            self.kullanici_listesi.setItem(satir, 0, isim)
            self.kullanici_listesi.setItem(satir, 1, telefon)
            satir += 1

def show_pearson_correlation(self):
        if self.dataset_loaded:
            self.feature_inspection_fig.hide()
            self.correlation_table.show()
            correlation_matrix=pearson_correlation_matrix(self.X)


            #initialize rows, columns and headers
            self.correlation_table.setRowCount(0)
            self.correlation_table.setColumnCount(0)
            for i in xrange(len(self.X[0])):
                self.correlation_table.insertRow(i)
                self.correlation_table.insertColumn(i)
                self.correlation_table.setHorizontalHeaderItem(i,QtWidgets.QTableWidgetItem(self.features[i]))
                self.correlation_table.setVerticalHeaderItem(i,QtWidgets.QTableWidgetItem(self.features[i]))

            #fill table data
            for i in xrange(len(self.X[0])):
                for j in xrange(len(self.X[0])):
                    self.correlation_table.setItem(i,j,QtWidgets.QTableWidgetItem(str(correlation_matrix[i][j])))
        else:
            QtWidgets.QMessageBox.information(self, "Data Not Found","Please load a dataset first.")

    #Apply data tranformation

def get_widgets(self):
            widgets = {}
            widgets["address"] = QtWidgets.QTableWidgetItem(self.address)
            widgets["curname"] = QtWidgets.QTableWidgetItem(self.curname)
            widgets["machoc"] = QtWidgets.QTableWidgetItem(self.machoc)
            widgets["proposed"] = QtWidgets.QTableWidgetItem(self.proposed)

            return widgets

def Search(self):
        matric_num = self.report_matric.text()
        search_date = self.report_date.date().toString("yyyy-MM-dd")

        if matric_num == "" and search_date == "":
            QMessageBox.about(self, "Invalid Parameters", "Please Provide a search Query to continue")
        else:
            self.tableWidget.setRowCount(0)
            if matric_num != "":
                sql = "Select * from attendance where matric_num = %s"
                cursor = connection.cursor()
                cursor.execute(sql, matric_num)
                result = cursor.fetchall()

            else:
                sql = "Select * from attendance where dte = %s"
                cursor = connection.cursor()
                cursor.execute(sql, search_date)
                result = cursor.fetchall()

            if len(result) > 0:
                self.tableWidget.setRowCount(len(result))
                self.tableWidget.setColumnCount(3)
                header_labels = ['Matric Number', 'Date', 'Status']
                self.tableWidget.setHorizontalHeaderLabels(header_labels)

                for count in range(0, len(result)):
                    self.tableWidget.setItem(count, 0, QTableWidgetItem(
                        str(result[count]["matric_num"].encode('ascii', 'ignore'))))
                    self.tableWidget.setItem(count, 1,
                                             QTableWidgetItem(result[count]["dte"].encode('ascii', 'ignore')))
                    self.tableWidget.setItem(count, 2,
                                             QTableWidgetItem(result[count]["status"].encode('ascii', 'ignore')))
            else:
                QMessageBox.about(self, "No Data", "No Data has been recorded")

def add_point(point):
    global w
    if w.input_rect:
        w.pen.setColor(black)
        if w.point_now_rect is None:
            w.point_now_rect = point
            w.point_lock = point
            add_row(w.table_rect)
            i = w.table_rect.rowCount() - 1
            item_x = QTableWidgetItem("{0}".format(point.x()))
            item_y = QTableWidgetItem("{0}".format(point.y()))
            w.table_rect.setItem(i, 0, item_x)
            w.table_rect.setItem(i, 1, item_y)
        else:
            w.edges.append(point)
            w.point_now_rect = point
            add_row(w.table_rect)
            i = w.table_rect.rowCount() - 1
            item_x = QTableWidgetItem("{0}".format(point.x()))
            item_y = QTableWidgetItem("{0}".format(point.y()))
            w.table_rect.setItem(i, 0, item_x)
            w.table_rect.setItem(i, 1, item_y)
            item_x = w.table_rect.item(i-1, 0)
            item_y = w.table_rect.item(i-1, 1)
            w.scene.addLine(point.x(), point.y(), float(item_x.text()), float(item_y.text()), w.pen)
    if w.input_bars:
        w.pen.setColor(red)
        if w.point_now_bars is None:
            w.point_now_bars = point
        else:
            w.lines.append([[w.point_now_bars.x(), w.point_now_bars.y()],
                            [point.x(), point.y()]])

            add_row(w.table_bars)
            i = w.table_bars.rowCount() - 1
            item_b = QTableWidgetItem("[{0}, {1}]".format(w.point_now_bars.x(), w.point_now_bars.y()))
            item_e = QTableWidgetItem("[{0}, {1}]".format(point.x(), point.y()))
            w.table_bars.setItem(i, 0, item_b)
            w.table_bars.setItem(i, 1, item_e)
            w.scene.addLine(w.point_now_bars.x(), w.point_now_bars.y(), point.x(), point.y(), w.pen)
            w.point_now_bars = None

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

        self.form_widget = MyTable(10, 7)
        self.setCentralWidget(self.form_widget)
        col_headers = ['Name', 'Company', 'Mobile', 'Email ID', 'Address', 'Designation', 'DOB']
        self.form_widget.setHorizontalHeaderLabels(col_headers)

        #number = QTableWidgetItem('10')
        #self.form_widget.setCurrentCell(1, 1)
        #self.form_widget.setItem(1, 1, number)

        self.show()

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

        self.form_widget = MyTable(10, 10)
        self.setCentralWidget(self.form_widget)
        col_headers = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
        self.form_widget.setHorizontalHeaderLabels(col_headers)

        number = QTableWidgetItem('10')
        self.form_widget.setCurrentCell(1, 1)
        self.form_widget.setItem(1, 1, number)

        self.show()

def switchPatNum(self):

        if self.patNum_flag:

            self.patColHeaders = []
            for i in range(self.nStage):

                self.patColHeaders.append("Stage "+str(i+1))

            self.patNum_tableWidget.setRowCount(1)
            self.patNum_tableWidget.setColumnCount(self.nStage)
            self.patNum_tableWidget.setCurrentCell(-1, -1)
            self.patNum_tableWidget.setHorizontalHeaderLabels(self.patColHeaders)

            # If unchanged, load the settings last time
            if self.nStage == len(self.ns_list):

                for j in range(self.nStage):

                    self.patNum_tableWidget.setItem(0, j, QtWidgets.QTableWidgetItem(str(int(self.ns_list[j]))))

            self.nStage_comboBox.setEnabled(False)
            self.nArm_comboBox.setEnabled(False)

        else:

            self.assignPatient_btn.setFocus()
            self.nStage_comboBox.setEnabled(True)
            self.nArm_comboBox.setEnabled(True)


        self.patNum_Frame.setVisible(self.patNum_flag)
        self.patNum_flag = not self.patNum_flag


    # Toggle for patient frame

def switchStopBoundary(self):

        if self.stopBoundary_flag:

            self.patColHeaders = []
            for i in range(self.nStage):

                self.patColHeaders.append("Stage "+str(i+1))

            # There are two rows, corresponding to the futility and efficacy boundary
            self.stopBoundary_tableWidget.setRowCount(2)
            self.stopBoundary_tableWidget.setColumnCount(self.nStage)
            self.stopBoundary_tableWidget.setCurrentCell(-1, -1)
            self.stopBoundary_tableWidget.setHorizontalHeaderLabels(self.patColHeaders)
            self.stopBoundary_tableWidget.setVerticalHeaderLabels(["Futility", "Efficacy"])

            # If unchanged, load the settings last time
            if self.nStage == len(self.fut_list) and self.nStage == len(self.eff_list):

                for j in range(self.nStage):

                    self.stopBoundary_tableWidget.setItem(0, j, QtWidgets.QTableWidgetItem(str(self.fut_list[j])))
                    self.stopBoundary_tableWidget.setItem(1, j, QtWidgets.QTableWidgetItem(str(self.eff_list[j])))

            self.nStage_comboBox.setEnabled(False)
            self.nArm_comboBox.setEnabled(False)

        else:

            self.setStopBoundary_btn.setFocus()
            self.nStage_comboBox.setEnabled(True)
            self.nArm_comboBox.setEnabled(True)


        self.stopBoundary_Frame.setVisible(self.stopBoundary_flag)
        self.stopBoundary_flag = not self.stopBoundary_flag


    # Toggle for added patient frame

def switchPredNum(self):

        if self.predNum_flag:

            self.patColHeaders = []
            for i in range(self.nStage):

                self.patColHeaders.append("Stage "+str(i+1))

            self.predNum_tableWidget.setRowCount(1)
            self.predNum_tableWidget.setColumnCount(self.nStage)
            self.predNum_tableWidget.setCurrentCell(-1, -1)
            self.predNum_tableWidget.setHorizontalHeaderLabels(self.patColHeaders)

            # If unchanged, load the settings last time
            if self.nStage == len(self.predns_list):

                for j in range(self.nStage):

                    self.predNum_tableWidget.setItem(0, j, QtWidgets.QTableWidgetItem(str(int(self.predns_list[j]))))

            self.nStage_comboBox.setEnabled(False)
            self.nArm_comboBox.setEnabled(False)
            self.predict_checkBox.setEnabled(False)

        else:

            self.predNum_btn.setFocus()
            self.nStage_comboBox.setEnabled(True)
            self.nArm_comboBox.setEnabled(True)
            self.predict_checkBox.setEnabled(True)

        self.predNum_Frame.setVisible(self.predNum_flag)
        self.predNum_flag = not self.predNum_flag


    # Save effective size

def appendLine(self, line = None):
        """
        Add a line to the table. The new line is inserted before the selected line, or at the end of the table is no line is selected
        @param line: a string list containing all the values for this lines. If line is None, an empty line is inserted
        """
        selected_row = self.tablewidget.currentRow()
        if selected_row < 0 or len(self.tablewidget.selectedIndexes()) <= 0: #Trick to be able to insert lines before the first and after the last line (click on column name to unselect the lines)
            selected_row = self.tablewidget.rowCount()

        self.tablewidget.insertRow(selected_row)

        #If provided, fill the table with the content of the line list
        if line is not None and isinstance(line, (list, tuple)) and len(line) >= self.tablewidget.columnCount():
            for i in range(self.tablewidget.columnCount()):
                #self.tablewidget.setItem(selected_row, i, QTableWidgetItem(line[i]))
                self.setCellValue(selected_row, i, line[i])
        else:
            for i in range(self.tablewidget.columnCount()):
                self.setCellValue(selected_row, i, "") #Don't remove this line, otherwise the subclasses won't be able to set custom widget into the table.

        #Resize the columns to the content, except for the last one
        for i in range(self.tablewidget.columnCount() - 1):
            self.tablewidget.resizeColumnToContents(i)

        #Resize the rows to the content
        for i in range(self.tablewidget.rowCount()):
            self.tablewidget.resizeRowToContents(i)

def setCellValue(self, line, column, value):
        """
        Default implementation for filling cells use Qt default QTableWidgetItem. One can subclass to provide another implementation, like inserting various Widget into the table.
        @param line: line number (int)
        @param column: column number (int)
        @param value: cell content (string)
        """
        self.tablewidget.setItem(line, column, QTableWidgetItem(value))