HYTOS

# 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 type(item) is QEngineeringVendorItem:

                self.onVendorClicked(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)

            elif type(item) is QEngineeringVendorItem:

                self.setRowCount(1)

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

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

                if type(self._item) is QEngineeringSpecBreakItem:

                    row = self.rowCount()

                    setSpecsItem = QTableWidgetItem('Open')

                    icon = QtGui.QIcon()

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

                    setSpecsItem.setIcon(icon)

                    self.setItem(row - 1, 2, setSpecsItem)

                if type(self._item) is QEngineeringErrorItem:

                    errType = 'None'

                    if type(self._item.parent) is QEngineeringLineItem:

                        errType = 'line'

                    elif issubclass(type(self._item.parent), SymbolSvgItem):

                        errType = 'symbol'

                    self.setItem(2, 3, QTableWidgetItem(errType))

                    self.setItem(5, 3, QTableWidgetItem(str(self._item.parent.uid)))

                    self.setItem(6, 3, QTableWidgetItem(self._item.msg))

                self.show_item_attributes(self._item)

                '''

                self.show_item_connectors(self._item)

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

                    item = self.item(index, 3)

                    if item is not None: item.setToolTip(item.text())

            elif self._item is not None and type(self._item) is QEngineeringLineItem:

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

                """ show icon item """

                attr = SymbolAttr()

                attr.AttributeType = "OWNER"

                self.show_icon_item(1, 2, attr)

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

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

                self.setItem(1, 3, owner_item)

                self.show_item_properties(self._item)

                pt = self._item.startPoint()

                key_item = QTableWidgetItem(self.tr("Start"))

                key_item.setFlags(Qt.ItemIsEnabled)

                key_item.setBackground(Qt.lightGray)

                self.setItem(3, 1, key_item)

                self.setItem(3, 3, QTableWidgetItem('({},{})'.format(pt[0], pt[1])))

                pt = self._item.endPoint()

                key_item = QTableWidgetItem(self.tr("End"))

                key_item.setFlags(Qt.ItemIsEnabled)

                key_item.setBackground(Qt.lightGray)

                self.setItem(4, 1, key_item)

                self.setItem(4, 3, QTableWidgetItem('({},{})'.format(pt[0], pt[1])))

                self.show_item_attributes(self._item)

                self.show_item_connectors(self._item)

            else:

                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)

    '''

        @brief      combobox change event

        @author     kyouho

        @date       2018.08.28

    '''

    def upStreamChanged(self, text):

        if self._item is not None:

            find = False

            for index in range(len(self._item.attrs)):

                if type(self._item.attrs[index]) is tuple and self._item.attrs[index][0] == 'Up Stream':

                    self._item.attrs[index] = (self._item.attrs[index][0], text)

                    find = True

                    break

            if not find:

                self._item.attrs.append(('Up Stream', text))

    '''

        @brief      combobox change event

        @author     kyouho

        @date       2018.08.28

    '''

    def downStreamChanged(self, text):

        if self._item is not None:

            find = False

            for index in range(len(self._item.attrs)):

                if type(self._item.attrs[index]) is tuple and self._item.attrs[index][0] == 'Down Stream':

                    self._item.attrs[index] = (self._item.attrs[index][0], text)

                    find = True

                    break

            if not find:

                self._item.attrs.append(('Down Stream', text))

    '''

        @brief      Initialize Note Contents Cell

        @author     Jeongwoo

        @date       18.04.27

    '''

    def initNoteCell(self, noteNoStr, noteContentsList):

        self.setRowCount(0)

        for key in noteContentsList:

            row = self.rowCount()

            self.setRowCount(row + len(noteContentsList[key]))

            item = QTableWidgetItem(key)

            self.setItem(row, 1, item)

            for index in range(len(noteContentsList[key])):

                self.setItem(row, 3, QTableWidgetItem(noteContentsList[key][index]))

                row = row + 1

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

            item = self.item(index, 1)

            if item is not None:

                item.setFlags(Qt.ItemIsEnabled)

                item.setBackground(Qt.lightGray)

    '''

        @brief      Initialize Line No Contents Cell

        @author     Jeongwoo

        @date       18.05.10

        @history    humkyung 2018.07.20 display combobox when key is 'Stream No'

    '''

    def initLineNoCell(self, lineNoItem):

        appDocData = AppDocData.instance()

        configs = appDocData.getConfigs('Line No', 'Configuration')

        configs = configs[0].value.split('"-"')

        item = QTableWidgetItem(str(lineNoItem.uid))

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

        self.setItem(0, 3, item)

        self.show_item_properties(lineNoItem)

        row = self.rowCount()

        attrs = lineNoItem.getAttributes()

        self.setRowCount(row + len(attrs))

        if attrs is not None:

            for key in attrs.keys():

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

                item.setFlags(Qt.ItemIsEnabled)

                item.setBackground(Qt.lightGray)

                item.tag = key

                self.setItem(row, 1, item)

                """ show icon item """

                self.show_icon_item(row, 2, key)

                # value cell

                value = attrs[key]

                valueCell = QTableWidgetItem(value)

                # UID로 확인

                keyStr = appDocData.getLinePropertiesByUID(key.UID)

                if keyStr:

                    # editable value cell

                    if keyStr[0].AttributeType == 'String':

                        pass

                        #self.attrValueList.append((valueCell, key.Attribute))

                        #self.stringCell.append(valueCell)