HYTOS

#!/usr/bin/env/python3

# coding: utf-8

import sys

import os

import math

from PyQt5.QtGui import *

from PyQt5.QtCore import *

from PyQt5.QtSvg import *

from PyQt5.QtWidgets import (QApplication, QGraphicsItem)

from PyQt5.QtXml import *

from AppDocData import *

from EngineeringConnectorItem import QEngineeringConnectorItem

from EngineeringAbstractItem import QEngineeringAbstractItem

from EngineeringSpecBreakItem import QEngineeringSpecBreakItem

from UserInputAttribute import UserInputAttribute

import SelectAttributeCommand

class SymbolSvgItem(QGraphicsSvgItem, QEngineeringAbstractItem):

    clicked = pyqtSignal(QGraphicsSvgItem)

    ZVALUE = 50

    HIGHLIGHT = '#BC4438'

    '''

        @history    18.04.11    Jeongwoo    Add Variable (Name, Type)

                    18.05.11    Jeongwoo    Declare variable self.color

                    18.05.25    Jeongwoo    Call setColor() method

                    18.05.30    Jeongwoo    Add self variables (parentSymbol, childSymbol)

    '''

    def __init__(self, path, uid=None):

        import uuid

        QGraphicsSvgItem.__init__(self)

        QEngineeringAbstractItem.__init__(self)

        self.setFlags(QGraphicsItem.ItemIsSelectable|QGraphicsItem.ItemIsFocusable)

                      #QGraphicsItem.ItemIsMovable)

        self.uid = uuid.uuid4() if uid is None else uid

        self.name = ''

        self.type = ''

        self.angle = 0

        self.origin = None

        self.loc = None

        self.size = None

        self.attrs = [] # attributes

        self._owner = None

        self.parentSymbol = ''

        self.childSymbol = '' 

        self.hasInstrumentLabel = 0

        # attributeType uid

        self.attribute = ''

        self.setAcceptHoverEvents(True)

        self.setAcceptedMouseButtons(Qt.LeftButton)

        self.setAcceptTouchEvents(True)

        self.currentCursor = 0

        self.transfer = Transfer()

        self.specBreak_offsetX = 0

        self.specBreak_offsetY = 0

        try:

            f = QFile(path)

            f.open(QIODevice.ReadOnly)

            array = f.readAll()

            self._document = QDomDocument()

            self._document.setContent(array)

            self._renderer = QSvgRenderer(self._document.toByteArray())

            self.setSharedRenderer(self._renderer)

            self.setColor(self._color)

            self._savedColor = self.getColor()

        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:

            f.close()

        self.setZValue(SymbolSvgItem.ZVALUE)

    '''

        @breif  getter owner

        @author humkyung

        @date   2018.05.10

    '''

    @property

    def owner(self):

        return self._owner

    '''

        @brief  setter owner

        @author humkyung

        @date   2018.05.10

        @history    2018.05.17  Jeongwoo    Add Calling setColor if self._owner is None or not

    '''

    @owner.setter

    def owner(self, value):

        self._owner = value

        if self._owner is None:

            self._color = self.DEFAULT_COLOR

        self.setColor(self._color)

    '''

        @brief      build symbol item

        @author     humkyung

        @date       2018.05.02

        @history    2018.05.09  Jeongwoo    Clear self.connectors

                    2018.05.30  Jeongwoo    Add parameters (parentSymbol, childSymbol)

    '''

    def buildItem(self, name, type, angle, loc, size, origin, connPts, parentSymbol, childSymbol, hasInstrumentLabel):

        try:

            docData = AppDocData.instance()

            self.name = name

            self.type = type

            self.angle = angle

            self.loc = loc

            self.size = size

            self.origin = origin

            symbolInfo = docData.getSymbolByQuery('name', name)

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

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

            # setting connectors

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

            for index in range(len(connectionPoints)):

                tokens = connectionPoints[index].split(',')

                direction = 'AUTO'

                if len(tokens) == 2:

                    x = float(tokens[0])

                    y = float(tokens[1])

                elif len(tokens) == 3:

                    direction = tokens[0]

                    x = float(tokens[1])

                    y = float(tokens[2])

                self.setConnector()

                self.connectors[index].direction = direction

                self.connectors[index].setPos((x - self.specBreak_offsetX, y - self.specBreak_offsetY))

                self.connectors[index].connectPoint = (x, y)

                self.connectors[index].sceneConnectPoint = (connPts[index][0], connPts[index][1]) if len(connPts[index]) == 2 else (connPts[index][1], connPts[index][2]) \

                    if len(connPts) > index else None

            self.parentSymbol = parentSymbol

            self.childSymbol = childSymbol

            self.hasInstrumentLabel = hasInstrumentLabel

            self.currentPointModeIndex = 0

            self.setToolTip(self.name)

        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  return bounding box of symbol

        @author humkyung

        @date   2018.04.08

    '''

    def rect(self):

        return self.sceneBoundingRect()

    '''

        @brief  return true if line is able to connect symbol

        @author humkyung

        @date   2018.04.13

    '''

    def isConnectable(self, line, offset,  toler=10):

        for connector in self.connectors:

            dx = connector.sceneConnectPoint[0] - (line[0][0] + offset[0])

            dy = connector.sceneConnectPoint[1] - (line[0][1] + offset[1])

            if (math.sqrt(dx*dx + dy*dy) < toler): return True

            dx = connector.sceneConnectPoint[0] - (line[-1][0] + offset[0])

            dy = connector.sceneConnectPoint[1] - (line[-1][1] + offset[1])

            if (math.sqrt(dx*dx + dy*dy) < toler): return True

        return False

    '''

        @brief      check if symbol and given item is jointed

        @author     humkyung

        @date       2018.07.03

    '''

    def isJointed(self, item, toler=5):

        import math

        from EngineeringLineItem import QEngineeringLineItem

        lhs = []

        for connector in self.connectors:

            lhs.append(connector.sceneConnectPoint)

        if type(item) is QEngineeringLineItem:

            rhs = [item.startPoint(), item.endPoint()]

        elif issubclass(type(item), SymbolSvgItem):

            rhs = []

            for connector in item.connectors:

                rhs.append(connector.sceneConnectPoint)

        else:

            rhs = []

        for pt in lhs:

            for _pt in rhs:

                dx = _pt[0] - pt[0]

                dy = _pt[1] - pt[1]

                if math.sqrt(dx*dx + dy*dy) < toler:

                    return True

        return False

    '''

        @brief      connect line and symbol is able to be connected and return line

        @author     humkyung

        @date       2018.04.16

        @history    humkyung 2018.05.08 check if symbol is possible to be connected

                    Jeongwoo 2018.05.15 Connect each symbol and line

    '''

    def connectIfPossible(self, obj, toler=10):

        from shapely.geometry import Point

        from EngineeringLineItem import QEngineeringLineItem

        res = []

        if type(obj) is QEngineeringLineItem:

            startPt = obj.startPoint()

            endPt = obj.endPoint()

            for i in range(len(self.connectors)):

                if (self.connectors[i].connectedItem is None) and (Point(startPt[0], startPt[1]).distance(Point(self.connectors[i].sceneConnectPoint[0], self.connectors[i].sceneConnectPoint[1])) < toler):

                    self.connectors[i].connectedItem = obj 

                    obj.connectors[0].connectedItem = self

                    res.append(obj)

                if (self.connectors[i].connectedItem is None) and (Point(endPt[0], endPt[1]).distance(Point(self.connectors[i].sceneConnectPoint[0], self.connectors[i].sceneConnectPoint[1])) < toler):

                    self.connectors[i].connectedItem = obj

                    obj.connectors[1].connectedItem = self

                    res.append(obj)

        elif issubclass(type(obj), SymbolSvgItem):

            for i in range(len(self.connectors)):

                for j in range(len(obj.connectors)):

                    _pt = Point(obj.connectors[j].sceneConnectPoint[0], obj.connectors[j].sceneConnectPoint[1])

                    if (self.connectors[i].connectedItem is None) and (_pt.distance(Point(self.connectors[i].sceneConnectPoint[0], self.connectors[i].sceneConnectPoint[1])) < toler):

                        self.connectors[i].connectedItem = obj 

                        obj.connectors[j].connectedItem = self

                        res.append(obj)

        return res

    '''

        @brief      check connector overlap specbreak

        @author     kyouho

        @date       2018.08.30

    '''

    def isConnectSpecBreak(self, specBreakList):

        for connector in self.connectors:

            for specBreak in specBreakList:

                if connector.isOverlapConnector(specBreak.connectors[0]):

                    return (True, connector)

        return (False,)

    '''

        @brief      disconnect connector item

        @author     kyouho

        @date       2018.08.30

    '''

    def disconnectedItemAtConnector(self, connector):

        for conn in self.connectors:

            if conn.isOverlapConnector(connector):

                conn.connectedItem = None

    '''

        @brief  get connection point close to given point in tolerance

        @author humkyung

        @dat

    '''

    def getConnectionPointCloseTo(self, pt, toler=10):

        import math

        for connector in self.connectors:

            dx = connector.sceneConnectPoint[0] - pt[0]

            dy = connector.sceneConnectPoint[1] - pt[1]

            if math.sqrt(dx*dx + dy*dy) < toler: return connPt

        return None

    '''

        @brief  return center of symbol

        @author humkyung

        @date   2018.04.08

    '''

    def center(self):

        return self.sceneBoundingRect().center()

    '''

        @brief      highlight connector and attribute

        @authro     humkyung

        @date       2018.05.02

    '''

    def hoverEnterEvent(self, event):

        try:

            from EngineeringTextItem import QEngineeringTextItem

            self.setHightlight()

            self.currentCursor = int(Qt.OpenHandCursor)

            cursor = QCursor(Qt.OpenHandCursor)

            QApplication.instance().setOverrideCursor(cursor)

            self.update()

            for attr in self.attrs:

                if issubclass(type(attr), QEngineeringTextItem):

                    attr.setDefaultTextColor(Qt.red)

                    attr.update()

                elif issubclass(type(attr), SymbolSvgItem):

                    attr._savedColor = attr.getColor()

                    attr.setColor(SymbolSvgItem.HIGHLIGHT)

                    attr.update()

        except Exception as ex: 

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

    '''

        @brief      unhighlight connector and attribute

        @author     humkyung

        @date       2018.05.02

        @history    kyouho 2018.07.18 edit ArrowCursor

    '''

    def hoverLeaveEvent(self, event):

        from EngineeringTextItem import QEngineeringTextItem

        self.unsetHightlight()

        self.currentCursor = int(Qt.ArrowCursor)

        cursor = QCursor(Qt.ArrowCursor)

        QApplication.instance().setOverrideCursor(cursor)

        self.update()

        for attr in self.attrs:

            if issubclass(type(attr), QEngineeringTextItem):

                attr.setDefaultTextColor(Qt.blue)

                attr.update()

            elif issubclass(type(attr), SymbolSvgItem):

                attr.setColor(attr._savedColor)

                attr.update()

    '''

        @brief      set highlight

        @author     kyouho

        @date       2018.08.27

    '''

    def setHightlight(self):

        self.setColor(SymbolSvgItem.HIGHLIGHT)

        self.update()

    '''

        @brief      unset highlight

        @author     kyouho

        @date       2018.08.27

    '''

    def unsetHightlight(self):

        self.setColor(self._savedColor)

        self.update()

    '''

        @brief  change cursor to CrossCursor if mouse point is close to connection point

        @author humkyung

        @date   2018.04.28

    '''

    def hoverMoveEvent(self, event):

        pass

    '''

        scenePos = self.mapToScene(event.pos())

        connPt = self.getConnectionPointCloseTo((scenePos.x(), scenePos.y()), 5)

        if connPt is not None:

            cursor = QCursor(Qt.CrossCursor)

            QApplication.instance().changeOverrideCursor(cursor)

        else:

            cursor = QCursor(Qt.OpenHandCursor)

            QApplication.instance().changeOverrideCursor(cursor)

        self.update()

    '''

    '''

        @brief      Mouse Press Event

        @author     Jeongwoo

        @date       18.04.11

        @history    kyouho 2018.07.18 add isClick logic

    '''

    def mousePressEvent(self, event):

        if event.buttons() == Qt.LeftButton:

            self.clicked.emit(self)

    '''

        @brief      Mouse Release Event

        @author     kyouho

        @date       18.07.17

    '''

    def mouseReleaseEvent(self, event):

        super().mouseReleaseEvent(event)

    '''

        @brief      Mouse Move Event

        @author     kyouho

        @date       18.07.17

    '''

    def removeSelfAttr(self, attributeName):

        for attr in self.attrs:

            if attr.attribute == attributeName:

                self.attrs.remove(attr)

    '''

        @brief      Find TextItem contain Point

        @author     kyouho

        @date       18.07.17

    '''

    def findTextItemInPoint(self, point):

        from EngineeringTextItem import QEngineeringTextItem

        scene = self.scene()

        for item in scene.items():

            if type(item) is QEngineeringTextItem:

                if self.isOverlapItemAndPoint(item, point):

                    return (True, item)

        return (False,)

    '''

        @brief      Check Overlap

        @author     kyouho

        @date       18.07.17

    '''

    def isOverlapItemAndPoint(self, item, point):

        x = point.x()

        y = point.y()

        loc = item.loc

        size = item.size

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

            return True

        else:

            return False

    '''

        @brief      Remove Attr

        @author     kyouho

        @date       18.07.17

    '''

    def removeAttr(self, item):

        scene = self.scene()

        for symbol in scene.items():

            if issubclass(type(symbol), SymbolSvgItem):

                for attr in symbol.attrs:

                    if attr == item:

                        symbol.attrs.remove(item)

    '''

        @brief  remove item when user press delete key

        @author humkyung

        @date   2018.04.23

        @history    2018.05.17  Jeongwoo    Add if-statement and move 'break'

                    2018.05.25  Jeongwoo    Seperate delete item method

    '''

    def keyPressEvent(self, event):

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

            self.deleteSvgItemFromScene()

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

            self.rotateSymbol()

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

            self.changeStandardPoint()

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

            self.changeConnPoint()

    '''

        @brief      connect attribute

        @author     humkyung

        @date       2018.05.02

        @history    humkyung 2018.05.09 append only nearest size attribute

    '''

    def connectAttribute(self, attributes):

        import math

        from QEngineeringSizeTextItem import QEngineeringSizeTextItem

        self.attrs.clear()

        dist = max(self.sceneBoundingRect().height(), self.sceneBoundingRect().width())

        center = self.sceneBoundingRect().center()

        minDist = None

        selected = None

        for attr in attributes:

            if type(attr) is QEngineeringSizeTextItem:

                dx = attr.center().x() - center.x()

                dy = attr.center().y() - center.y()

                length = math.sqrt(dx*dx + dy*dy)

                if (length < dist*2) and (minDist is None or length < minDist):

                    minDist = length

                    selected = attr

        if selected is not None: self.attrs.append(selected)

    '''

        @Auther     Yecheol

        @Date       2018.07.06

        @History    add Get not connected Attribute Item

                    humkyung 2018.07.23 fixed the code

    '''

    def getConnectedLabel(self, worker):

        import math

        from QEngineeringInstrumentItem import QEngineeringInstrumentItem

        findSymbols = [symbol for symbol in worker.graphicsView.scene.items() if type(symbol) is QEngineeringInstrumentItem]

        for symbol in findSymbols:

            isConnected = False

            for connector in symbol.connectors:

                if connector.connectedItem is not None:

                     isConnected = True

                     break

            if isConnected == False:

                dx = symbol.origin[0] - self.origin[0]

                dy = symbol.origin[1] - self.origin[1]

                if math.sqrt(dx*dx + dy*dy) < 200:

                    self.attrs.append(symbol)

    '''

        @brief      get attribute

        @author     humkyung

        @date       2018.06.14

        @history    kyouho  2018.07.18  Add only attr QEngineeringTextItem

    '''

    def getAttributes(self):

        from EngineeringTextItem import QEngineeringTextItem

        from QEngineeringInstrumentItem import QEngineeringInstrumentItem

        attrs = {}

        # 해당 Type의 attribute setting

        docData = AppDocData.instance()

        if type(attr) is QEngineeringSpecBreakItem:

            attrs['Up Stream'] = ''

            attrs['Down Stream'] = ''

        symbolAttrs = docData.getSymbolAttribute(self.type)

        for attr in symbolAttrs:

            attrs[attr[0]] = ''

        for attr in self.attrs:

            if type(attr) is QEngineeringTextItem or issubclass(type(attr), SymbolSvgItem):

                attrs[attr.attribute] = attr.uid

            elif type(attr) is QEngineeringInstrumentItem:

                attrs['Label'] = '{}'.format(attr)

            elif type(attr) is UserInputAttribute:

                attrs[attr.attribute] = attr.text

            elif type(attr) is tuple:

                attrs[attr[0]] = attr[1]

        return attrs

    '''

        @brief      generate xml code

        @author     humkyung

        @date       2018.04.23

        @history    humkyung 2018.04.25 add angle xml node

                    humkyung 2018.04.27 add originalpoint xml node

                    humkyung 2018.05.02 add attribute of symbol

                    Jeongwoo 2018.05.30 add attribute of symbol (parentSymbol, childSymbol, type, connectionPoint)

                    yecheol  2018.07.11 add attribute of symbol (hasInstrumentLabel)

                    humkyung 2018.07.20 write owner's uid to xml

                    humkyung 2018.07.23 write connected item's uid to xml

                    kyouho  2018.07.31 

    '''

    def toXml(self):

        from xml.etree.ElementTree import Element, SubElement, dump, ElementTree

        try:

            node = Element('SYMBOL')

            uidNode = Element('UID')

            uidNode.text = str(self.uid)

            node.append(uidNode)

            nameNode = Element('NAME')

            nameNode.text = self.name

            node.append(nameNode)

            attributeValueNode = Element('ATTRIBUTEVALUE')

            attributeValueNode.text = self.attribute

            node.append(attributeValueNode)

            typeNode = Element('TYPE')

            typeNode.text = self.type

            node.append(typeNode)

            # write owner's uid to xml

            if self.owner is not None:

                ownerNode = Element('OWNER')

                ownerNode.text = str(self.owner.uid)

                node.append(ownerNode)

            # up to here

            originNode = Element('ORIGINALPOINT')

            originNode.text = '{},{}'.format(self.origin[0], self.origin[1])

            node.append(originNode)

            connectorsNode = Element('CONNECTORS')

            for connector in self.connectors:

                connectorNode = Element('CONNECTOR')

                connectedItemNode = Element('CONNECTEDITEM')

                connectedItemNode.text = str(connector.connectedItem.uid) if connector.connectedItem is not None else 'None'

                connectPointNode = Element('CONNECTPOINT')

                connectPointNode.text = str(connector.connectPoint[0]) + ',' + str(connector.connectPoint[1])

                sceneConnectPointNode = Element('SCENECONNECTPOINT')

                sceneConnectPointNode.text = str(connector.sceneConnectPoint[0]) + ',' + str(connector.sceneConnectPoint[1])

                connectorNode.append(connectedItemNode)

                connectorNode.append(connectPointNode)

                connectorNode.append(sceneConnectPointNode)

                connectorsNode.append(connectorNode)

            node.append(connectorsNode)

            connectionNode = Element('CONNECTIONPOINT')

            connectionPoint = ''

            if self.connectors is not None:

                for index in range(len(self.connectors)):

                    if index != 0:

                        connectionPoint = connectionPoint + "/"

                    connTuple = self.connectors[index].sceneConnectPoint

                    connectionPoint = connectionPoint + str(connTuple[0]) + "," + str(connTuple[1])

            connectionNode.text = connectionPoint

            node.append(connectionNode)

            rect = self.sceneBoundingRect()

            locNode = Element('LOCATION')

            locNode.text = '{},{}'.format(self.loc[0], self.loc[1])

            node.append(locNode)

            sizeNode = Element('SIZE')

            sizeNode.text = '{},{}'.format(rect.width(), rect.height())

            node.append(sizeNode)

            angleNode = Element('ANGLE')

            angleNode.text = str(self.angle)

            node.append(angleNode)

            parentSymbolNode = Element('PARENT')

            parentSymbolNode.text = str(self.parentSymbol)

            node.append(parentSymbolNode)

            childSymbolNode = Element('CHILD')

            childSymbolNode.text = str(self.childSymbol)

            node.append(childSymbolNode)

            hasInstrumentLabelNode = Element('HASINSTRUMENTLABEL')

            hasInstrumentLabelNode.text = str(self.hasInstrumentLabel)

            node.append(hasInstrumentLabelNode)

            attributesNode = Element('SYMBOLATTRIBUTES')

            for attr in self.attrs:

                if type(attr) is UserInputAttribute:

                    attributesNode.append(attr.toXml())

                elif type(attr) is not tuple:

                    attributeNode = Element('SYMBOLATTRIBUTE')

                    attributeNode.text = str(attr.uid)

                    attributesNode.append(attributeNode)

                elif type(attr) is tuple and type(self) is QEngineeringSpecBreakItem:

                    attributeNode = Element(attr[0].upper().replace(' ',''))

                    attributeNode.text = str(attr[1] if attr[1] is not None else '')

                    attributesNode.append(attributeNode)

            node.append(attributesNode)

            currentPointModeIndexNode = Element('CURRENTPOINTMODEINDEX')

            currentPointModeIndexNode.text = str(self.currentPointModeIndex)

            node.append(currentPointModeIndexNode)

            if type(self) is QEngineeringSpecBreakItem:

                specBreakOffsetXNode = Element('SPECBREAKOFFSETX')

                specBreakOffsetXNode.text = str(self.specBreak_offsetX)

                node.append(specBreakOffsetXNode)

                specBreakOffsetYNode = Element('SPECBREAKOFFSETY')

                specBreakOffsetYNode.text = str(self.specBreak_offsetY)

                node.append(specBreakOffsetYNode)

        except Exception as ex:

            return str(self.uid)

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

        return node 

    '''

        @brief  generate xml code for attribute

        @author humkyung

        @date   2018.05.02

    '''

    def toXmlAsAttribute(self, parent):

        for attr in self.attrs:

            parent.append(attr.toXml(self))

    '''

        @brief      parse xml code

        @author     humkyung

        @date       2018.07.20

        @history    humkyung 2018.07.20 parse uid from xml node

                    humkyung 2018.07.23 parse connected item's uid from xml node

                    kyouho  2018.07.31 

    '''

    @staticmethod 

    def fromXml(node):

        import uuid

        item = [None, None]

        try:

            uidNode = node.find('UID')

            uid = uidNode.text if uidNode is not None else uuid.uuid4() # generate UUID

            pt = [float(x) for x in node.find('LOCATION').text.split(',')]

            size = [float(x) for x in node.find('SIZE').text.split(',')]

            name = node.find('NAME').text

            angle = float(node.find('ANGLE').text)

            type = node.find('TYPE').text

            origin = [float(x) for x in node.find('ORIGINALPOINT').text.split(',')]

            connPts = []

            if node.find('CONNECTIONPOINT').text is not None:

                connPts = [(float(x.split(',')[0]), float(x.split(',')[1])) for x in node.find('CONNECTIONPOINT').text.split('/')]

            baseSymbol = node.find('PARENT').text

            childSymbolNode = node.find('CHILD')

            childSymbol = ''

            if childSymbolNode is not None:

                childSymbol = childSymbolNode.text

            ownerNode = node.find('OWNER')

            owner = ownerNode.text if ownerNode is not None else None

            hasInstrumentLabelNode = node.find('HASINSTRUMENTLABEL')

            hasInstrumentLabel = hasInstrumentLabelNode.text if hasInstrumentLabelNode is not None else 'False'

            project = AppDocData.instance().getCurrentProject()

            svgFilePath = os.path.join(project.getSvgFilePath(), type, name + '.svg')

            if os.path.isfile(svgFilePath):

                item[0] = SymbolSvgItem.createItem(type, svgFilePath, uid)

                item[0].buildItem(name, type, angle, pt, size, origin, connPts, baseSymbol, childSymbol, hasInstrumentLabel)

                connectors = node.find('CONNECTORS')

                if connectors is not None:

                    iterIndex = 0

                    for connector in connectors.iter('CONNECTOR'):

                        connectedItemStr = connector.find('CONNECTEDITEM').text

                        connectPointStr = connector.find('CONNECTPOINT').text.split(',')

                        sceneConnectPointStr = connector.find('SCENECONNECTPOINT').text.split(',')

                        item[0].connectors[iterIndex].connectedItem = connectedItemStr if connectedItemStr != 'None' else None

                        item[0].connectors[iterIndex].connectPoint = (float(connectPointStr[0]), float(connectPointStr[1]))

                        item[0].connectors[iterIndex].sceneConnectPoint = (float(sceneConnectPointStr[0]), float(sceneConnectPointStr[1]))

                        iterIndex += 1

                attributeValue = node.find('ATTRIBUTEVALUE')

                if attributeValue is not None:

                    item[0].attribute = attributeValue.text

                attributes = node.find('SYMBOLATTRIBUTES')

                if attributes is not None:

                    for attr in attributes.iter('SYMBOLATTRIBUTE'):

                        item[0].attrs.append(attr.text)

                    for attr in attributes.iter('USERINPUTATTRIBUTE'):

                        typeUID = attr.find('TYPEUID').text

                        typeValue = attr.find('TYPEVALUE').text

                        item[0].attrs.append(UserInputAttribute(typeUID, typeValue))

                    if item[0].type == 'Segment Breaks':

                        upStreamNode = attributes.find('UPSTREAM')

                        downStreamNode = attributes.find('DOWNSTREAM')

                        if upStreamNode is not None :

                            item[0].attrs.append(('Up Stream', upStreamNode.text))

                        if downStreamNode is not None:

                            item[0].attrs.append(('Down Stream', downStreamNode.text))

                currentPointModeIndex = node.find('CURRENTPOINTMODEINDEX')

                if currentPointModeIndex is not None:

                    item[0].currentPointModeIndex = int(currentPointModeIndex.text)

                if item[0].type == 'Segment Breaks':

                    specBreakOffsetXNode = node.find('SPECBREAKOFFSETX')

                    specBreakOffsetYNode = node.find('SPECBREAKOFFSETY')

                    if specBreakOffsetXNode is not None and specBreakOffsetYNode is not None:

                        item[0].specBreak_offsetX = float(specBreakOffsetXNode.text)

                        item[0].specBreak_offsetY = float(specBreakOffsetYNode.text)

                        connLoc = item[0].connectors[0]._loc

                        item[0].connectors[0].setPos((float(connLoc[0] + item[0].specBreak_offsetX), float(connLoc[1] + item[0].specBreak_offsetY)))

                        item[0].reSettingSymbol(item[0].getCurrentPoint(), item[0].angle)

                item[1] = owner

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

        return item

    '''

        @brief      create item corresponding to given type

        @author     humkyung

        @date       2018.05.02

        @history    2018.05.08  Jeongwoo    Change type name (Piping OPC''S → Piping OPC's)

                    humkyung 2018.05.10 change symbol's color to blue

                    humkyung 2018.07.19 create nozzle instance if type is 'Nozzles'

    '''

    @staticmethod

    def createItem(type, path, uid=None):

        from QEngineeringOPCItem import QEngineeringOPCItem

        from QEngineeringEquipmentItem import QEngineeringEquipmentItem

        from QEngineeringInstrumentItem import QEngineeringInstrumentItem

        from EngineeringNozzleItem import QEngineeringNozzleItem

        from AppDocData import AppDocData

        docData = AppDocData.instance()

        item = None

        cateogry = docData.getSymbolCategoryByType(type)

        if type == "Piping OPC's":

            item = QEngineeringOPCItem(path, uid)

        elif cateogry == 'Equipment':

            item = QEngineeringEquipmentItem(path, uid)

        elif cateogry == 'Instrumentation':

            item = QEngineeringInstrumentItem(path, uid)

        elif type == 'Nozzles':

            item = QEngineeringNozzleItem(path, uid)

        elif type == 'Segment Breaks':

            item = QEngineeringSpecBreakItem(path, uid)

        else:

            item = SymbolSvgItem(path, uid)

        return item

    '''

        @brief      change svg's color

        @author     humkyung

        @date       2018.05.10

        @history    2018.05.11  Jeongwoo    Override QEngineeringAbstractItem's

                    humkyung 2018.05.13 update after change color

    '''

    def setColor(self, color):

        self._color = color

        self.changeAttributes('fill', color)

        self.changeAttributes('stroke', color)

        self.renderer().load(self._document.toByteArray())

        self.update()

    '''

        @brief      Get Color code

        @author     Jeongwoo

        @date       2018.05.17

    '''

    def getColor(self):

        return self._color

    '''

        @brief  change attributes

        @author humkyung

        @date   2018.05.10

    '''

    def changeAttributes(self, attName, attValue):

        root = self._document.documentElement()

        node = root.firstChild()

        while not node.isNull():

            if node.isElement():

                element = node.toElement()

                if element.hasAttribute(attName):

                    element.setAttribute(attName, attValue)

                if element.hasChildNodes():

                    recursiveChangeAttributes(element.firstChild(), attName, attValue)

            node = node.nextSibling()

    '''

        @brief  change attribute

        @author humkyung

        @date   2018.05.10

    '''

    def recursiveChangeAttributes(self, node, attName, attValue):

        while not node.isNull():

            if node.isElement():

                element = node.toElement()

                if element.hasAttribute(attName):

                    element.setAttribute(attName, attValue)

                if node.hasChildNodes():

                    recursiveChangeAttributes(node.firstChild(), attName, attValue)

            node = node.nextSibling()

    '''

        @brief  draw rect when item is selected

        @author humkyung

        @date   2018.07.07

    '''

    def drawFocusRect(self, painter):

        self.focuspen = QPen(Qt.DotLine)

        self.focuspen.setColor(Qt.black)

        self.focuspen.setWidthF(1.5)

        hilightColor = QColor(255, 0, 0, 127)

        painter.setBrush(QBrush(hilightColor))

        painter.setPen(self.focuspen)

        painter.drawRect(self.boundingRect())

    '''

        @brief  override paint(draw connection points)

        @author humkyung

        @date   2018.04.21

    '''

    def paint(self, painter, options=None, widget=None):

        painter.setClipRect(options.exposedRect)

        QGraphicsSvgItem.paint(self, painter, options, widget)

        if self.isSelected():

            self.drawFocusRect(painter)

    '''

        @brief      Add Svg Item into ImageViewer's Scene

        @author     Jeongwoo

        @date       2018.05.03

        @history    add connectors which's parent is symbol

                    kyouho  2018.07.30  remove connectors logic

    '''

    def addSvgItemToScene(self, scene):

        transform = QTransform()

        transform.translate(self.loc[0] + self.symbolOrigin[0] + self.specBreak_offsetX, self.loc[1] + self.symbolOrigin[1] + self.specBreak_offsetY)

        transform.rotateRadians(-self.angle)

        currentPoint = self.getCurrentPoint()

        transform.translate(-currentPoint[0] - self.specBreak_offsetX, -currentPoint[1] - self.specBreak_offsetY)

        self.setTransform(transform)

        scene.addItem(self)

    '''

        @brief      

        @author     humkyung

        @date       2018.07.27

    '''

    def onConnectorPosChaned(self, connector):

        pass

    '''

        @brief      set connector

        @author     kyouho

        @date       2018.07.26

    '''

    def setConnector(self):

        connector = QEngineeringConnectorItem(self)

        connector.setParentItem(self)

        self.connectors.append(connector)

    '''

    '''

    def refreshConnector(self):

        for connector in self.connectors:

            connector.buildItem()

    '''

        @brief      Delete svg item

        @author     Jeongwoo

        @date       2018.05.25

    '''

    def deleteSvgItemFromScene(self):

        for connector in self.connectors:

            if connector.connectedItem is not None:

                connector.connectedItem.removeSymbol(self)

                break

        self.transfer.onRemoved.emit(self)

    '''

        @brief      Return real item position

        @author     Jeongwoo

        @date       2018.05.25

    '''

    def boundingRectOnScene(self):

        rect = self.boundingRect()

        rect.moveTo(self.loc[0], self.loc[1])

        return rect

    '''

        @brief      rotate Symbol

        @author     kyouho

        @date       2018.07.24

    '''

    def rotateSymbol(self):

        #degree 0

        if 0 == self.angle:

            self.angle = 1.57

        #degree 90

        elif (1.57 == self.angle):

            self.angle = 3.14

        #degree 180

        elif 3.14 == self.angle:

            self.angle = 4.71

        #degree 270

        elif 4.71 == self.angle :

            self.angle = 0

        currentPoint = self.getCurrentPoint()

        self.reSettingSymbol(currentPoint, self.angle)

    '''

        @brief      resetting rotate Symbol

        @author     kyouho

        @date       2018.07.24

    '''

    def reSettingSymbol(self, standardPoint, angle):

        transform = QTransform()

        transform.translate(self.loc[0] + self.symbolOrigin[0] + self.specBreak_offsetX, self.loc[1] + self.symbolOrigin[1] + self.specBreak_offsetY)

        transform.rotateRadians(-angle)

        transform.translate(-standardPoint[0] - self.specBreak_offsetX, -standardPoint[1] - self.specBreak_offsetY)

        self.setTransform(transform)

        from EngineeringLineItem import QEngineeringLineItem

        for connector in self.connectors:

            if connector.connectedItem is not None and type(connector.connectedItem) == QEngineeringLineItem:

                line = connector.connectedItem

                line.reDrawLine(self, connector.center())

    '''

        @brief      change Conn point 

        @author     kyouho

        @date       2018.07.25

    '''

    def changeConnPoint(self):

        if len(self.connectors) == 2:

            conn1Item = self.connectors[0].connectedItem

            conn2Item = self.connectors[1].connectedItem

            self.connectors[0].connectedItem = conn2Item

            self.connectors[1].connectedItem = conn1Item

            currentPoint = self.getCurrentPoint()

            self.reSettingSymbol(currentPoint, self.angle)

    '''

        @brief      change standard point

        @author     kyouho

        @date       2018.07.24

    '''

    def changeStandardPoint(self):

        connPtsCount = len(self.connectors)