HYTOS

VisualStudioVersion = 15.0.27130.2027

<<<<<<< HEAD

=======

		{B7B8B0AE-9F03-4543-BC05-813A25E9D584}.Debug|x64.ActiveCfg = Debug|x64

		{B7B8B0AE-9F03-4543-BC05-813A25E9D584}.Debug|x64.Build.0 = Debug|x64

>>>>>>> ca32c11aca77cf342b602a9cca577d5a8dd0584c

        self._hmbTable = None

                sql = 'SELECT UID,RED,GREEN,BLUE FROM Colors'

                    self._colors.append(Color(int(row[0]), int(row[1]), int(row[2]), int(row[3])))

        @brief      getter of hmb table

        @author     humkyung

        @date       2018.07.16

    '''

    @property

    def hmbTable(self):

        from HMBTable import HMBTable

        if self._hmbTable is None:

            self._hmbTable = HMBTable()

            self._hmbTable.loadData()

        return self._hmbTable

    '''

        @brief      setter of hmb table

        @author     humkyung

        @date       2018.07.16

    '''

    @hmbTable.setter

    def hmbTable(self, value):

        self._hmbTable = value

    '''

                    humkyung 2018.07.09 make drawing folder if not exists

        drawingPath = project.getDrawingFilePath()

        if not os.path.exists(drawingPath):

            os.makedirs(drawingPath)

        @brief      get NominalDiameter

                    kyouho 2018.07.16 edit query order by code

    def getNomialPipeSizeData(self, forCheckLineNumber = False, orderStr = "CODE"):

            sql = "select Code,Metric,Inch,InchStr,MetricStr from NominalDiameter ORDER BY {} ASC".format(orderStr)

                pipeSize = NominalPipeSize(row[0], float(row[1]) if row[1] is not None else None, float(row[2]) if row[2] is not None else None, row[3], row[4])

        @brief      insert NominalDiameter table

        @date       2018.07.16

    def insertNomialPipeSize(self, pipeSizes):

            sql = "INSERT INTO NominalDiameter(Code, Metric, Inch, InchStr, MetricStr) VALUES(?,?,?,?,?)"

            for pipeSize in pipeSizes:

                param = (pipeSize.code, pipeSize.metric, pipeSize.inch, pipeSize.inchStr, pipeSize.metricStr)

                cursor.execute(sql, param)

            conn.commit()

        @brief      delete NominalDiameter table

        @date       2018.07.16

    def deleteNomialPipeSize(self):

            dbPath = self.getCurrentProject().getPath() + "/db/ITI_PID.db"

            sql = "DELETE FROM NominalDiameter"

            try:

                cursor.execute(sql)

                conn.commit()

            except Exception as ex:

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

        @brief      convert inch to metric

    def convertInchToMetric(self, inch):

        result = ''

            sql = "select MetricStr from NominalDiameter WHERE InchStr = ?"

            param = (inch,)

            cursor.execute(sql, param)

            rows = cursor.fetchall()

            if rows:

                result = rows[0][0]

        @brief      get Symbol Attribute

        @date       2018.07.18

    def checkAttribute(self, attr):

            sql = 'select attribute from SymbolAttribute where Attribute = ?'

            param = (attr,)

            cursor.execute(sql, param)

            rows = cursor.fetchall()

            if len(rows):

                return True

            else:

                return False

            # Catch the exception

        except Exception as ex:

            # Roll back any change if something goes wrong

            conn.rollback()

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

        finally:

            # Close the db connection

            conn.close()

        return False

    '''

        @brief      get Symbol Attribute

        @author     kyouho

        @date       2018.07.18

    '''

    def getSymbolAttribute(self, _type):

        result = []

        try:

            # Creates or opens a file called mydb with a SQLite3 DB

            dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), 'ITI_PID.db')

            conn = sqlite3.connect(dbPath)

            # Get a cursor object

            cursor = conn.cursor()

            sql = 'select a.attribute from SymbolAttribute a inner join SymbolType t on a.SymbolType = t.id and t.type = ? order by attribute'

            param = (_type,)

            cursor.execute(sql, param)

            rows = cursor.fetchall()

            for row in rows:

                result.append(row[0])

            # Catch the exception

        except Exception as ex:

            # Roll back any change if something goes wrong

            conn.rollback()

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

        finally:

            # Close the db connection

            conn.close()

        return result

    '''

        @brief      get Code Table Data

        @author     kyouho

        @date       2018.07.10

    '''

    def getCodeTable(self, property, forCheckLineNumber = False):

        result = []

        try:

            # Creates or opens a file called mydb with a SQLite3 DB

            dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), 'ITI_PID.db')

            conn = sqlite3.connect(dbPath)

            # Get a cursor object

            cursor = conn.cursor()

            sql = 'select uid, code, description from {} order by length(code) DESC'.format(property)

            cursor.execute(sql)

            rows = cursor.fetchall()

            for row in rows:

                if forCheckLineNumber:

                    data = row[1]

                else:

                    data = (row[0], row[1], row[2])

                result.append(data)

            # Catch the exception

        except Exception as ex:

            # Roll back any change if something goes wrong

            conn.rollback()

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

        finally:

            # Close the db connection

            conn.close()

        return result

    '''

        @brief      Set Common Code Data

        @author     kyouho

        @date       2018.07.12

    '''

    def setCommonCodeData(self, tableName, datas):

        try:

            # Creates or opens a file called mydb with a SQLite3 DB

            dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), 'ITI_PID.db')

            conn = sqlite3.connect(dbPath)

            # Get a cursor object

            cursor = conn.cursor()

            for data in datas:

                uid = data[0]

                    sql = "insert or replace into {}(UID, CODE, DESCRIPTION) values(lower(hex(randomblob(16))), ?, ?)".format(tableName)

                    param = (data[1], data[2])

                    sql = "update {} SET CODE=?, DESCRIPTION=? WHERE UID = ?".format(tableName)

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

            conn.commit()

        # Catch the exception

        except Exception as ex:

            # Roll back any change if something goes wrong

            conn.rollback()

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

        finally:

            # Close the db connection

            conn.close()

    '''

        @brief      Set Common Code Data

        @author     kyouho

        @date       2018.07.12

    '''

    def deleteCommonCodeData(self, datas):

        try:

            # Creates or opens a file called mydb with a SQLite3 DB

            dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), 'ITI_PID.db')

            conn = sqlite3.connect(dbPath)

            # Get a cursor object

            cursor = conn.cursor()

            for data in datas:

                uid = data[0]

                tableName = data[1]

                    sql = "delete from {} where UID = ?".format(tableName)

                cursor.execute(sql, param)

# coding: utf-8

import os

import sys

from PyQt5.QtCore import *

from PyQt5.QtGui import *

from PyQt5.QtWidgets import *

import sqlite3

from AppDocData import AppDocData

from AppDocData import Config

import CodeTable_UI

class QCodeTableDialog(QDialog):

    def __init__(self, parent):

        QDialog.__init__(self, parent)

        self.removeUID = {}

        self.currentCode = {}

        self.ui = CodeTable_UI.Ui_CodeTableDialog()

        self.ui.setupUi(self)

        #DB Table명 기준으로 작성

        self.settingTable("Nominal Diameter")

        self.settingTable("Fluid Code")

        self.settingTable("Insulation Purpose")

        self.settingTable("PnID Number")

        self.settingTable("Piping Materials Class")

        self.settingTable("Unit Number")

    '''

        @brief      Setting Table

        @author     kyouho

        @date       2018.07.10

    '''

    def settingTable(self, tableName):

        try:

            tableName = self.replaceText(tableName)

            docData = AppDocData.instance()

            table = self.findTableWidget(tableName)

            if tableName == "NominalDiameter":

                tableDatas = docData.getNomialPipeSizeData()

            else:

                tableDatas = docData.getCodeTable(tableName)

            if tableName == "NominalDiameter":

                self.insertTableWidgetNominalPipeSizeRow(tableDatas)

                table.cellChanged.connect(self.cellValueChanged)

                self.checkRowAndAddRow(tableName, table)

            else:

                table.setColumnCount(3)

                table.setHorizontalHeaderLabels(['uid', 'Code', 'Desc.'])

                table.hideColumn(0)

                self.insertTableWidgetCommonRow(table, tableDatas)

                table.horizontalHeaderItem(1).setSizeHint(QSize(30, 30))

                table.cellChanged.connect(self.cellValueChanged)

                self.checkRowAndAddRow(tableName, table)

                self.setCurrentCode(table, tableName)

        except Exception as ex:

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

    '''

        @brief      Insert row NominalPipeSzie Tablewidget

        @author     kyouho

        @date       2018.07.10

    '''

    def insertTableWidgetNominalPipeSizeRow(self, pipeSizes):

        try:

            self.ui.tableWidgetNominalDiameter.setColumnCount(5)

            self.ui.tableWidgetNominalDiameter.setHorizontalHeaderLabels(['Code', 'Metric', 'Inch', 'InchStr', 'MetricStr'])

            self.ui.tableWidgetNominalDiameter.setRowCount(len(pipeSizes))

            row = 0

            for pipeSize in pipeSizes:

                self.ui.tableWidgetNominalDiameter.setItem(row, 0, QTableWidgetItem(pipeSize.code))

                self.ui.tableWidgetNominalDiameter.setItem(row, 1, QTableWidgetItem('' if pipeSize.metric is None else str(pipeSize.metric)))

                self.ui.tableWidgetNominalDiameter.setItem(row, 2, QTableWidgetItem('' if pipeSize.inch is None else str(pipeSize.inch)))

                self.ui.tableWidgetNominalDiameter.setItem(row, 3, QTableWidgetItem('' if pipeSize.inchStr is None else pipeSize.inchStr))

                self.ui.tableWidgetNominalDiameter.setItem(row, 4, QTableWidgetItem('' if pipeSize.metricStr is None else pipeSize.metricStr))

                row += 1

            self.ui.tableWidgetNominalDiameter.horizontalHeaderItem(0).setSizeHint(QSize(30, 30))

        except Exception as ex:

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

    '''

        @brief      Insert row Common Tablewidget

        @author     kyouho

        @date       2018.07.10

    '''

    def insertTableWidgetCommonRow(self, table, tableDatas):

        try:

            table.setRowCount(len(tableDatas))

            row = 0

            for tableData in tableDatas:

                table.setItem(row, 0, QTableWidgetItem(tableData[0]))

                table.setItem(row, 1, QTableWidgetItem(tableData[1]))

                table.setItem(row, 2, QTableWidgetItem(tableData[2]))

                row += 1

        except Exception as ex:

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

    '''

        @brief      Find TableWidget with Name

        @author     kyouhokyouho

        @date       2018.07.10

    '''

    def findTableWidget(self, tableName):

        tableName = self.replaceText(tableName)

        return self.findChild(QTableWidget, 'tableWidget' + tableName)

    '''

        @brief      key press event

        @author     kyouho

        @date       2018.07.10

    '''

    def keyPressEvent(self, e):

        try:

            if e.key() == Qt.Key_Delete:

                _tabWidget = self.ui.tabWidget

                currentTabIndex = _tabWidget.currentIndex()

                tabText = self.replaceText(_tabWidget.tabText(currentTabIndex))

                table = self.findTableWidget(tabText)

                if table:

                    selectedIndexes = table.selectedIndexes()

                    selectedRows = [item.row() for item in selectedIndexes]

                    model = table.model()

                    rowsIndex = []

                    for row in selectedRows:

                        rowsIndex.append(row)

                    #중복 제거

                    rowsIndex = list(set(rowsIndex))

                    rowsIndex.reverse()

                    if tabText != "NominalDiameter":

                        for row in rowsIndex:

                            uid = table.item(row, 0).text()

                            self.removeUID[uid] = tabText

                            model.removeRow(row)

                        self.checkRowAndAddRow(tabText, table)

        except Exception as ex:

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

    '''

        @brief      Add new row

        @author     kyouho

        @date       2018.07.10

    '''

    def checkRowAndAddRow(self, tableName, table):

        try:

            rowCount = table.rowCount()

            result = True

            if tableName != "NominalDiameter":

                for row in range(rowCount):

                    code = table.item(row, 1).text()

                    if not code:

                        result = False

                if result:

                    table.cellChanged.disconnect(self.cellValueChanged)

                    table.setRowCount(rowCount + 1)

                    table.setItem(rowCount, 0, QTableWidgetItem(''))

                    table.setItem(rowCount, 1, QTableWidgetItem(''))

                    table.setItem(rowCount, 2, QTableWidgetItem(''))

                    table.cellChanged.connect(self.cellValueChanged)

            else:

                columnCount = table.columnCount()

                for row in range(rowCount):

                    if not result:

                        break

                    for columnIndex in range(columnCount):

                        if not table.item(row, columnIndex).text():

                            result = False

                            break

                if result:

                    table.setRowCount(rowCount + 1)

                    table.cellChanged.disconnect(self.cellValueChanged)

                    for columnIndex in range(columnCount):

                        table.setItem(rowCount, columnIndex, QTableWidgetItem(''))    

                    table.cellChanged.connect(self.cellValueChanged)

        except Exception as ex:

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

    '''

        @brief      cellValueChange event

        @author     kyouho

        @date       2018.07.10

    '''

    def cellValueChanged(self, row, column):

        try:

            _tabWidget = self.ui.tabWidget

            currentTabIndex = _tabWidget.currentIndex()

            tabText = self.replaceText(_tabWidget.tabText(currentTabIndex))

            table = self.findTableWidget(tabText)

            if tabText != "NominalDiameter":

                item = table.item(row, 1)

                code = item.text()

                if column == 1:

                    result = self.isExistCode(table, code)

                    if result:

                        self.checkRowAndAddRow(tabText, table)

                        self.setCurrentCode(table, tabText)

                    else:

                        item.setText(self.currentCode[tabText][row])

                else:

                    table.resizeColumnToContents(2)

            else:

                self.checkRowAndAddRow(tabText, table)

        except Exception as ex:

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

    '''

        @brief      Check  Duplicate Code 

        @author     kyouho

        @date       2018.07.10

    '''

    def isExistCode(self, table, editCode):

        try:

            if not editCode:

                return False

            rowCount = table.rowCount()

            codes = []

            for row in range(rowCount):

                code = table.item(row, 1).text()

                codes.append(code)

            count = codes.count(editCode)

            if count >=2:

                return False

            else:

                return True

        except Exception as ex:

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

    '''

        @brief      save current Code (self.currentCode)

        @author     kyouho

        @date       2018.07.10

    '''

    def setCurrentCode(self, table, tabText):

        try:

            self.currentCode[tabText] = {}

            rowCount = table.rowCount()

            res = {}

            for row in range(rowCount):

                code = table.item(row, 1).text()

                res[row] = code

            self.currentCode[tabText] = res

        except Exception as ex:

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

    '''

        @brief      replaceTextForCodeTable

        @author     kyouho

        @date       2018.07.12

    '''

    def replaceText(self, text):

        return text.replace(' ','').replace('&&', 'n')

    '''

        @brief      save codes

        @author     kyouho

        @date       2018.07.12

    '''

    def accept(self):

        self.saveCommonCodeData("Fluid Code")

        self.saveCommonCodeData("Insulation Purpose")

        self.saveCommonCodeData("PnID Number")

        self.saveCommonCodeData("Piping Materials Class")

        self.saveCommonCodeData("Unit Number")

        self.deleteCommonCodeData()

        self.saveNomialPipeSize()

        QDialog.accept(self)

    '''

        @brief      save common code data

        @author     kyouho

        @date       2018.07.12

    '''

    def saveCommonCodeData(self, tableName):

        datas = []

        try:

            tableName = self.replaceText(tableName)

            table = self.findTableWidget(tableName)

            rowCount = table.rowCount()

            for row in range(rowCount):

                uid = table.item(row, 0).text()

                code = table.item(row, 1).text()

                description = table.item(row, 2).text()

                if code:

                    datas.append((uid, code, description))

            docData = AppDocData.instance()

            docData.setCommonCodeData(tableName, datas)

        except Exception as ex:

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

    '''

        @brief      save common code data

        @author     kyouho

        @date       2018.07.12

    '''

    def deleteCommonCodeData(self):

        try:

            datas = self.removeUID.items()

            docData = AppDocData.instance()

            docData.deleteCommonCodeData(datas)

        except Exception as ex:

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

    '''

        @brief      save common code data

        @author     kyouho

        @date       2018.07.16

    '''

    def saveNomialPipeSize(self):

        pipeSizes = []

        try:

            docData = AppDocData.instance()

            self.deleteNomialPipeSize()

            from AppDocData import NominalPipeSize

            table = self.ui.tableWidgetNominalDiameter

            rowCount = table.rowCount()

            for row in range(rowCount):

                code = table.item(row, 0).text()

                metric = table.item(row, 1).text()

                inch = table.item(row, 2).text()

                inchStr = table.item(row, 3).text()

                metricStr = table.item(row, 4).text()

                pipeSize = NominalPipeSize(code, float(metric) if metric != '' else None, float(inch) if inch != '' else None, inchStr, metricStr)

                pipeSizes.append(pipeSize)

            docData.insertNomialPipeSize(pipeSizes)

        except Exception as ex:

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

    '''

        @brief      save common code data

        @author     kyouho

        @date       2018.07.16

    '''

    def deleteNomialPipeSize(self):

        docData = AppDocData.instance()

        docData.deleteNomialPipeSize()

# -*- coding: utf-8 -*-

# Form implementation generated from reading ui file './UI/CodeTable.ui'

#

# Created by: PyQt5 UI code generator 5.9.2

#

# WARNING! All changes made in this file will be lost!

from PyQt5 import QtCore, QtGui, QtWidgets

class Ui_CodeTableDialog(object):

    def setupUi(self, CodeTableDialog):

        CodeTableDialog.setObjectName("CodeTableDialog")

        CodeTableDialog.resize(550, 589)

        font = QtGui.QFont()

        font.setFamily("맑은 고딕")

        CodeTableDialog.setFont(font)

        CodeTableDialog.setModal(True)

        self.gridLayout = QtWidgets.QGridLayout(CodeTableDialog)

        self.gridLayout.setObjectName("gridLayout")

        self.buttonBox = QtWidgets.QDialogButtonBox(CodeTableDialog)

        self.buttonBox.setOrientation(QtCore.Qt.Horizontal)

        self.buttonBox.setStandardButtons(QtWidgets.QDialogButtonBox.Cancel|QtWidgets.QDialogButtonBox.Ok)

        self.buttonBox.setObjectName("buttonBox")

        self.gridLayout.addWidget(self.buttonBox, 4, 0, 1, 1)

        self.tabWidget = QtWidgets.QTabWidget(CodeTableDialog)

        self.tabWidget.setObjectName("tabWidget")

        self.tabNominalDiameter = QtWidgets.QWidget()

        self.tabNominalDiameter.setObjectName("tabNominalDiameter")

        self.gridLayout_4 = QtWidgets.QGridLayout(self.tabNominalDiameter)

        self.gridLayout_4.setObjectName("gridLayout_4")

        self.verticalLayout = QtWidgets.QVBoxLayout()

        self.verticalLayout.setObjectName("verticalLayout")

        self.groupBox = QtWidgets.QGroupBox(self.tabNominalDiameter)

        self.groupBox.setObjectName("groupBox")

        self.gridLayout_13 = QtWidgets.QGridLayout(self.groupBox)

        self.gridLayout_13.setObjectName("gridLayout_13")

        self.tableWidgetNominalDiameter = QtWidgets.QTableWidget(self.groupBox)

        self.tableWidgetNominalDiameter.setColumnCount(4)

        self.tableWidgetNominalDiameter.setObjectName("tableWidgetNominalDiameter")

        self.tableWidgetNominalDiameter.setRowCount(0)

        self.tableWidgetNominalDiameter.verticalHeader().setVisible(False)

        self.gridLayout_13.addWidget(self.tableWidgetNominalDiameter, 0, 0, 1, 1)

        self.verticalLayout.addWidget(self.groupBox)

        self.gridLayout_4.addLayout(self.verticalLayout, 0, 0, 1, 1)

        self.tabWidget.addTab(self.tabNominalDiameter, "")

        self.tabFluidCode = QtWidgets.QWidget()

        self.tabFluidCode.setObjectName("tabFluidCode")

        self.gridLayout_3 = QtWidgets.QGridLayout(self.tabFluidCode)

        self.gridLayout_3.setObjectName("gridLayout_3")

        self.gridLayout_2 = QtWidgets.QGridLayout()

        self.gridLayout_2.setObjectName("gridLayout_2")

        self.groupBox_2 = QtWidgets.QGroupBox(self.tabFluidCode)

        self.groupBox_2.setObjectName("groupBox_2")

        self.gridLayout_14 = QtWidgets.QGridLayout(self.groupBox_2)

        self.gridLayout_14.setObjectName("gridLayout_14")

        self.tableWidgetFluidCode = QtWidgets.QTableWidget(self.groupBox_2)

        self.tableWidgetFluidCode.setColumnCount(3)

        self.tableWidgetFluidCode.setObjectName("tableWidgetFluidCode")

        self.tableWidgetFluidCode.setRowCount(0)

        self.tableWidgetFluidCode.verticalHeader().setVisible(False)

        self.gridLayout_14.addWidget(self.tableWidgetFluidCode, 0, 0, 1, 1)

        self.gridLayout_2.addWidget(self.groupBox_2, 0, 0, 1, 1)

        self.gridLayout_3.addLayout(self.gridLayout_2, 0, 0, 1, 1)

        self.tabWidget.addTab(self.tabFluidCode, "")

        self.tabInsulationPurpose = QtWidgets.QWidget()

        self.tabInsulationPurpose.setObjectName("tabInsulationPurpose")

        self.gridLayout_6 = QtWidgets.QGridLayout(self.tabInsulationPurpose)

        self.gridLayout_6.setObjectName("gridLayout_6")

        self.gridLayout_5 = QtWidgets.QGridLayout()

        self.gridLayout_5.setObjectName("gridLayout_5")

        self.groupBox_3 = QtWidgets.QGroupBox(self.tabInsulationPurpose)

        self.groupBox_3.setObjectName("groupBox_3")

        self.gridLayout_15 = QtWidgets.QGridLayout(self.groupBox_3)

        self.gridLayout_15.setObjectName("gridLayout_15")

        self.tableWidgetInsulationPurpose = QtWidgets.QTableWidget(self.groupBox_3)

        self.tableWidgetInsulationPurpose.setColumnCount(3)

        self.tableWidgetInsulationPurpose.setObjectName("tableWidgetInsulationPurpose")

        self.tableWidgetInsulationPurpose.setRowCount(0)

        self.tableWidgetInsulationPurpose.verticalHeader().setVisible(False)

        self.gridLayout_15.addWidget(self.tableWidgetInsulationPurpose, 0, 0, 1, 1)

        self.gridLayout_5.addWidget(self.groupBox_3, 0, 0, 1, 1)

        self.gridLayout_6.addLayout(self.gridLayout_5, 0, 0, 1, 1)

        self.tabWidget.addTab(self.tabInsulationPurpose, "")

        self.tabPnIDNumber = QtWidgets.QWidget()

        self.tabPnIDNumber.setObjectName("tabPnIDNumber")

        self.gridLayout_10 = QtWidgets.QGridLayout(self.tabPnIDNumber)

        self.gridLayout_10.setObjectName("gridLayout_10")

        self.gridLayout_9 = QtWidgets.QGridLayout()

        self.gridLayout_9.setObjectName("gridLayout_9")

        self.groupBox_4 = QtWidgets.QGroupBox(self.tabPnIDNumber)

        self.groupBox_4.setObjectName("groupBox_4")

        self.gridLayout_16 = QtWidgets.QGridLayout(self.groupBox_4)

        self.gridLayout_16.setObjectName("gridLayout_16")

        self.tableWidgetPnIDNumber = QtWidgets.QTableWidget(self.groupBox_4)

        self.tableWidgetPnIDNumber.setColumnCount(3)

        self.tableWidgetPnIDNumber.setObjectName("tableWidgetPnIDNumber")

        self.tableWidgetPnIDNumber.setRowCount(0)

        self.tableWidgetPnIDNumber.verticalHeader().setVisible(False)

        self.gridLayout_16.addWidget(self.tableWidgetPnIDNumber, 0, 0, 1, 1)

        self.gridLayout_9.addWidget(self.groupBox_4, 0, 0, 1, 1)

        self.gridLayout_10.addLayout(self.gridLayout_9, 0, 0, 1, 1)

        self.tabWidget.addTab(self.tabPnIDNumber, "")

        self.tabPipingMaterialsClass = QtWidgets.QWidget()

        self.tabPipingMaterialsClass.setObjectName("tabPipingMaterialsClass")

        self.gridLayout_8 = QtWidgets.QGridLayout(self.tabPipingMaterialsClass)

        self.gridLayout_8.setObjectName("gridLayout_8")

        self.gridLayout_7 = QtWidgets.QGridLayout()

        self.gridLayout_7.setObjectName("gridLayout_7")

        self.groupBox_5 = QtWidgets.QGroupBox(self.tabPipingMaterialsClass)

        self.groupBox_5.setObjectName("groupBox_5")

        self.gridLayout_17 = QtWidgets.QGridLayout(self.groupBox_5)

        self.gridLayout_17.setObjectName("gridLayout_17")

        self.tableWidgetPipingMaterialsClass = QtWidgets.QTableWidget(self.groupBox_5)

        self.tableWidgetPipingMaterialsClass.setColumnCount(3)

        self.tableWidgetPipingMaterialsClass.setObjectName("tableWidgetPipingMaterialsClass")

        self.tableWidgetPipingMaterialsClass.setRowCount(0)

        self.tableWidgetPipingMaterialsClass.verticalHeader().setVisible(False)

        self.gridLayout_17.addWidget(self.tableWidgetPipingMaterialsClass, 0, 0, 1, 1)

        self.gridLayout_7.addWidget(self.groupBox_5, 0, 0, 1, 1)

        self.gridLayout_8.addLayout(self.gridLayout_7, 0, 0, 1, 1)

        self.tabWidget.addTab(self.tabPipingMaterialsClass, "")

        self.tabUnitNumber = QtWidgets.QWidget()

        self.tabUnitNumber.setObjectName("tabUnitNumber")

        self.gridLayout_12 = QtWidgets.QGridLayout(self.tabUnitNumber)

        self.gridLayout_12.setObjectName("gridLayout_12")

        self.gridLayout_11 = QtWidgets.QGridLayout()

        self.gridLayout_11.setObjectName("gridLayout_11")

        self.groupBox_6 = QtWidgets.QGroupBox(self.tabUnitNumber)

        self.groupBox_6.setObjectName("groupBox_6")

        self.gridLayout_18 = QtWidgets.QGridLayout(self.groupBox_6)

        self.gridLayout_18.setObjectName("gridLayout_18")

        self.tableWidgetUnitNumber = QtWidgets.QTableWidget(self.groupBox_6)

        self.tableWidgetUnitNumber.setColumnCount(3)

        self.tableWidgetUnitNumber.setObjectName("tableWidgetUnitNumber")

        self.tableWidgetUnitNumber.setRowCount(0)

        self.tableWidgetUnitNumber.verticalHeader().setVisible(False)

        self.gridLayout_18.addWidget(self.tableWidgetUnitNumber, 0, 0, 1, 1)

        self.gridLayout_11.addWidget(self.groupBox_6, 0, 0, 1, 1)

        self.gridLayout_12.addLayout(self.gridLayout_11, 0, 0, 1, 1)

        self.tabWidget.addTab(self.tabUnitNumber, "")

        self.gridLayout.addWidget(self.tabWidget, 0, 0, 1, 1)

        self.retranslateUi(CodeTableDialog)

        self.tabWidget.setCurrentIndex(0)

        self.buttonBox.accepted.connect(CodeTableDialog.accept)

        self.buttonBox.rejected.connect(CodeTableDialog.reject)

        QtCore.QMetaObject.connectSlotsByName(CodeTableDialog)

    def retranslateUi(self, CodeTableDialog):

        _translate = QtCore.QCoreApplication.translate

        CodeTableDialog.setWindowTitle(_translate("CodeTableDialog", "Code Table"))

        self.groupBox.setTitle(_translate("CodeTableDialog", "Nominal Diameter"))

        self.tabWidget.setTabText(self.tabWidget.indexOf(self.tabNominalDiameter), _translate("CodeTableDialog", "Nominal Diameter"))

        self.groupBox_2.setTitle(_translate("CodeTableDialog", "Fluid Code"))

        self.tabWidget.setTabText(self.tabWidget.indexOf(self.tabFluidCode), _translate("CodeTableDialog", "Fluid Code"))

        self.groupBox_3.setTitle(_translate("CodeTableDialog", "Insulation Purpose"))

        self.tabWidget.setTabText(self.tabWidget.indexOf(self.tabInsulationPurpose), _translate("CodeTableDialog", "Insulation Purpose"))

        self.groupBox_4.setTitle(_translate("CodeTableDialog", "P&&ID Number"))

        self.tabWidget.setTabText(self.tabWidget.indexOf(self.tabPnIDNumber), _translate("CodeTableDialog", "P&&ID Number"))

        self.groupBox_5.setTitle(_translate("CodeTableDialog", "Piping Materials Class"))

        self.tabWidget.setTabText(self.tabWidget.indexOf(self.tabPipingMaterialsClass), _translate("CodeTableDialog", "Piping Materials Class"))

        self.groupBox_6.setTitle(_translate("CodeTableDialog", "Unit Number"))

        self.tabWidget.setTabText(self.tabWidget.indexOf(self.tabUnitNumber), _translate("CodeTableDialog", "Unit Number"))

if __name__ == "__main__":

    import sys

    app = QtWidgets.QApplication(sys.argv)

    CodeTableDialog = QtWidgets.QDialog()

    ui = Ui_CodeTableDialog()

    ui.setupUi(CodeTableDialog)

    CodeTableDialog.show()

    sys.exit(app.exec_())

import sys

import os.path

import AbstractCommand

try:

    from PyQt5.QtCore import Qt, QRectF, pyqtSignal, QT_VERSION_STR, QEvent

    from PyQt5.QtGui import QImage, QPixmap, QPainterPath, QCursor, QMouseEvent, QTransform

    from PyQt5.QtWidgets import QGraphicsView, QGraphicsScene, QFileDialog, QApplication

except ImportError:

    try:

        from PyQt4.QtCore import Qt, QRectF, pyqtSignal, QT_VERSION_STR, QEvent

        from PyQt4.QtGui import QGraphicsView, QGraphicsScene, QImge, QPixmap, QPainterPath, QFileDialog, QCursor, QMouseEvent

    except ImportError:

        raise ImportError("ImageViewerQt: Requires PyQt5 or PyQt4.")

sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.realpath(__file__))) + '\\Shapes')

from SymbolSvgItem import SymbolSvgItem

from AppDocData import AppDocData

import symbol

'''

    @brief      QtImageViewer Copy Symbol Command

    @author     kyouho

    @date       18.07.27

'''

class CopySymbolCommand(AbstractCommand.AbstractCommand):

    def __init__(self, imageViewer):

        super(CopySymbolCommand, self).__init__(imageViewer)

        self.name = 'CopySymbol'

        QApplication.instance().setOverrideCursor(QCursor(Qt.DragCopyCursor))

        # create symbol

        svgFileName = self.imageViewer.copySymbol.name

        self.symbol = self.imageViewer.createSymbolObject(svgFileName)

        self.imageViewer.scene.addItem(self.symbol)

    '''

        @brief      Select Attribuew

        @author     kyouho

        @date       18.07.19

    '''

    def execute(self, param):

        event = param[1]

        scenePos = param[2]

        if 'mouseReleaseEvent' == param[0] and event.button() == Qt.LeftButton:

            transform = QTransform()

            transform.translate(scenePos.x(), scenePos.y())

            self.symbol.setTransform(transform)

            self.imageViewer.scene.removeItem(self.symbol)

            self.imageViewer.matchSymbolToLine(self.symbol, scenePos)

        elif 'mouseMoveEvent' == param[0]:

            transform = QTransform()

            transform.translate(scenePos.x() - self.symbol.symbolOrigin[0], scenePos.y() - self.symbol.symbolOrigin[1])

            self.symbol.setTransform(transform)

        self.isTreated = True

    def undo(self):

        pass

    def redo(self):

        pass

    '''

        @brief      Find TextItem contain Point

        @author     kyouho

        @date       18.07.19

    '''

    def findTextItemInPoint(self, point):

        from QEngineeringTextItem import QEngineeringTextItem

        for item in self.imageViewer.items():

            if type(item) is QEngineeringTextItem:

                if self.isOverlapItemAndPoint(item, point):

                    return (True, item)

        return (False,)

    '''

        @brief      Check Overlap

        @author     kyouho

        @date       18.07.17

    '''

    def isOverlapItemAndPoint(self, item, point):

        x = point.x()

        y = point.y()

        loc = item.loc

        size = item.size

        if loc[0] <= x and loc[0] + size[0] >= x and loc[1] <= y and loc[1] + size[1] >= y:

            return True

        else:

            return False

                            svg.transfer.onRemoved.connect(self.resultTreeWidget.itemRemoved)

    onSuccess = pyqtSignal(float, float, float, float)

        self._vertices = []

        self.startX = 0

        self.startY = 0

        self.isClicked = False

        elif 'mousePressEvent' == param[0] and event.button() == Qt.LeftButton:

            self.imageViewer.setDragMode(QGraphicsView.RubberBandDrag)

            self.startX = scenePos.x()

            self.startY = scenePos.y()

            self._vertices.clear()

            self._vertices.append(param[2])

            self.isClicked = True

        elif 'mouseReleaseEvent' == param[0] and event.button() == Qt.LeftButton:

            try:

                QGraphicsView.mouseReleaseEvent(self.imageViewer, event)

                self._vertices.append(param[2])

            finally:

                self.imageViewer.setDragMode(QGraphicsView.NoDrag)

                x = min(self._vertices[0].x(), self._vertices[1].x())

                y = min(self._vertices[0].y(), self._vertices[1].y())

                width = abs(self._vertices[0].x() - self._vertices[1].x())

                height = abs(self._vertices[0].y() - self._vertices[1].y())

                self.onSuccess.emit(x, y, width, height)

                self.isClicked = False

                pass

        elif self.isClicked and 'mouseMoveEvent' == param[0]:

            endX = scenePos.x()

            endY = scenePos.y()

            if self.startX > endX and self.startY > endY:

                self.imageViewer.setRubberBandSelectionMode(Qt.ContainsItemShape)

            else:

                self.imageViewer.setRubberBandSelectionMode(Qt.IntersectsItemShape)

import os.path

import AbstractCommand

try:

    from PyQt5.QtCore import Qt, QPointF, QRectF, pyqtSignal, QT_VERSION_STR

    from PyQt5.QtGui import QImage, QPixmap, QPainterPath, QCursor, QTransform

    from PyQt5.QtWidgets import QGraphicsView, QGraphicsScene, QFileDialog

except ImportError:

    try:

        from PyQt4.QtCore import Qt, QRectF, pyqtSignal, QT_VERSION_STR

        from PyQt4.QtGui import QGraphicsView, QGraphicsScene, QImage, QPixmap, QPainterPath, QFileDialog, QCursor

    except ImportError:

        raise ImportError("ImageViewerQt: Requires PyQt5 or PyQt4.")

class PlaceLineCommand(AbstractCommand.AbstractCommand):

    onSuccess = pyqtSignal()

    onRejected = pyqtSignal(AbstractCommand.AbstractCommand)

    def __init__(self, imageViewer):

        super(PlaceLineCommand, self).__init__(imageViewer)

        self.name = 'PlaceLine' 

        self.imageViewer.setCursor(QCursor(Qt.CrossCursor))

        self._polyline = None

    '''

        @brief      reset command status

        @author     humkyung

        @date       2018.07.23

    '''

    def reset(self):

        self._polyline = None

    '''

        @brief      place a line

        @author     humkyung

        @date       2018.07.23

    '''

    def execute(self, param):

        import shapely

        from EngineeringConnectorItem import QEngineeringConnectorItem

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringPolylineItem import QEngineeringPolylineItem

        from EngineeringLineItem import QEngineeringLineItem

        event = param[1]

        if 'mousePressEvent' == param[0] and event.button() == Qt.LeftButton:

            if self._polyline is None:

                selected = self.imageViewer.scene.itemAt(param[2], QTransform())

                if selected is not None and type(selected) is QEngineeringConnectorItem:

                    self._polyline = QEngineeringPolylineItem()

                    self._polyline._vertices.append(selected.center())

                    self.imageViewer.scene.addItem(self._polyline)

                    self.imageViewer.scene.setFocusItem(self._polyline)

                elif selected is not None and type(selected) is QEngineeringLineItem:

                    length = selected.length()*0.5

                    dir = selected.perpendicular()

                    start = [param[2].x() - dir[0]*length, param[2].y() - dir[1]*length]

                    end = [param[2].x() + dir[0]*length, param[2].y() + dir[1]*length]

                    pt = selected.intersection([start, end])

                    if (pt is not None) and (type(pt) == shapely.geometry.point.Point):

                        self._polyline = QEngineeringPolylineItem()

                        self._polyline._vertices.append([pt.x, pt.y])

                        self.imageViewer.scene.addItem(self._polyline)

                        self.imageViewer.scene.setFocusItem(self._polyline)

            else:

                try:

                    QGraphicsView.mouseReleaseEvent(self.imageViewer, event)

                    self._polyline._vertices.append(self._polyline._pt)

                    self._polyline.update()

                finally:

                    pass

        elif 'mouseReleaseEvent' == param[0] and event.button() == Qt.RightButton and self._polyline is not None:

            self.onSuccess.emit()

        elif 'mouseMoveEvent' == param[0] and self._polyline is not None:

            self._polyline.onMouseMoved(event, param[2])

        elif 'keyPressEvent' == param[0]:

            if event.key() == Qt.Key_Escape:

                self.onRejected.emit(self)

        self.isTreated = False

    def undo(self):

        pass

    def redo(self):

        pass

import os.path

import AbstractCommand

try:

    from PyQt5.QtCore import Qt, QRectF, pyqtSignal, QT_VERSION_STR, QEvent

    from PyQt5.QtGui import QImage, QPixmap, QPainterPath, QCursor, QMouseEvent

    from PyQt5.QtWidgets import QGraphicsView, QGraphicsScene, QFileDialog

except ImportError:

    try:

        from PyQt4.QtCore import Qt, QRectF, pyqtSignal, QT_VERSION_STR, QEvent

        from PyQt4.QtGui import QGraphicsView, QGraphicsScene, QImge, QPixmap, QPainterPath, QFileDialog, QCursor, QMouseEvent

    except ImportError:

        raise ImportError("ImageViewerQt: Requires PyQt5 or PyQt4.")

'''

    @brief      QtImageViewer Select Attribute Command

    @author     kyouho

    @date       18.04.10

'''

class SelectAttributeCommand(AbstractCommand.AbstractCommand):

    def __init__(self, imageViewer):

        super(SelectAttributeCommand, self).__init__(imageViewer)

        self.name = 'SelectAttribute'

        self.imageViewer.setCursor(QCursor(Qt.ArrowCursor))

        self.resultItem = None

    '''

        @brief      Select Attribuew

        @author     kyouho

        @date       18.07.19

    '''

    def execute(self, param):

        event = param[1]

        scenePos = param[2]

        if 'mouseReleaseEvent' == param[0] and event.button() == Qt.LeftButton:

            result = self.findTextItemInPoint(scenePos)

            if result[0]:

                self.resultItem = result[1]

        self.isTreated = True

    def undo(self):

        pass

    def redo(self):

        pass

    '''

        @brief      Find TextItem contain Point

        @author     kyouho

        @date       18.07.19

    '''

    def findTextItemInPoint(self, point):

        from QEngineeringTextItem import QEngineeringTextItem

        for item in self.imageViewer.items():

            if type(item) is QEngineeringTextItem:

                if self.isOverlapItemAndPoint(item, point):

                    return (True, item)

        return (False,)

    '''

        @brief      Check Overlap

        @author     kyouho

        @date       18.07.17

    '''

    def isOverlapItemAndPoint(self, item, point):

        x = point.x()

        y = point.y()

        loc = item.loc

        size = item.size

        if loc[0] <= x and loc[0] + size[0] >= x and loc[1] <= y and loc[1] + size[1] >= y:

            return True

        else:

            return False

import EngineeringPolylineItem

from EngineeringLineItem import QEngineeringLineItem

            if prop != "Tag Seq No":

                self.ui.comboBoxColorOption.addItem(prop)

        if len(configs) == 1 and configs[0].value is not None:

        self.setPropertyToggle(self.ui.radioButtonProperty.isChecked())

        self.ui.radioButtonRandom.toggled.connect(self.onPropertyToggled)

    '''

        @brief  Clear Table

        @author kyouho

        @date   2018.07.10

    '''

    def clearColorPropertyTable(self):

        table = self.ui.tableWidgetColorProperty

        model = table.model()

        while table.rowCount():

            model.removeRow(table.rowCount() - 1)

        self.clearColorPropertyTable()

            result = docData.getNomialPipeSizeData(False, "Metric")

            for pipeSize in result:

                if not pipeSize.inchStr or not pipeSize.metricStr:

                    replaceInchStr = pipeSize.inchStr.replace("'", '"')