HYTOS

    def getCustomTables(self):

        ''' get custom code tables '''

        with self.project.database.connect() as conn:

            try:

                # Get a cursor object

                cursor = conn.cursor()

                sql = self.project.database.to_sql('select UID, Name, Desciption from CustomTables')

                cursor.execute(sql)

                rows = cursor.fetchall()

                for row in rows:

                    attr = SymbolAttr()

                    attr.UID = uuid.UUID(row[0])

                    attr.Attribute = row[1]

                    attr.DisplayAttribute = row[2]

                    attr.AttributeType = row[3]

                    attr.AttrAt = row[4]

                    attr.Expression = row[5]

                    attr.Target = row[7]

                    attr.IsProp = row[8]

                    attr.Codes = CodeTable.instance('SymbolAttributeCodeTable', row[0])

                    result.append(attr)

            # Catch the exception

            except Exception as ex:

                from App import App

                message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename,

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

        return result

    def saveCustomCodes(self, tables):

        ''' save custom code tables and codes '''

        from CodeTables import CodeTable

        conn = self.project.database.connect()

        with conn:

            try:

                # Get a cursor object

                cursor = conn.cursor()

                # delete custom codes and tables

                sql = "delete from CustomCodes"

                cursor.execute(sql)

                sql = "delete from CustomTables"

                cursor.execute(sql)

                # up to here

                # update symbol attribute code table data

                for table in tables:

                    sql = self.project.database.to_sql("insert into CustomTables (UID, Name, Description) VALUES(?,?,?)")

                    param = (table[0], table[1], table[2])

                    cursor.execute(sql, param)

                    for code in table[3]:

                        sql = self.project.database.to_sql( \

                            "insert into CustomCodes(UID, Code, Description, Allowables, Table_UID) VALUES(?,?,?,?,?)")

                        param = (code[0], code[1], code[2], ','.join(code[3]), table[0])

                        cursor.execute(sql, param)

                # up to here

                conn.commit()

            # Catch the exception

            except Exception as ex:

                # Roll back any change if something goes wrong

                conn.rollback()

                from App import App

                message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename,

                                                              sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

            CodeTable.clearTables()

    def getCodeTable(self, property, forCheckLineNumber=False, symbol_attribute_uid=None, custom_table_uid=None):

                    if not symbol_attribute_uid and not custom_table_uid:

                    elif symbol_attribute_uid and not custom_table_uid:

                    elif not symbol_attribute_uid and custom_table_uid:

                        sql = "select uid, code, description, Allowables from [{}] where Table_UID='{}' order by code DESC".format(property, custom_table_uid)

    def settingTable(self, tableName, symbol_attribute_uid=None, custom_table_uid=None, tableDatas=None):

            elif tableName == 'CustomCodes':

                if tableDatas is None:

                    tableDatas = docData.getCodeTable(tableName, forCheckLineNumber=False, custom_table_uid=symbol_attribute_uid)

                else:

                    pass

    def instance(table_name, symbol_attribute_uid=None, custom_table_uid=None):

        elif symbol_attribute_uid is None and custom_table_uid is None and _table_name not in CodeTable.TABLES:

        elif _table_name == 'CUSTOMTABLES' and symbol_attribute_uid:

            if custom_table_uid in CodeTable.TABLES:

                return CodeTable.TABLES[custom_table_uid]

            else:

                appDocData = AppDocData.instance()

                values = appDocData.getCodeTable(_table_name, False, custom_table_uid=custom_table_uid)

                CodeTable.TABLES[custom_table_uid] = CodeTable(custom_table_uid, values)

                return CodeTable.TABLES[custom_table_uid]

        self.ui.tableWidgetCustomCodeTable.setColumnCount(4)

        self.ui.tableWidgetCustomCodeTable.setHorizontalHeaderLabels(['UID', 'Name', 'Description', 'Table'])

        self.ui.tableWidgetCustomCodeTable.hideColumn(0)

        self.ui.pushButtonAdd.clicked.connect(self.addTable)

        self.ui.pushButtonDelete.clicked.connect(self.delTable)

        self.ui.tableWidgetCustomCodeTable.cellDoubleClicked.connect(self.cell_double_clicked)

    def cell_double_clicked(self, row, column):

        from SymbolAttrCodeTableDialog import SymbolAttrCodeTableDialog

        from App import App

        try:

            if column == 3:

                dialog = SymbolAttrCodeTableDialog(self, self.ui.tableWidgetCustomCodeTable.item(row, 0).text(), tableDatas=self.ui.tableWidgetCustomCodeTable.item(row, 3).tag, Table_Name='CustomCodes')

                (isAccept, code_data) = dialog.showDialog()

                if isAccept:

                    self.ui.tableWidgetCustomCodeTable.item(row, 3).tag = code_data

                graphicsView = App.mainWnd().graphicsView

                if dialog.code_area:

                    if dialog.code_area.scene():

                        graphicsView.scene.removeItem(dialog.code_area)

                if dialog.desc_area:

                    if dialog.desc_area.scene():

                        graphicsView.scene.removeItem(dialog.desc_area)

                graphicsView.useDefaultCommand()

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)

            App.mainWnd().addMessage.emit(MessageType.Error, message)

    def addTable(self):

        import uuid

        rows = self.ui.tableWidgetCustomCodeTable.rowCount()

        self.ui.tableWidgetCustomCodeTable.setRowCount(rows + 1)

        item = QTableWidgetItem('...')

        item.tag = []

        item.setTextAlignment(Qt.AlignHCenter)

        item.setFlags(Qt.ItemIsEnabled)

        self.ui.tableWidgetCustomCodeTable.setItem(rows, 3, item)

        item = QTableWidgetItem(str(uuid.uuid4()))

        self.ui.tableWidgetCustomCodeTable.setItem(rows, 0, item)

    def delTable(self):

        model = self.ui.tableWidgetCustomCodeTable.model()

        row = self.ui.tableWidgetCustomCodeTable.currentRow()

        if row != -1:

            model.removeRow(row)

            appDocData = AppDocData.instance()

            tables = []

            table = self.ui.tableWidgetCustomCodeTable

            for index in range(table.rowCount()):

                attr = []

                attr.append(table.item(index, 0).text() if table.item(index, 0) is not None else '')

                attr.append(table.item(index, 1).text() if table.item(index, 1) is not None else '')

                attr.append(table.item(index, 2).text() if table.item(index, 2) is not None else '')

                attr.append(table.item(index, 3).tag if table.item(index, 3) is not None else [])

                tables.append(attr)

            appDocData.saveCustomCodes(tables)

        # for custom code table

        if Table_Name != 'SymbolAttributeCodeTable':

            self.setWindowTitle('Custom Code Table')

            self.ui.tableWidgetSymbolAttributeCodeTable.setObjectName('tableWidget' + Table_Name)

        self.settingTable(Table_Name, symbol_attribute_uid=symbol_attribute_uid, tableDatas=tableDatas)