HYTOS

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

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

            if item:

        elif self.col == 3:

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

            if cell:

                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)

        @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

        except Exception as ex:

            from App import App

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

        finally:

            self.blockSignals(False)

        @date       18.04.13

        @history    humkyung 2018.07.08 show column header

    '''

    def initResultPropertyTableWidget(self):

        self.setColumnCount(4)

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

        @date       18.04.13

        @history    humkyung 2018.04.17 check if given symbol type is SymbolSvgItem

    '''

    @pyqtSlot(SymbolSvgItem)

    def onSymbolClicked(self, symbol):

        try:

        @author     humkyung 

        @date       2018.07.07

    '''

    @pyqtSlot(Drawing)

    def onDrawingClicked(self, drawing):

        try:

                name = attr[0]

                item = QTableWidgetItem(name)

                item.setFlags(Qt.ItemIsEnabled)

                self.setItem(row, 0, item)

                value = attr[1]

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

            self.setItem(1, 3, owner_item)

            """ show icon item """

        @date       18.04.27

        @history    humkyung 2018.07.08 change method name to onNoteClicked

    '''

    @pyqtSlot(str, dict)

    def onNoteClicked(self, noteNoStr, noteContentsList):

        try:

        @date       18.05.10

        @hisotry    humkyung 2018.07.08 change method name to onLineNoClicked

    '''

    @pyqtSlot(QEngineeringAbstractItem)

    def onLineNoClicked(self, item):

        try:

        finally:

            self.blockSignals(False)

    def symbolChanged(self, item):

        self.initTitleCell(item)

        self.initContentsCell()

        @author     Jeongwoo

        @date       18.04.27

    '''

    def noteChanged(self, noteNoStr, noteContentsList):

        self.initNoteCell(noteNoStr, noteContentsList)

        @author     Jeongwoo

        @date       18.05.10

    '''

    def lineNoChanged(self, item):

        from EngineeringRunItem import QEngineeringRunItem

                    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

                item = self.item(index, 1)

                if item is not None:

                    item.setFlags(Qt.ItemIsEnabled)

        except Exception as ex:

            from App import App

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

    '''

        @author humkyung

        @date   2018.08.15

    '''

    def onLineTypeChanged(self, param):

        lineType = self._lineTypeComboBox.itemText(param)

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

    def changeConnectedLineType(self, line, lineType):

        line.lineType = lineType

        if type(line.connectors[0].connectedItem) is QEngineeringLineItem 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.lineType is not lineType:

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

        if hasattr(item, '_properties'):

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

                try:

                    """ show freeze state """

                    checkbox = QCustomCheckBox(self, row, 0)

                    """ show property name """

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

                    key_item.setFlags(Qt.ItemIsEnabled)

                    key_item.setData(Qt.UserRole, prop)

                    self.setItem(row, 1, key_item)

                    """ show property value """

                    if prop.is_selectable:

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

                        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)

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

                        else:

                            value_item = QTableWidgetItem(value if value else '')

                            self.setItem(row, 3, value_item)

                    checkbox.state_changed(checkbox.isChecked())

                except Exception as ex:

                    from App import App

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

    def show_item_attributes(self, item):

        if attrs is not None:

            self.setRowCount(row + len(attrs))

                try:

                    """ show freeze state """

                    checkbox = QCustomCheckBox(self, row, 0)

                    """ show property name """

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

                    key_item.setData(Qt.UserRole, key)

                    self.setItem(row, 1, key_item)

                    self.show_icon_item(row, 2, key)

                    value_item = QTableWidgetItem(str(value))

                    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)

                            self.setItem(row, 3, QTableWidgetItem(str(value)[1:-1]))

                    else:

                        self.setItem(row, 3, value_item)

                    row = row + 1

                except Exception as ex:

    def show_item_connectors(self, item):

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

        for connector in item.connectors:

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

            connector_item.setFlags(Qt.ItemIsEnabled)

            self.setItem(row, 1, connector_item)

            attr = SymbolAttr()

            """ show icon item """

            self.show_icon_item(row, 2, attr)

            self.setItem(row, 3, connector_item)

            row = row + 1

                    humkyung 2018.07.05 display connectivity

                    euisung  2019.01.15 edit specbreak

    '''

    def initContentsCell(self):

        from PyQt5 import QtGui

        from SymbolAttr import SymbolAttr

                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(4, 3, QTableWidgetItem(str(self._item.origin)))

                self.setItem(5, 3, owner_item)

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

                    item = self.item(index, 3)

                    if item is not None:

                """ show icon item """

                attr = SymbolAttr()

                self.show_icon_item(1, 2, attr)

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

                self.setItem(1, 3, owner_item)

                self.show_item_properties(self._item)

        except Exception as ex:

            from App import App

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

    '''

        @author     kyouho

        @date       2018.08.28

    '''

    def upStreamChanged(self, text):

        if self._item is not None:

            find = False

        @author     kyouho

        @date       2018.08.28

    '''

    def downStreamChanged(self, text):

        if self._item is not None:

            find = False

        @author     Jeongwoo

        @date       18.04.27

    '''

    def initNoteCell(self, noteNoStr, noteContentsList):

        self.setRowCount(0)

            item = self.item(index, 1)

            if item is not None:

                item.setFlags(Qt.ItemIsEnabled)

    '''

        @brief      Initialize Line No Contents Cell

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

        self.setItem(0, 3, item)

        self.show_item_properties(lineNoItem)

            for key in attrs.keys():

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

                item.setFlags(Qt.ItemIsEnabled)

                item.setData(Qt.UserRole, key)

                self.setItem(row, 1, item)

                    # editable value cell

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

                        pass

                    if keyStr[0].UID in configs: valueCell.setFlags(Qt.ItemIsEnabled)

                else:

                if key.Attribute.upper() == 'STREAM_NO':

                    self.streamNoComboBox = QComboBox()

        @author humkyung

        @date   2018.07.20

    '''

    def onStreamNoChanged(self, param):

        items = self.mainWindow.graphicsView.scene().selectedItems()

        if items is not None and len(items) == 1:

        @author     humkyung 

        @date       2018.05.27

    '''

    def initLineRunCell(self, item):

        self.setRowCount(1)

        lineTypeItem = QTableWidgetItem(self.tr("Line Type"))

        lineTypeItem.setFlags(Qt.ItemIsEnabled)

        self.setItem(0, 1, lineTypeItem)

        @author     kyouho

        @date       2018.07.19

    '''

    def keyPressEvent(self, event):

        from SymbolAttr import SymbolAttr

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

            items = self.mainWindow.graphicsView.scene().selectedItems()

            selectedIndexes = self.selectedIndexes()

                items[0].owner = None

                self.show_item_property(items[0])

                key_cell = self.item(selectedIndexes[0].row(), 1)

                data = key_cell.data(Qt.UserRole)

                if selectedIndexes[0].column() == 3 and key_cell.text().find('CONN') is 0:

                    self.show_item_property(items[0])

                    for sceneItem in self.mainWindow.graphicsView.scene().items():

                            for sceneConnector in sceneItem.connectors:

                                    sceneConnector.connectedItem = None

                elif selectedIndexes[0].column() == 3 and data and type(data) is SymbolAttr:

                    assocItem = None

                        if str(_attr.UID) == str(data.UID):

                            assocItem = _attr.AssocItem

                            items[0].remove_assoc_item(_attr.AssocItem)

                            _attr.AssocItem = None

                            items[0].attrs[_attr] = ''

                            break

                        if _attr.AssocItem is assocItem:

                            _attr.AssocItem = None

                            items[0].attrs[_attr] = ''

                    self.show_item_property(items[0])

            elif len(items) == 1 and len(selectedIndexes) == 1 and type(items[0]) is QEngineeringSpecBreakItem:

                keyCell = self.item(selectedIndexes[0].row(), 1)

                    for attr in items[0].attrs.keys():

                        if attr.Attribute == keyCell.text():

                            items[0].attrs[attr] = None

        @author     kyouho

        @date       2018.08.20

    '''

    def cellChangedEvent(self, row, column):

        from SymbolAttr import SymbolProp

        from SymbolAttr import SymbolAttr

            from App import App

            from AppDocData import MessageType

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

    '''

        @date       2018.07.19

        @history    euisung  2019.01.15  edit specbreak

    '''

    def cellDoubleClickedEvent(self, row, column):

        from SymbolAttr import SymbolProp

                cmd = SelectAttributeCommand.SelectAttributeCommand(items[0], attr, self.mainWindow.graphicsView)

                cmd.onSuccess.connect(self.onSuccessSelectAttribute)

                self.mainWindow.graphicsView.command = cmd

                attr = keyCell.data(Qt.UserRole)

                cmd = SelectAttributeCommand.SelectAttributeCommand(items[0], attr, self.mainWindow.graphicsView)

                cmd.onSuccess.connect(self.onSuccessSelectAttribute)

                        dialog.exec_()

                        self.show_item_property(items[0])

                    except Exception as ex:

            elif issubclass(type(attr), SymbolProp):

                attr = keyCell.data(Qt.UserRole)

                cmd = SelectAttributeCommand.SelectAttributeCommand(items[0], attr, self.mainWindow.graphicsView)

        @author     kyouho

        @date       2018.10.23

    '''

        """ update item's properties after selecting """

        self.itemTreeWidget.sceneChanged(self.graphicsView.scene().items())

    def dbUpdate(self):

        try:

            appDocData = AppDocData.instance()

            items = appDocData.allItems

            self.addMessage.emit(MessageType.Error, message)

    def drawDetectedItemsToScene(self):

        try:

                if issubclass(type(symbol), SymbolSvgItem):

                else:

                    self.graphicsView.scene().addItem(symbol)

                self.addTextItemToScene(text)

                self.addTextItemToScene(lineNo)

                self.graphicsView.scene().addItem(line)

                line.transfer.onRemoved.connect(self.itemRemoved)

                for conn in line.connectors:

                    conn.transfer.onPosChanged.connect(line.onConnectorPosChaned)

                self.graphicsView.scene().addItem(unknown)

        finally:

            # update scene

            self.graphicsView.scene().update(self.graphicsView.sceneRect())

        from QEngineeringFlowArrowItem import QEngineeringFlowArrowItem

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringUnknownItem import QEngineeringUnknownItem

        try:

            docData = AppDocData.instance()

            else:

                message = 'can\'t found {}'.format(diffFilePath)

                self.addMessage.emit(MessageType.Normal, message)

        except Exception as ex:

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

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

                    item.transfer.onRemoved.connect(self.itemRemoved)

                    symbols.append(item)

                    app_doc_data.symbols.append(item)

                else:

                    pt = [float(symbol['X']), float(symbol['Y'])]

                    size = [float(symbol['Width']), float(symbol['Height'])]

        @author     Jeongwoo

        @date       2018.05.25

        @history    2018.05.29  Jeongwoo    Moved from QRecognitionDialog

                    2018.06.05  Jeongwoo    Remove Size condition

                    2018.06.18  Jeongwoo    Set Z-index

    '''

                    # up to here

                    # remove line has not connected item

                    try:

                        count = 1

                        while count > 0:

                                        for conn in item.connectors:

                                            if conn.connectedItem is line:

                                                conn.connectedItem = None

                    except Exception as ex:

                        message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[

                            -1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)

                        worker.displayLog.emit(MessageType.Error, message)

                    # up to here

                createUnknownItems(mainRes)

                    roiw = (roiItemEp[0] - roiItemSp[0])

                    roih = (roiItemEp[1] - roiItemSp[1])

                    if roiw < sw or roih < sh:

                        if baseSymbol is not None and additionalSymbol is not None:

                            additionalSymbol = Worker.getRotatedChildInfo(additionalSymbol)

                                                             hasInstrumentLabel=hasInstrumentLabel, text_area=text_area)

                                    threadLock.release()

                    if additionalSymbol is not None:

                        additionalSymbol = Worker.getRotatedChildInfo(additionalSymbol)

            transform.translate(originImageHeight * 0.5, originImageWidth * 0.5)

        elif angle == 0 or angle == 180:

            transform.translate(originImageWidth * 0.5, originImageHeight * 0.5)

        transform.translate(-originImageWidth * 0.5, -originImageHeight * 0.5)

        point = QPoint(connPt[1], connPt[2])

        point = transform.map(point)

            self._class = symbolInfo.baseSymbol

            originalPoint = symbolInfo.getOriginalPoint().split(',')

            self.symbolOrigin = [float(originalPoint[0]), float(originalPoint[1])]

            # setting connectors

            connectionPoints = symbolInfo.getConnectionPoint().split('/')

            self.changeConnPoint()

        elif event.key() == Qt.Key_Return:

            # disable

            (isAccept, angle, x, y, z) = dialog.showDialog()

            if isAccept:

                self.angle = angle

                """

                self.loc = [x - self.symbolOrigin[0], y - self.symbolOrigin[1]]

            # up to here

            originNode = Element('ORIGINALPOINT')

            node.append(originNode)

            connectorsNode = Element('CONNECTORS')

                    if matches:

                        item._properties[matches[0]] = matches[0].parse_value(prop_node.text) if prop_node.text else ''

                areaNode = node.find('AREA')

                if areaNode is None:

                    for area in appDocData.getAreaList():

                            break

                else:

                    item.area = areaNode.text

                connectors = node.find('CONNECTORS')

                if connectors is not None:

    def addSvgItemToScene(self, scene, undoable: bool = False) -> None:

        """Add Svg Item into ImageViewer's Scene"""

        if self.flip:

            self.flip_symbol()

        self.moveBy(-self.symbolOrigin[0], -self.symbolOrigin[1])

        scene.addItem(self)

        self.size[0], self.size[1] = round(self.sceneBoundingRect().width()), round(self.sceneBoundingRect().height())