HYTOS

    """

    This is App class inherits from QApplication

    """

    """

    try:

        import qtmodern.styles

    except ImportError:

        pass

    else:

        qtmodern.styles.darkorange(app)

    """

        dlg = Ui_Dialog()

        selectedProject = dlg.showDialog()

        if selectedProject is not None:

            AppDocData.instance().setCurrentProject(selectedProject)

            AppDocData.instance().ex = exceptionHandler

            app._mainWnd = MainWindow.instance()

            app._mainWnd.show()

            sys.exit(app.exec_())

    '''

        @brief  Set current Project

        @history    2018.06.27  Jeongwoo    If DB file is not, copy DB file from ProgramData

    '''

    def setCurrentProject(self, project):

        self.project = project

        try:

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

            dbPath = os.path.join(self.getCurrentProject().getDbFilePath() , App.NAME + '.db')

            if not os.path.isfile(dbPath):

                templatePath = self.getTemplateDbPath()

                templateFile = QFile(templatePath)

                templateFile.copy(dbPath)

            else:

                try:

                    conn = sqlite3.connect(dbPath)

                    # Get a cursor object

                    cursor = conn.cursor()

                    fileNames = os.listdir(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'Scripts'))

                    for fileName in fileNames:

                        if fileName.endswith(".sql") and (1 == len(os.path.splitext(fileName)[0].split('.'))):

                            try:

                                file = QFile(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'Scripts', fileName))

                                file.open(QFile.ReadOnly)

                                sql = file.readAll()

                                sql = str(sql, encoding='utf8')

                                cursor.executescript(sql)

                            finally:

                                file.close()

                    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))

                finally:

                    conn.close()

        # Catch the exception

        except Exception as ex:

            # Roll back any change if something goes wrong

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

        finally:

            pass

        try:

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

            dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)

            db = sqlite3.connect(dbPath)

            db.row_factory = sqlite3.Row

            # Get a cursor object

            cursor = db.cursor()

            sql = "select UID, Material, Meter, Inch, Feet, Milimeter from Roughness" 

            cursor.execute(sql)

            rows = cursor.fetchall()

            for row in rows:                

                res.append((row[0], row[1], row[2], row[3], row[4], row[5]))

        # Catch the exception

        except Exception as ex:

            # Roll back any change if something goes wrong

            db.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

            db.close()

        try:

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

            dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)

            db = sqlite3.connect(dbPath)

            # Get a cursor object

            cursor = db.cursor()

            sql = "select UID, No from Schedule" 

            cursor.execute(sql)

            rows = cursor.fetchall()

            for row in rows:                

                res.append((row[0], row[1]))

        # Catch the exception

        except Exception as ex:

            # Roll back any change if something goes wrong

            db.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

            db.close()

        return res

        try:

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

            dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)

            db = sqlite3.connect(dbPath)

            # Get a cursor object

            cursor = db.cursor()

            sql = "select UID, Milimeter, Inch from NominalDiameter" 

            cursor.execute(sql)

            rows = cursor.fetchall()

            for row in rows:                

                res.append((row[0], row[1], row[2]))

        # Catch the exception

        except Exception as ex:

            # Roll back any change if something goes wrong

            db.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

            db.close()

        try:

            dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)

            conn = sqlite3.connect(dbPath)

                          , s.Name

                          , t.Category

                          , t.Type

                          , s.OriginalPoint

                          , s.ConnectionPoint

                       from Symbols s

                      inner join SymbolType t

                         on s.SymbolType_UID = t.UID 

                      where """ + "s." + fieldName + '=?'

        finally:

            conn.close()

        try:

            dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)

            conn = sqlite3.connect(dbPath)

                          , s.Name

                          , t.Category

                          , t.Type

                          , s.OriginalPoint

                          , s.ConnectionPoint

                       from Symbols s

                      inner join SymbolType t

                         on s.SymbolType_UID = t.uid 

                      where s.SymbolType_UID = ?"""

        finally:

            conn.close()

        try:

            dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)

            conn = sqlite3.connect(dbPath)

        finally:

            conn.close()

        db_path = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)

        conn = sqlite3.connect(db_path)

    def getDrawingsUnitsByDrawingUID(self, uid):

        try:

            dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)

            conn = sqlite3.connect(dbPath)

            #sql = 'select UID from Components where Drawings_UID = ? order by x desc'

            sql = """select du.Units

                          , u.Value

                       from DrawingsUnits du 

                       left join units u 

                         on du.Units_UID = u.uid

                      where du.drawings_uid = ?"""

                param = (uid, )

                cursor.execute(sql, param)

        finally:

            conn.close()

        try:

            dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)

            conn = sqlite3.connect(dbPath)

        finally:

            conn.close()

        try:

            dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)

            conn = sqlite3.connect(dbPath)

            cursor = conn.cursor()

            sql = """SELECT dn.DISPLAY_NAME

                          , hu.Units_Expression

                       FROM DisplayNames dn

                       left join HMBUnits hu

                         on dn.COLUMN_NAME = Hu.Column_Name

                      where dn.Table_Name = 'HMB'

                      order by dn.[Order]"""    

            try:

                cursor.execute(sql)  

                rows = cursor.fetchall()

                for row in rows:

                    res.append((row[0], row[1])) 

            except Exception as ex:

                from App import App

                message = 'error occured({}) 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)

        finally:

            conn.close()

        try:

            dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)

            conn = sqlite3.connect(dbPath)

            cursor = conn.cursor()

            sql = 'SELECT Category FROM SymbolType WHERE type = "' + type + '"'

            cursor.execute(sql)

            rows = cursor.fetchall()

            if rows is not None and len(rows) > 0:

                category = rows[0][0]

        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))

        finally:

            conn.close()

        unitsList = AppDocData.instance().getDrawingsUnitsByDrawingUID(uid)

            self._hmbTable.loadDataByDrawingUID(self.UID)

        self._flowrate_mass = float(value)

        self._flowrate_volume = float(value)

        self._density = float(value)

        self._viscosity = float(value)

        self._temperature = float(value)

        self._molecular_weight = float(value)

        self._specific_heat_ratio = float(value)

        self._compress_factor = float(value)

        self._nominal_pipe_size = float(value)

        self._inside_pipe_size = float(value)

        self._straight_length = float(value)

        self._equivalent_length = float(value)

        self._roughness = float(value)

        self._limitation_velocity = float(value)

        self._limitation_pressure_drop = float(value)

        self._velocity = float(value)

        self._reynolds = float(value)

        self._friction_factor = float(value)

        self._pressure_drop = float(value)

        self._pressure_drop_friction = float(value)

        self._pressure_drop_static = float(value)

        self._pressure_pipe_end_point = float(value)

        self._power = float(value)

    def loadDataByDrawingUID(self, uid):

        try:

            if self._hmbs is None:

                self._hmbs = []

                appDocData = AppDocData.instance()

                dbPath = os.path.join(appDocData.getCurrentProject().getDbFilePath() , App.NAME + '.db')

                conn = sqlite3.connect(dbPath)

                cursor = conn.cursor()

                sql = """select h.UID

                              , h.Components_UID

                              , h.Stream_No

                              , h.Phase_Type

                              , h.Flowrate_Mass

                              , h.Flowrate_Volume

                              , h.Density

                              , h.Viscosity

                              , h.Temperature

                              , h.Molecular_Weight

                              , h.Specific_Heat_Ratio

                              , h.Compress_Factor

                              , h.Nominal_Pipe_Size

                              , h.Inside_Pipe_Size

                              , h.Schedule_No

                              , h.Straight_Length

                              , h.Equivalent_Length

                              , h.Roughness

                              , h.Limitation_Velocity

                              , h.Limitation_Pressure_Drop

                              , h.Velocity

                              , h.Reynolds

                              , h.Friction_Factor

                              , h.Pressure_Drop

                              , h.Pressure_Drop_Friction

                              , h.Pressure_Drop_Static

                              , h.Pressure_Pipe_End_Point

                              , h.Power

                           from HMB h

                           left join Components c

                             on h.Components_UID = c.UID

                          where c.Drawings_UID = ?

                          order by h.Stream_No"""

                param = (uid, )           

                cursor.execute(sql, param)

                rows = cursor.fetchall()

                for row in rows:

                    hmb = HMBData.fromRow(row)

                    self._hmbs.append(hmb)

        # 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:

            conn.close()

# coding: utf-8

try:

    from PyQt5.QtCore import *

    from PyQt5.QtGui import *

    from PyQt5.QtWidgets import *

except ImportError:

    try:

        from PyQt4.QtCore import *

        from PyQt4.QtGui import *

    except ImportError:

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

import os

import sys

import math

import re

from EngineeringAbstractItem import QEngineeringAbstractItem

from SymbolSvgItem import SymbolSvgItem

from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

from EngineeringNoteItem import QEngineeringNoteItem

from EngineeringTextItem import QEngineeringTextItem

from UserInputAttribute import UserInputAttribute

from EngineeringSpecBreakItem import QEngineeringSpecBreakItem

from EngineeringErrorItem import QEngineeringErrorItem

from SymbolAttr import SymbolAttr

from AppDocData import *

from Drawing import Drawing

from enum import Enum

'''

    @brief      ItemType

    @author     Jeongwoo

    @date       2018.04.27

    @history    2018.05.10  Jeongwoo    Add LINE_NO

'''

class ItemType(Enum):

    SYMBOL = 1

    NOTE = 2

    LINE_NO = 3

class QCustomCheckBox(QCheckBox):

    def __init__(self, table, row, col):

        QCheckBox.__init__(self)

        self.table = table

        self.row = row

        self.col = col

    def state_changed(self, state):

        """ check box state is changed """

        if self.col == 0:

            '''

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

                data = self.table.item(index, 1).data(Qt.UserRole) if self.table.item(index, 1) is not None else None

                if data and type(data) is SymbolAttr:

                    widget = self.table.cellWidget(index, 3)

                    if widget:

                        widget.setEnabled(False) if state else widget.setEnabled(True)

                    data.Freeze = self.isChecked()

                    item = self.table.item(index, 3)

                    if item:

                        item.setFlags(Qt.ItemIsEnabled) if state else item.setFlags(Qt.ItemIsEnabled|Qt.ItemIsEditable|Qt.ItemIsSelectable)

                        item.setBackground(Qt.lightGray) if state else item.setBackground(Qt.white)

            '''

            widget = self.table.cellWidget(self.row, 3)

            if widget:

                widget.setEnabled(False) if state else widget.setEnabled(True)

            data = self.table.item(self.row, 1).data(Qt.UserRole)

            if data: data.Freeze = self.isChecked()

            item = self.table.item(self.row, 3)

            if item:

                item.setFlags(Qt.ItemIsEnabled) if state else item.setFlags(Qt.ItemIsEnabled|Qt.ItemIsEditable|Qt.ItemIsSelectable)

                item.setBackground(Qt.lightGray) if state else item.setBackground(Qt.white)

        elif self.col == 3:

            cell = self.table.item(self.row, 1)

            if cell:

                data = cell.data(Qt.UserRole)

                if data is not None:

                    if self.table._item: self.table._item.set_property(data.Attribute, self.isChecked())

class QItemPropertyTableWidget(QTableWidget):

    def __init__(self, mainWindow):

        QTableWidget.__init__(self)

        self._item = None

        self.mainWindow = mainWindow

        self.cellChanged.connect(self.cellChangedEvent)

        self.cellDoubleClicked.connect(self.cellDoubleClickedEvent)

    '''

        @brief      Initialize TableWidget

        @author     Jeongwoo

        @date       18.04.13

        @history    humkyung 2018.07.08 show column header

    '''

    def initItemPropertyTableWidget(self, item=None):

        if item is None:

            self.horizontalHeader().hide()

            return

        self.horizontalHeader().show()

        category = item.category

        if category == 'Equipment - [ Pressure Drop ]':

            self.setColumnCount(2)

            self.setHorizontalHeaderLabels(['P. Drop', 'Elevation'])

            self.setColumnWidth(0, 80)

            self.setColumnWidth(1, 80)

        elif category == 'Equipment - [ Pressurized ]':

            self.setColumnCount(3)

            self.setHorizontalHeaderLabels(['Index', 'P. Drop', 'Elevation'])

            self.setColumnWidth(0, 70)

            self.setColumnWidth(1, 70)

            self.setColumnWidth(2, 10)

        elif category == 'Equipment - [ Rotating ]':

            self.setColumnCount(2)

            self.setHorizontalHeaderLabels(['P. Drop', 'Elevation'])

            self.setColumnWidth(0, 80)

            self.setColumnWidth(1, 80)

        elif category == 'Instrument':

            self.setColumnCount(2)

            self.setHorizontalHeaderLabels(['P. Drop', 'Elevation'])

            self.setColumnWidth(0, 80)

            self.setColumnWidth(1, 80)

        self.verticalHeader().hide()

        self.horizontalHeader().setStretchLastSection(True)

        #self.verticallHeader().setDefaultSectionSize(50)

    '''

        @brief  show item's property

        @author humkyung

        @date   2018.07.03

        @history    euisung  2019.01.15     add icon image to line item

    '''

    def show_item_property(self, item):

        try:

            from PyQt5 import QtGui

            from SymbolAttr import SymbolAttr

            from EngineeringStreamlineItem import QEngineeringStreamlineItem

            self._item = item

            self.blockSignals(True)

            if type(item) is QEngineeringStreamlineItem:

                self.initItemPropertyTableWidget()

                self.initTitleCell(item)

                self.initContentsCell()

            elif issubclass(type(item), SymbolSvgItem):                

                self.onSymbolClicked(item)

            elif type(item) is QEngineeringLineNoTextItem:

                self.onLineNoClicked(item)

            elif type(item) is QEngineeringNoteItem:

                noteContentsList = item.findNoteContents(item.text())

                self.onNoteClicked(item.text(), noteContentsList)

            elif issubclass(type(item), QEngineeringTextItem):

                self.onTextClicked(item)            

            elif item is None:

                self.setRowCount(0)

        except Exception as ex:

            from App import App 

            message = 'error occured({}) 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)

        finally:

            self.blockSignals(False)

    '''

        @brief      Slot to accept item click event

        @author     Jeongwoo

        @date       18.04.13

        @history    humkyung 2018.04.17 check if given symbol type is SymbolSvgItem

    '''

    @pyqtSlot(SymbolSvgItem)

    def onSymbolClicked(self, symbol):

        try:

            self.blockSignals(True)

            if issubclass(type(symbol), SymbolSvgItem):

                self._item = symbol

                self.symbolChanged(symbol)

            elif type(symbol) is QEngineeringLineNoTextItem:

                self.lineNoChanged(symbol)

        finally:

            self.blockSignals(True)

    '''

        @brief      show drawing' attributes

        @author     humkyung 

        @date       2018.07.07

    '''

    @pyqtSlot(Drawing)

    def onDrawingClicked(self, drawing):

        try:

            self.blockSignals(True)

            self.setRowCount(len(drawing.attrs))

            row = 0

            for attr in drawing.attrs:

                name = attr[0]

                item = QTableWidgetItem(name)

                item.setFlags(Qt.ItemIsEnabled)

                item.setBackground(Qt.lightGray)

                self.setItem(row, 0, item)

                value = attr[1]

                item = QTableWidgetItem(value)

                item.setFlags(Qt.ItemIsEnabled)

                self.setItem(row, 1, item)

                row = row + 1

        finally:

            self.blockSignals(False)

    def onVendorClicked(self, item):

        from SymbolAttr import SymbolAttr

        try:

            self.blockSignals(True)

            self.initTitleCell(item)

            self.setItem(0, 3, QTableWidgetItem(str(self._item.uid)))

            self.show_item_properties(item)

        finally:

            self.blockSignals(False)

    def onTextClicked(self, item):

        from SymbolAttr import SymbolAttr

        try:

            self.blockSignals(True)

            self.initTitleCell(item)

            self.setItem(0, 3, QTableWidgetItem(str(self._item.uid)))

            owner_item = QTableWidgetItem('{}'.format('None' if self._item.owner is None else str(self._item.owner)))

            owner_item.setFlags(Qt.ItemIsEnabled|Qt.ItemIsSelectable)

            self.setItem(1, 3, owner_item)

            """ show icon item """

            attr = SymbolAttr()

            attr.AttributeType = "OWNER"

            self.show_icon_item(1, 2, attr)

            self.item(1, 1).setData(Qt.UserRole, attr)

            self.setItem(2, 3, QTableWidgetItem(self._item.type))

            self.setItem(3, 3, QTableWidgetItem(self._item.text()))

        finally:

            self.blockSignals(False)

    '''

        @brief      Slot to accept Note item click event

        @author     Jeongwoo

        @date       18.04.27

        @history    humkyung 2018.07.08 change method name to onNoteClicked

    '''

    @pyqtSlot(str, dict)

    def onNoteClicked(self, noteNoStr, noteContentsList):

        try:

            self.blockSignals(True)

            self.noteChanged(noteNoStr, noteContentsList)

        finally:

            self.blockSignals(False)

    '''

        @brief      Slot to accept Line No Item Click event

        @author     Jeongwoo

        @date       18.05.10

        @hisotry    humkyung 2018.07.08 change method name to onLineNoClicked

    '''

    @pyqtSlot(QEngineeringAbstractItem)

    def onLineNoClicked(self, item):

        try:

            self.blockSignals(True)

            self.lineNoChanged(item)

        finally:

            self.blockSignals(False)

    '''

        @brief      Reset table with new SymbolSvgItem

        @author     Jeongwoo

        @date       18.04.13

        @history    .

    '''

    def symbolChanged(self, item):

        self.initItemPropertyTableWidget(item)

        #self.initTitleCell(item)

        self.initContentsCell()

    '''

        @brief      Reset table with note info

        @author     Jeongwoo

        @date       18.04.27

    '''

    def noteChanged(self, noteNoStr, noteContentsList):

        self.initNoteCell(noteNoStr, noteContentsList)

    '''

        @brief      Reset table with line no item

        @author     Jeongwoo

        @date       18.05.10

    '''

    def lineNoChanged(self, item):

        from EngineeringRunItem import QEngineeringRunItem

        if type(item) is QEngineeringLineNoTextItem:

            self.initTitleCell(item)

            self.initLineNoCell(item)

        elif type(item) is QEngineeringRunItem:

            self.initLineRunCell(item)

        """ show tooltip """

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

            item = self.item(index, 1)

            if item is not None:

                item.setToolTip(item.text())

    '''

        @brief      Initialize Title Cell

        @author     Jeongwoos

        @date       18.04.13

        @history    Jeongwoo 2018.04.27 Add if-statement by ItemType

                    Jeongwoo 2018.05.10 Add if-statement LINE_NO ItemType

                    humkyung 2018.08.15 add combobox for line type

    '''

    def initTitleCell(self, item):

        from LineTypeConditions import LineTypeConditions

        from EngineeringStreamlineItem import QEngineeringStreamlineItem

        try:

            #self.clear()

            #self.setHorizontalHeaderLabels(['', self.tr('Name'), '', self.tr('Value')])

            #self.setColumnWidth(0, 20)

            #self.setColumnWidth(1, 80)

            #self.setColumnWidth(2, 20)

            if type(item) is QEngineeringStreamlineItem:

                self.setRowCount(7)

                self.setItem(0, 1, QTableWidgetItem(self.tr("UID")))

                self.setItem(1, 1, QTableWidgetItem(self.tr("Name")))

                self.setItem(2, 1, QTableWidgetItem(self.tr("Type")))

                self.setItem(3, 1, QTableWidgetItem(self.tr("Angle")))

                self.setItem(4, 1, QTableWidgetItem(self.tr("Origin")))

                self.setItem(5, 1, QTableWidgetItem(self.tr("OWNER")))

                self.setItem(6, 1, QTableWidgetItem(self.tr("Set Specs")))

            elif type(item) is QEngineeringErrorItem:

                self.setRowCount(7)

                self.setItem(0, 1, QTableWidgetItem(self.tr("UID")))

                self.setItem(1, 1, QTableWidgetItem(self.tr("Name")))

                self.setItem(2, 1, QTableWidgetItem(self.tr("Type")))

                self.setItem(3, 1, QTableWidgetItem(self.tr("Angle")))

                self.setItem(4, 1, QTableWidgetItem(self.tr("Origin")))

                self.setItem(5, 1, QTableWidgetItem(self.tr("OWNER")))

                self.setItem(6, 1, QTableWidgetItem(self.tr("Message")))

            elif issubclass(type(item), SymbolSvgItem):

                self.setRowCount(6)

                self.setItem(0, 1, QTableWidgetItem(self.tr("UID")))

                self.setItem(1, 1, QTableWidgetItem(self.tr("Name")))

                self.setItem(2, 1, QTableWidgetItem(self.tr("Type")))

                self.setItem(3, 1, QTableWidgetItem(self.tr("Angle")))

                self.setItem(4, 1, QTableWidgetItem(self.tr("Origin")))

                self.setItem(5, 1, QTableWidgetItem(self.tr("OWNER")))

            elif type(item) is QEngineeringNoteItem:

                self.setRowCount(2)

                self.setItem(0, 1, QTableWidgetItem(self.tr("Note No")))

                self.setItem(1, 1, QTableWidgetItem(self.tr("Desc.")))

            elif type(item) is QEngineeringLineNoTextItem:

                self.setRowCount(1)

                self.setItem(0, 1, QTableWidgetItem(self.tr("UID")))

            elif type(item) is QEngineeringLineItem:

                self.setRowCount(5)

                self.setItem(0, 1, QTableWidgetItem(self.tr('UID')))

                self.setItem(1, 1, QTableWidgetItem(self.tr('OWNER')))

                widgetItem = QTableWidgetItem(self.tr("Type"))

                widgetItem.setData(Qt.UserRole, item)

                self.setItem(2, 1, widgetItem)

                self._lineTypeComboBox = QComboBox(self)

                self._lineTypeComboBox.tag = widgetItem

                for lineType in LineTypeConditions.items():

                    self._lineTypeComboBox.addItem(lineType.name)

                self.setCellWidget(2, 3, self._lineTypeComboBox)

                self._lineTypeComboBox.setCurrentText(item.lineType)

                self._lineTypeComboBox.currentIndexChanged.connect(self.onLineTypeChanged)           

            #else:

            #    self.setRowCount(4)

            #    self.setItem(0, 1, QTableWidgetItem(self.tr("UID")))

            #    self.setItem(1, 1, QTableWidgetItem(self.tr("OWNER")))

            #    self.setItem(2, 1, QTableWidgetItem(self.tr("Type")))

            #    self.setItem(3, 1, QTableWidgetItem(self.tr("Text")))

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

                item = self.item(index, 1)

                if item is not None:

                    item.setFlags(Qt.ItemIsEnabled)

                    item.setBackground(Qt.lightGray)

        except Exception as ex:

            from App import App 

            message = 'error occured({}) 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)

    '''

        @brief  change selected lines' type by selected line type

        @author humkyung

        @date   2018.08.15

    '''

    def onLineTypeChanged(self, param):

        lineType = self._lineTypeComboBox.itemText(param)

        data = self._lineTypeComboBox.tag.data(Qt.UserRole)

        if type(data) is QEngineeringLineItem:

            self.changeConnectedLineType(data, lineType)

    def changeConnectedLineType(self, line, lineType):

        line.lineType = lineType

        if type(line.connectors[0].connectedItem) is QEngineeringLineItem and \

                (line.connectors[0].connectedItem.connectors[0].connectedItem is line or line.connectors[0].connectedItem.connectors[1].connectedItem is line) and \

                line.connectors[0].connectedItem.lineType is not lineType:

            self.changeConnectedLineType(line.connectors[0].connectedItem, lineType)

        if type(line.connectors[1].connectedItem) is QEngineeringLineItem and \

                (line.connectors[1].connectedItem.connectors[0].connectedItem is line or line.connectors[1].connectedItem.connectors[1].connectedItem is line) and \

                line.connectors[1].connectedItem.lineType is not lineType:

            self.changeConnectedLineType(line.connectors[1].connectedItem, lineType)

    def show_icon_item(self, row, col, prop):

        """ show icon item on grid """

        from PyQt5 import QtGui

        if prop.is_selectable or prop.AttributeType == 'OWNER' or prop.AttributeType == 'CONN':

            icon = QtGui.QIcon()

            icon.addPixmap(QtGui.QPixmap(":/newPrefix/doubleclick.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)

            icon_item = QTableWidgetItem('')

            icon_item.setFlags(Qt.ItemIsEnabled)

            icon_item.setIcon(icon)

            self.setItem(row, col, icon_item)

        elif prop.AttributeType == "String":

            icon = QtGui.QIcon()

            icon.addPixmap(QtGui.QPixmap(":/newPrefix/type.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)

            icon_item = QTableWidgetItem()

            icon_item.setIcon(icon)

            self.setItem(row, col, icon_item)

        else:

            item = QTableWidgetItem()

            item.setFlags(Qt.ItemIsEditable)

            self.setItem(row, col, item)

    def show_item_properties(self, item):

        """ show item properties on grid """

        from PyQt5 import QtGui

        row = self.rowCount()

        if hasattr(item, '_properties'):

            self.setRowCount(row + len(item.properties))

            for prop,value in item.properties.items():

                try:

                    """ show freeze state """

                    checkbox = QCustomCheckBox(self, row, 0)

                    checkbox.setChecked(prop.Freeze)

                    checkbox.stateChanged.connect(checkbox.state_changed)

                    self.setCellWidget(row, 0, checkbox)

                    """ show property name """

                    key_item = QTableWidgetItem(prop.DisplayAttribute if prop.DisplayAttribute else prop.Attribute)

                    key_item.setFlags(Qt.ItemIsEnabled)

                    key_item.setBackground(Qt.lightGray)

                    key_item.setData(Qt.UserRole, prop)

                    self.setItem(row, 1, key_item)

                    """ show icon item """

                    self.show_icon_item(row, 2, prop)

                    """ show property value """

                    if prop.is_selectable:

                        value_item = QTableWidgetItem(str(value.uid) if hasattr(value, 'uid') else value)

                        value_item.setFlags(Qt.ItemIsEnabled|Qt.ItemIsSelectable)

                        self.setItem(row, 3, value_item)

                    else:

                        if prop.AttributeType == 'Boolean':

                            self.checkbox_cell = QCustomCheckBox(self, row, 3)

                            self.checkbox_cell.setChecked(True if value and str(value) == 'True' else False)

                            self.checkbox_cell.stateChanged.connect(self.checkbox_cell.state_changed)

                            #if prop.Attribute == 'Freeze': self.checkbox_cell.stateChanged.connect(item.freeze_item.update_freeze)

                            self.setCellWidget(row, 3, self.checkbox_cell)

                        else:

                            value_item = QTableWidgetItem(value if value else '')

                            value_item.setFlags(Qt.ItemIsEnabled|Qt.ItemIsSelectable|Qt.ItemIsEditable)

                            self.setItem(row, 3, value_item)

                    checkbox.state_changed(checkbox.isChecked())

                    row = row + 1

                except Exception as ex:

                    from App import App 

                    message = 'error occured({}) 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 show_item_attributes(self, item):

        """ show item's attributes on grid """

        from PyQt5 import QtGui

        row = self.rowCount()

        attrs = item.getAttributes()

        # display attributes of symbol

        if attrs is not None:

            self.setRowCount(row + len(attrs))

            for key,value in attrs.items():

                try:

                    """ show freeze state """

                    checkbox = QCustomCheckBox(self, row, 0)

                    checkbox.setChecked(key.Freeze)

                    checkbox.stateChanged.connect(checkbox.state_changed)

                    self.setCellWidget(row, 0, checkbox)

                    """ show property name """

                    key_item = QTableWidgetItem(key.DisplayAttribute if key.DisplayAttribute else key.Attribute)

                    key_item.setBackground(Qt.lightGray)

                    key_item.setData(Qt.UserRole, key)

                    self.setItem(row, 1, key_item)

                    """ show icon item """

                    self.show_icon_item(row, 2, key)

                    value_item = QTableWidgetItem(str(value))

                    value_item.setFlags(Qt.ItemIsEnabled|Qt.ItemIsSelectable|Qt.ItemIsEditable)

                    if type(item) is QEngineeringSpecBreakItem:

                        if key.Attribute == 'UpStream' or key.Attribute == 'DownStream':

                            UpDownItem = QTableWidgetItem('{}'.format('None' if value is None else value))

                            self.setItem(row, 3, UpDownItem)

                        elif key.AttributeType == 'Spec':

                            self.setItem(row, 3, QTableWidgetItem(key.Attribute))

                    else:

                        self.setItem(row, 3, value_item)

                    checkbox.state_changed(checkbox.isChecked())

                    row = row + 1

                except Exception as ex:

                        from App import App 

                        message = 'error occured({}) 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 show_item_connectors(self, item):

        """ show items' connectors on grid """

        from PyQt5 import QtGui

        from SymbolAttr import SymbolAttr

        row = 0 #self.rowCount()

        self.setRowCount(row + len(item.connectors))

        count = 1

        for connector in item.connectors:

            connector_item = QTableWidgetItem('{}'.format(count))

            connector_item.setFlags(Qt.ItemIsEnabled)

            connector_item.setBackground(Qt.lightGray)

            connector_item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)

            self.setItem(row, 0, connector_item)

            #attr = SymbolAttr()

            #attr.AttributeType = "CONN"

            #attr.AttrAt = count

            #connector_item.setData(Qt.UserRole, attr)

            """ show icon item """

            #self.show_icon_item(row, 2, attr)

            #connector_item = QTableWidgetItem('{}'.format('None' if connector.connectedItem is None else str(connector.connectedItem)))

            #connector_item.setFlags(Qt.ItemIsEnabled|Qt.ItemIsSelectable)

            #self.setItem(row, 3, connector_item)

            row = row + 1

            count = count + 1

    '''

        @brief      Initialize Contents Cell

        @author     Jeongwoo

        @date       18.04.13

        @history    humkyung 2018.06.14 display symbol attributes 

                    humkyung 2018.07.05 display connectivity

                    euisung  2019.01.15 edit specbreak

    '''

    def initContentsCell(self):

        from PyQt5 import QtGui

        from SymbolAttr import SymbolAttr

        try:

            if self._item is not None and issubclass(type(self._item), SymbolSvgItem):

                docData = AppDocData.instance()

                '''

                self.setItem(0, 3, QTableWidgetItem(str(self._item.uid)))

                self.setItem(1, 3, QTableWidgetItem(self._item.name))

                self.setItem(2, 3, QTableWidgetItem(self._item.type))

                self.setItem(3, 3, QTableWidgetItem(str(round(math.degrees(self._item.angle)))))

                self.setItem(4, 3, QTableWidgetItem(str(self._item.origin)))

                owner_item = QTableWidgetItem('{}'.format('None' if self._item.owner is None else str(self._item.owner)))

                self.setItem(5, 3, owner_item)

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

                    item = self.item(index, 3)

                    if item is not None:

                        item.setFlags(Qt.ItemIsEnabled|Qt.ItemIsSelectable)

                """ show icon item """

                attr = SymbolAttr()

                attr.AttributeType = "OWNER"

                self.show_icon_item(5, 2, attr)

                self.item(5, 1).setData(Qt.UserRole, attr)

                #if type(self._item) is not QEngineeringSpecBreakItem and type(self._item) is not QEngineeringErrorItem:

                    #self.show_item_properties(self._item)