def paint(self, painter, option, index):
        ''' 
        Paint a checkbox without the label.
        '''
        checked = bool(index.model().data(index, Qt.DisplayRole))
        opts = QStyleOptionButton()
        opts.state |= QStyle.State_Active
        if index.flags() & Qt.ItemIsEditable:
            opts.state |= QStyle.State_Enabled
        else:
            opts.state |= QStyle.State_ReadOnly
        if checked:
            opts.state |= QStyle.State_On
        else:
            opts.state |= QStyle.State_Off
        opts.rect = self.getCheckBoxRect(option)
        QApplication.style().drawControl(QStyle.CE_CheckBox, opts, painter) 

def editorEvent(self, event, model, option, index):
        ''' 
        Change the data in the model and the state of the checkbox if the
        user presses the left mouse button and this cell is editable. Otherwise do nothing.
        '''
        if not (index.flags() & Qt.ItemIsEditable):
            return False
        if event.button() == Qt.LeftButton:
            if event.type() == QEvent.MouseButtonRelease:
                if self.getCheckBoxRect(option).contains(event.pos()):
                    self.setModelData(None, model, index)
                    return True
            elif event.type() == QEvent.MouseButtonDblClick:
                if self.getCheckBoxRect(option).contains(event.pos()):
                    return True
        return False 

def flags(self, index):
        if not index.isValid():
            return 0

        if index.column() == 0:
            return Qt.ItemIsEnabled | Qt.ItemIsSelectable

        return Qt.ItemIsEditable | Qt.ItemIsEnabled | Qt.ItemIsSelectable 

def flags(self, index):
        flags = QAbstractTableModel.flags(self, index)
        if not index.isValid():
            return flags
        prop = self.getProperty(index)
        if prop is None:
            return flags
        flags |= Qt.ItemIsEnabled
        flags |= Qt.ItemIsSelectable
        mode = prop.get('mode', "Read/Write")
        if "Write" in mode:
            flags |= Qt.ItemIsEditable
        return flags 

def flags(self, index):
        return Qt.ItemIsEditable | Qt.ItemIsEnabled | Qt.ItemIsSelectable 

def flags(self, qindex: QModelIndex):
        if qindex.isValid():
            if qindex.column() in (1, 2, 3):
                return super().flags(qindex) & ~Qt.ItemIsEditable
        return super().flags(qindex) 

def flags(self, index):
        if not index.isValid():
            return super().flags(index)
        node = index.internalPointer()
        if isinstance(node, ShellTreeEntryNode) and index.column() in (1, 2, 3):
            return super().flags(index) | Qt.ItemIsEditable
        return super().flags(index) 

def flags(self, qindex):
        flags = super().flags(qindex)
        if qindex.column() in (WpDatGEntry.id.index,
                               WpDatGEntry.gmd_name_index.index,
                               WpDatGEntry.gmd_description_index):
            return flags & ~Qt.ItemIsEditable
        return flags 

def flags(self, QModelIndex):
        return Qt.ItemIsEditable | Qt.ItemIsSelectable | Qt.ItemIsEnabled 

def createGUI(self):

        tableData = pd.read_csv('DLart/networks.csv')
        self.networkHist = []
        for i in range(pd.DataFrame.count(tableData)['name']):
            self.networkHist.append(tableData.iloc[i]['name'])
        length = len(self.networkHist)
        self.table = QTableWidget(length, 2)
        self.table.setHorizontalHeaderLabels(["Network Name", "Network Path"])
        self.table.verticalHeader().setVisible(True)
        self.table.setSizeAdjustPolicy(QtWidgets.QAbstractScrollArea.AdjustToContents)

        self.table.cellDoubleClicked.connect(self.editCell)
        self.table.cellChanged.connect(self.cellChanged)

        for i in range(length):
            name = tableData.at[i,'name']
            nameItem = QTableWidgetItem(name)
            nameItem.setFlags(nameItem.flags() | Qt.ItemIsEditable)
            path = tableData.at[i,'path'].replace(".", "/") + '.py'
            pathItem = QTableWidgetItem(path)
            self.table.setItem(i, 0, nameItem)
            self.table.setItem(i, 1, pathItem)

        self.table.resizeColumnToContents(0)
        self.table.horizontalHeader().setStretchLastSection(True)

        self.layout = QGridLayout()
        self.layout.addWidget(self.table, 0, 0)
        self.setLayout(self.layout)

        self.setWindowTitle("Predefined Neural Networks Editor") 

def createGUI(self):
        length = len(self.labelHist)
        tableData = pandas.read_csv('configGUI/predefined_label.csv')

        self.table = QTableWidget(length, 2)
        self.table.setHorizontalHeaderLabels(["Label Name", "Label Color"])
        self.table.verticalHeader().setVisible(True)
        self.table.setSizeAdjustPolicy(QtWidgets.QAbstractScrollArea.AdjustToContents)

        self.table.cellDoubleClicked.connect(self.editCell)
        self.table.cellChanged.connect(self.cellChanged)

        for i in range(length):
            name = tableData.at[i,'label name']
            nameItem = QTableWidgetItem(name)
            nameItem.setFlags(nameItem.flags() | Qt.ItemIsEditable)
            color = QColor(tableData.at[i,'label color'])
            colorItem = QTableWidgetItem()
            colorItem.setData(Qt.DisplayRole, color)
            colorItem.setFlags(colorItem.flags() | Qt.ItemIsEditable)
            self.table.setItem(i, 0, nameItem)
            self.table.setItem(i, 1, colorItem)

        self.table.resizeColumnToContents(0)

        self.layout = QGridLayout()
        self.layout.addWidget(self.table, 0, 0)
        self.setLayout(self.layout)

        self.setWindowTitle("Predefined Label Editor") 

def flags(self, index):
        base_flag = Qt.ItemIsEnabled | Qt.ItemIsSelectable
        if self.is_editable:
            return base_flag | Qt.ItemIsEditable
        else:
            return base_flag 

def flags(self, index):
        f = Qt.ItemIsEnabled | Qt.ItemIsSelectable
        if index.column() == 0:
            f = f | Qt.ItemIsUserCheckable | Qt.ItemIsEditable
        return f 

def _redraw_strcol(self, row):
        start = self.row_size * row
        end = start + self.row_size
        data = self.data[start:end]
        print_data = printable_data(data, include_newline=False)
        item = QTableWidgetItem(print_data)
        item.setFlags(item.flags() ^ Qt.ItemIsEditable)
        self.datatable.setItem(row, self.str_col, item) 

def redraw_table(self, length=None):
        with DisableUpdates(self.datatable):
            oldsig = self.datatable.blockSignals(True)
            self.row_size = length or self.row_size
            self.datatable.setColumnCount(self.row_size + 1)
            self.datatable.setRowCount(0)
            self.str_col = self.row_size

            self.datatable.horizontalHeader().hide()
            self.datatable.verticalHeader().hide()

            rows = int(len(self.data) / self.row_size)
            if len(self.data) % self.row_size > 0:
                rows += 1
            self.datatable.setRowCount(rows)

            for i in range(rows * self.row_size):
                row = i / self.row_size
                col = i % self.row_size
                if i < len(self.data):
                    dataval = "%02x" % self.data[i]
                    item = QTableWidgetItem(dataval)
                    if self.read_only:
                        item.setFlags(item.flags() ^ Qt.ItemIsEditable)
                else:
                    item = QTableWidgetItem("")
                    item.setFlags(item.flags() ^ Qt.ItemIsEditable)
                self.datatable.setItem(row, col, item)

            for row in range(rows):
                self._redraw_strcol(row)
            self.datatable.blockSignals(oldsig)
            self.datatable.resizeColumnsToContents()
            self.datatable.resizeRowsToContents() 

def _add_info(self, k, v):
        row = self.infotable.rowCount()
        self.infotable.insertRow(row)
        item1 = QTableWidgetItem(k)
        item1.setFlags(item1.flags() ^ Qt.ItemIsEditable)
        self.infotable.setItem(row, 0, item1)
        self.infotable.setItem(row, 1, QTableWidgetItem(v)) 

def _add_info(self, table, k, v):
        row = table.rowCount()
        table.insertRow(row)
        item1 = QTableWidgetItem(k)
        item1.setFlags(item1.flags() ^ Qt.ItemIsEditable)
        table.setItem(row, 0, item1)
        table.setItem(row, 1, QTableWidgetItem(v)) 

def add_request_item(self, req):
        path_parts = req.url.geturl(False).split("/")
        path_parts = path_parts[1:]
        path_parts = ["/" + p for p in path_parts]
        path_parts = [req.dest_host] + path_parts
        if path_parts[0] not in self.nodes:
            item = PathNodeItem(path_parts[0], path_parts[0])
            item.setFlags(item.flags() ^ Qt.ItemIsEditable)
            self.nodes[path_parts[0]] = item
            self.root.appendRow(item)
        else:
            item = self.nodes[path_parts[0]]
        item.add_child_path(path_parts[1:]) 

def __init__(self, parent: Optional[QTreeWidgetItem], folder: model.Folder):
        QTreeWidgetItem.__init__(self)
        self.folder = folder
        self.setIcon(0, QIcon.fromTheme("folder"))
        self.setText(0, folder.title)
        self.setText(1, folder.get_abbreviations())
        self.setText(2, folder.get_hotkey_string())
        self.setData(3, Qt.UserRole, folder)
        if parent is not None:
            parent.addChild(self)

        self.setFlags(self.flags() | Qt.ItemIsEditable) 

def __init__(self, parent: Optional[FolderWidgetItem], phrase: model.Phrase):
        QTreeWidgetItem.__init__(self)
        self.phrase = phrase
        self.setIcon(0, QIcon.fromTheme("text-x-generic"))
        self.setText(0, phrase.description)
        self.setText(1, phrase.get_abbreviations())
        self.setText(2, phrase.get_hotkey_string())
        self.setData(3, Qt.UserRole, phrase)
        if parent is not None:  # TODO: Phrase without parent allowed? This is should be an error.
            parent.addChild(self)

        self.setFlags(self.flags() | Qt.ItemIsEditable) 

def __init__(self, parent: Optional[FolderWidgetItem], script: model.Script):
        QTreeWidgetItem.__init__(self)
        self.script = script
        self.setIcon(0, QIcon.fromTheme("text-x-python"))
        self.setText(0, script.description)
        self.setText(1, script.get_abbreviations())
        self.setText(2, script.get_hotkey_string())
        self.setData(3, Qt.UserRole, script)
        if parent is not None:  # TODO: Script without parent allowed? This is should be an error.
            parent.addChild(self)
        self.setFlags(self.flags() | Qt.ItemIsEditable) 

def flags(self, index):
        """ Zwraca właściwości kolumn tabeli """
        flags = super(TabModel, self).flags(index)
        j = index.column()
        if j == 1:
            flags |= Qt.ItemIsEditable
        elif j == 3 or j == 4:
            flags |= Qt.ItemIsUserCheckable

        return flags 

def flags(self, index):
        """ Zwraca właściwości kolumn tabeli """
        flags = super(TabModel, self).flags(index)
        j = index.column()
        if j == 1:
            flags |= Qt.ItemIsEditable
        elif j == 3 or j == 4:
            flags |= Qt.ItemIsUserCheckable

        return flags 

def initData(self):
        # 初始化模拟数据
        for i in range(100):
            item = QListWidgetItem('Item {0}'.format(i), self.listWidget)
            if i % 3 == 0:
                item.setFlags(item.flags() | Qt.ItemIsEditable) 

def flags(self, index):
        return Qt.ItemIsEditable | Qt.ItemIsEnabled | Qt.ItemIsSelectable 

def variableTypeChanged(self, row):
        """
        variable type combobox changed
        """

        if self.twVariables.cellWidget(row, tw_indVarFields.index("type")).currentText() == SET_OF_VALUES:
            if self.twVariables.item(row, tw_indVarFields.index("possible values")).text() == "NA":
                self.twVariables.item(row, tw_indVarFields.index("possible values")).setText("Double-click to add values")
        else:
            # check if set of values defined
            if self.twVariables.item(row, tw_indVarFields.index("possible values")).text() not in ["NA", "Double-click to add values"]:
                if dialog.MessageDialog(programName, "Erase the set of values?", [YES, CANCEL]) == CANCEL:
                    self.twVariables.cellWidget(row, tw_indVarFields.index("type")).setCurrentIndex(SET_OF_VALUES_idx)
                    return
                else:
                    self.twVariables.item(row, tw_indVarFields.index("possible values")).setText("NA")
            else:
                self.twVariables.item(row, tw_indVarFields.index("possible values")).setText("NA")

            if self.twVariables.cellWidget(row, tw_indVarFields.index("type")).currentText() == TIMESTAMP:
                self.twVariables.item(row, tw_indVarFields.index("default value")).setFlags(Qt.ItemIsEnabled)
            else:
                self.twVariables.item(row, tw_indVarFields.index("default value")).setFlags(
                    Qt.ItemIsSelectable | Qt.ItemIsEditable | Qt.ItemIsEnabled)


            # check compatibility between variable type and default value
            if not self.check_variable_default_value(self.twVariables.item(row, tw_indVarFields.index("default value")).text(),
                                                     self.twVariables.cellWidget(row, tw_indVarFields.index("type")).currentIndex()):
                QMessageBox.warning(self,
                                    programName + " - Independent variables error",
                                    "The default value ({0}) of variable <b>{1}</b> is not compatible with variable type".format(
                                        self.twVariables.item(row, tw_indVarFields.index("default value")).text(),
                                        self.twVariables.item(row, tw_indVarFields.index("label")).text())) 

def flags(self, index):
            if not index.isValid():
                return Qt.NoItemFlags

            try:
                _ = self.checksum_label.data_ranges[index.row()]
            except IndexError:
                return Qt.NoItemFlags

            return Qt.ItemIsEditable | Qt.ItemIsEnabled | Qt.ItemIsSelectable 

def flags(self, index: QModelIndex):
        if index.isValid():
            alignment_offset = self.get_alignment_offset_at(index.row())
            if index.column() < alignment_offset:
                return Qt.ItemIsSelectable | Qt.ItemIsEnabled

            if self.is_writeable:
                return Qt.ItemIsEnabled | Qt.ItemIsEditable | Qt.ItemIsSelectable
            else:
                return Qt.ItemIsEnabled | Qt.ItemIsSelectable
        else:
            return Qt.NoItemFlags 

def flags(self, index: QModelIndex):
        flags = super().flags(index)
        if index.column() in (0, 1, 2, 3):
            flags |= Qt.ItemIsEditable
        if index.column() == 0:
            flags |= Qt.ItemIsUserCheckable

        return flags 

def flags(self, index):
        flags = Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsEditable

        try:
            lbl = self.labels[index.row()]
        except IndexError:
            return flags

        if len(lbl.fuzz_values) > 1:
            flags |= Qt.ItemIsUserCheckable
        else:
            lbl.fuzz_me = False
        return flags