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 EngineeringConnectorItem import QEngineeringConnectorItem

from UserInputAttribute import UserInputAttribute

import SelectAttributeCommand

class SymbolSvgItem(QGraphicsSvgItem, QEngineeringAbstractItem):

    """ This is symbolsvgitem class """

    clicked = pyqtSignal(QGraphicsSvgItem)

    ZVALUE = 50

    HOVER_COLOR = 'url(#hover)'

    '''

        @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, flip=0):

        import uuid

        from SymbolAttr import SymbolProp

        QGraphicsSvgItem.__init__(self)

        QEngineeringAbstractItem.__init__(self)

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

        self.uid = uuid.uuid4() if uid is None else uuid.UUID(uid, version=4)

        self.name = ''

        self.type = ''

        self.angle = 0

        self.origin = None

        self.loc = None

        self.size = None

        self._owner = None

        self.parentSymbol = ''

        self.childSymbol = '' 

        self.hasInstrumentLabel = 0

        self.flip = flip

        # attributeType uid

        self.attribute = ''

        self._properties = {SymbolProp(None, 'Supplied By', 'String'):None}

        self.setAcceptDrops(True)

        self.setAcceptHoverEvents(True)

        self.setAcceptedMouseButtons(Qt.LeftButton)

        self.setAcceptTouchEvents(True)

        self.currentCursor = 0

        self.transfer = Transfer()

        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._color = self.get_attribute('fill')

        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)

        app_doc_data = AppDocData.instance()

        configs = app_doc_data.getConfigs('Symbol Style', 'Opacity')

        self.setOpacity(float(configs[0].value)/100 if configs else 0.5)

    '''

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

    @property

    def properties(self):

        """ getter of properties """

        import uuid

        for prop,value in self._properties.items():

            if prop.is_selectable and type(value) is uuid.UUID:

                matches = [x for x in self.scene().items() if hasattr(x, 'uid') and str(x.uid) == str(value)]

                if matches: self._properties[prop] = matches[0]

        return self._properties

    @properties.setter

    def properties(self, value):

        """ setter of properties """

        self._properties = value

    def set_property(self, property, value):

        """ set property with given value """

        matches = [prop for prop,_ in self._properties.items() if prop.Attribute == property]

        if matches: self._properties[matches[0]] = value

    def validate(self):

        '''

            @brief  validation check : flow

            @author euisung

            @date   2019.04.16

        '''

        from EngineeringErrorItem import QEngineeringErrorItem

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringSpecBreakItem import QEngineeringSpecBreakItem

        errors = []

        if type(self) is QEngineeringSpecBreakItem:

            return errors

        docdata = AppDocData.instance()

        dataPath = docdata.getErrorItemSvgPath()

        origin = [int(pt) for pt in docdata.getAppConfigs('app', 'error origin point')[0].value.split(',')]

        # check flow for 2 connection point symbol

        if len(self.connectors) is 2:

            if type(self.connectors[0].connectedItem) is QEngineeringLineItem and type(self.connectors[1].connectedItem) is QEngineeringLineItem:

                if self.includes(self.connectors[0].connectedItem.startPoint(), 5) is not self.includes(self.connectors[1].connectedItem.endPoint(), 5):

                    #print(self.sceneBoundingRect())

                    error = SymbolSvgItem.createItem('Error', dataPath)

                    error.parent = self

                    error.msg = 'flow error'

                    error.setToolTip(error.msg)

                    error.area = 'Drawing'

                    error.name = 'Error'

                    errors.append(error)

        # check disconnected point

        disconnect = False

        if len(self.connectors) is not 0:

            disconnect = True

            for connector in self.connectors:

                if connector.connectedItem is not None:

                    disconnect = False

                    break

        if disconnect:

            error = SymbolSvgItem.createItem('Error', dataPath)

            error.parent = self

            error.msg = 'disconnected'

            error.setToolTip(error.msg)

            error.area = 'Drawing'

            error.name = 'Error'

            errors.append(error)

        # set error position

        #denominator = len(errors) + 1

        #molecule = 1

        for error in errors:

            error.setPosition([self.sceneBoundingRect().center().x(), self.sceneBoundingRect().center().y()], origin)

            #molecule = molecule + 1

        return errors

    def includes(self, pt, margin=0):

        """

        return True if symbol contains given point else return False

        """

        rect = self.sceneBoundingRect()

        minX = rect.x() - margin

        minY = rect.y() - margin

        maxX = minX + rect.width() + margin

        maxY = minY + rect.height() + margin

        return True if (pt[0] >= minX and pt[0] <= maxX and pt[1] >= minY and pt[1] <= maxY) else False

    def associations(self):

        """

        return associated instance

        """

        import uuid

        res = []

        for key in self._associations.keys():

            for assoc in self._associations[key]:

                # find owner with uid

                if assoc and type(assoc) is uuid.UUID:

                    matches = [x for x in self.scene().items() if hasattr(x, 'uid') and str(x.uid) == str(assoc)]

                    if matches: res.append(matches[0]) # TODO: need to update association with instance

                # up to here

                elif assoc:

                    res.append(assoc)

        return res

    def texts(self):

        """

        return text type of associations

        """

        from EngineeringTextItem import QEngineeringTextItem

        return [x for x in self.associations() if issubclass(type(x), QEngineeringTextItem)]

    def symbols(self):

        """

        return symbol type of associations

        """

        return [x for x in self.associations() if issubclass(type(x), SymbolSvgItem)]

    def toSql(self):

        """

        convert valve data to sql query

        """

        import uuid

        from AppDocData import AppDocData

        res = []

        appDocData = AppDocData.instance()

        cols = ['UID', 'ITEM_NO', 'PNID_NO']

        values = ['?','?','?']

        param = [str(self.uid), self.name, appDocData.activeDrawing.name]

        sql = 'insert or replace into VALVE_DATA_LIST({}) values({})'.format(','.join(cols), ','.join(values))

        res.append((sql, tuple(param)))

        _attrs = self.getAttributes()

        for key in _attrs.keys():

            cols = ['UID', 'Components_UID', 'SymbolAttribute_UID', 'Value']

            values = ['?', '?', '?', '?']

            param = [str(uuid.uuid4()), str(self.uid), key.UID, _attrs[key]]

            sql = 'insert or replace into Attributes({}) values({})'.format(','.join(cols), ','.join(values))

            res.append((sql, tuple(param)))

        # save connectors to database

        for connector in self.connectors:

            res.append(connector.toSql())

        # up to here

        return res

    '''

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

            if self.flip is 1:

                self.symbolOrigin[0] = self.size[0] - self.symbolOrigin[0]

            # setting connectors

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

            #print(connectionPoints)

            for index in range(len(connectionPoints)):

                if connectionPoints[index] == '':

                    break

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

                direction = 'AUTO'

                symbol_idx = '0'

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

                elif len(tokens) == 4:

                    direction = tokens[0]

                    x = float(tokens[1])

                    y = float(tokens[2])

                    symbol_idx = tokens[3]

                self.setConnector()

                self.connectors[index].direction = direction

                self.connectors[index].symbol_idx = symbol_idx

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

                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]) == 3 else \

                                                           (connPts[index][1], connPts[index][2]) if len(connPts[index]) == 4 else None

            self.parentSymbol = parentSymbol

            self.childSymbol = childSymbol

            self.hasInstrumentLabel = hasInstrumentLabel

            self.currentPointModeIndex = 0

            tooltip = '<b>{}</b><br>{}={}'.format(str(self.uid), self.type, self.name)

            self.setToolTip(tooltip)

        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 is_connectable(self, line, toler=10):

        start_pt = line.startPoint()

        end_pt = line.endPoint()

        for connector in self.connectors:

            dx = connector.sceneConnectPoint[0] - (start_pt[0])

            dy = connector.sceneConnectPoint[1] - (start_pt[1])

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

            dx = connector.sceneConnectPoint[0] - (end_pt[0])

            dy = connector.sceneConnectPoint[1] - (end_pt[1])

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

        return False

    '''

        @author     humkyung

        @date       2018.07.03

    '''

    def is_connected(self, item, at=QEngineeringAbstractItem.CONNECTED_AT_PT):

        """ check if given item is connected to self """

        _connectors = [connector for connector in self.connectors if (connector.connectedItem == item and (connector._connected_at == at if at else True))]

        return len(_connectors) > 0

    def next_connected(self, lhs, rhs):

        """ tes given two item's are next connected(ex: 0-1, 2-3) """

        lhs_matches = [at for at in range(len(self.connectors)) if self.connectors[at].connectedItem == lhs]

        rhs_matches = [at for at in range(len(self.connectors)) if self.connectors[at].connectedItem == rhs]

        if lhs_matches and rhs_matches:

            return (lhs_matches[0] in [0,1] and rhs_matches[0] in [0,1]) or (lhs_matches[0] in [2,3] and rhs_matches[0] in [2,3])

        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 connect_if_possible(self, obj, toler=10):

        from shapely.geometry import Point

        from EngineeringLineItem import QEngineeringLineItem

        res = []

        try:

            if type(obj) is QEngineeringLineItem:

                startPt = obj.startPoint()

                endPt = obj.endPoint()

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

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

                        if self.connectors[i].connectedItem is None:

                            self.connectors[i].connect(obj)

                        if obj.connectors[0].connectedItem is None:

                            obj.connectors[0].connect(self)

                        res.append(obj)

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

                        if self.connectors[i].connectedItem is None:

                            self.connectors[i].connect(obj)

                        if obj.connectors[1].connectedItem is None:

                            obj.connectors[1].connect(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 (_pt.distance(Point(self.connectors[i].sceneConnectPoint[0], self.connectors[i].sceneConnectPoint[1])) < toler):

                            if self.connectors[i].connectedItem is None:

                                self.connectors[i].connect(obj)

                            if obj.connectors[j].connectedItem is None:

                                obj.connectors[j].connect(self)

                            res.append(obj)

        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)

        return res

    '''

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

            self.hover = True

            self.update()

            for assoc in self.associations():

                assoc.hoverEnterEvent(event)

        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      unhighlight connector and attribute

        @author     humkyung

        @date       2018.05.02

        @history    kyouho 2018.07.18 edit ArrowCursor

    '''

    def hoverLeaveEvent(self, event):

        self.hover = False

        self.update()

        for assoc in self.associations():

            assoc.hoverLeaveEvent(event)

    '''

        @brief      set highlight

        @author     kyouho

        @date       2018.08.27

    '''

    def setHightlight(self):

        self.setColor('url(#hover)')

        self.update()

    '''

        @brief      unset highlight

        @author     kyouho

        @date       2018.08.27

    '''

    def unsetHightlight(self):

        self.setColor('url(#normal)')

        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

    '''

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

    #def dropEvent(self, event):

    #    '''

    #        @brief      Mouse Drop Event

    #        @author     euisung

    #        @date       2019.04.01

    #    '''

    #    print('d')

    #    super().dropEvent(event)

    #def dragLeaveEvent(self, event):

    #    print('l')

    def removeSelfAttr(self, attributeName):

        for attr in self.attrs:

            if attr.Attribute == attributeName:

                del self.attrs[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 self.isSelected() and 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()

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

            self.flipSymbol()

    '''

        @brief      connect attribute

        @author     humkyung

        @date       2018.05.02

        @history    humkyung 2018.05.09 append only nearest size attribute

    '''

    def connectAttribute(self, attributes, clear=True):

        import math

        from EngineeringTextItem import QEngineeringTextItem

        from QEngineeringSizeTextItem import QEngineeringSizeTextItem

        from EngineeringInstrumentItem import QEngineeringInstrumentItem

        from EngineeringValveOperCodeTextItem import QEngineeringValveOperCodeTextItem

        if clear:

            self.attrs.clear()

            self._associations.clear()

        try:

            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 or type(attr) is QEngineeringValveOperCodeTextItem or type(attr) is QEngineeringTextItem:

                    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

                elif type(attr) is QEngineeringInstrumentItem:

                    if not attr.is_connected:

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

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

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

                            self.add_assoc_item(attr)

            if selected is not None:

                self.add_assoc_item(selected)

        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      Double click event, Show rotate symbol dialog

        @author     euisung

        @date       2019.04.16

    '''

    def mouseDoubleClickEvent(self, event):

        from RotateSymbolDialog import QRotateSymbolDialog

        dialog = QRotateSymbolDialog(None, self.angle)

        (isAccept, angle) = dialog.showDialog()

        if isAccept:

            self.rotateSymbol(angle)

    '''

        @brief      get attribute

        @author     humkyung

        @date       2018.06.14

        @history    kyouho  2018.07.18  Add only attr QEngineeringTextItem

    '''

    def getAttributes(self):

        _attrs = {}

        try:

            from AppDocData import AppDocData

            from EngineeringAbstractItem import QEngineeringAbstractItem

            from EngineeringTextItem import QEngineeringTextItem

            from EngineeringValveOperCodeTextItem import QEngineeringValveOperCodeTextItem

            # 해당 Type의 attribute setting

            docData = AppDocData.instance()

            symbolAttrs = docData.getSymbolAttribute(self.type)

            _texts = self.texts()

            _symbols = self.symbols()

            for attr in symbolAttrs:

                if attr.AttributeType == 'Size Text Item' or attr.AttributeType == 'Text Item' or attr.AttributeType == 'Valve Oper Code':

                    at = int(attr.AttrAt)

                    items = [text for text in _texts if QEngineeringAbstractItem.assoc_type(text) == attr.AttributeType]

                    if len(items) > at:

                        item = items[at]

                        _attrs[attr] = eval(attr.Expression) if attr.Expression else ''

                    else:

                        _attrs[attr] = ''

                elif attr.AttributeType == 'Symbol Item':

                    at = int(attr.AttrAt)

                    if len(_symbols) > at:

                        item = _symbols[at]

                        _attrs[attr] = eval(attr.Expression) if attr.Expression else ''

                    else:

                        _attrs[attr] = ''

                else:

                    matches = [prop for prop in self.attrs if prop.UID == attr.UID]

                    if len(matches) == 1:

                        _attrs[matches[0]] = self.attrs[matches[0]]

                    else:

                        _attrs[attr] = ''

        except Exception as ex:

            from App import App 

            from AppDocData import MessageType

            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)

        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 

                    humkyung 2018.09.06 write area to xml

    '''

    def toXml(self):

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

        from EngineeringAbstractItem import QEngineeringAbstractItem

        from EngineeringTextItem import QEngineeringTextItem

        from EngineeringSpecBreakItem import QEngineeringSpecBreakItem

        from SymbolAttr import SymbolAttr

        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('ASSOCIATIONS')

            for assoc in self.associations():

                assoc_node = Element('ASSOCIATION')

                assoc_node.attrib['TYPE'] = QEngineeringAbstractItem.assoc_type(assoc)

                assoc_node.text = str(assoc.uid)

                attributeValueNode.append(assoc_node)

            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:

                connectorsNode.append(connector.toXml())

            node.append(connectorsNode)

            connectionNode = Element('CONNECTIONPOINT')

            connection_point = []

            if self.connectors is not None:

                for connector in self.connectors:

                    connection_point.append(repr(connector))

            connectionNode.text = '/'.join(connection_point)

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

            sizeNode.text = '{},{}'.format(self.size[0], self.size[1])

            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)

            areaNode = Element('AREA')

            areaNode.text = self.area

            node.append(areaNode)

            flipNode = Element('FLIP')

            flipNode.text = str(self.flip)

            node.append(flipNode)

            properties_node = Element('PROPERTIES')

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

                prop_node = prop.toXml()

                prop_node.text = '' if not value else str(value.uid) if prop.is_selectable else str(value)

                properties_node.append(prop_node)

            node.append(properties_node)

            attributesNode = Element('SYMBOLATTRIBUTES')

            _attrs = self.getAttributes()

            for attr in _attrs:

                if type(attr) is SymbolAttr:

                    _node = attr.toXml()

                    _node.text = _attrs[attr]

                    attributesNode.append(_node)

                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)

        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)

            return None

        return node 

    '''

        @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 

                    humkyung 2018.09.06 assign area to item

    '''

    @staticmethod 

    def fromXml(node):

        import uuid

        from EngineeringSpecBreakItem import QEngineeringSpecBreakItem

        from SymbolAttr import SymbolAttr

        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:

                for conn_pt in node.find('CONNECTIONPOINT').text.split('/'):

                    tokens = conn_pt.split(',')

                    connPts.append(('AUTO', float(tokens[0]), float(tokens[1]), '0') if len(tokens) == 2 else \

                                   (tokens[0], float(tokens[1]), float(tokens[2]), '0') if len(tokens) == 3 else \

                                   (tokens[0], float(tokens[1]), float(tokens[2]), tokens[3]))

            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'

            flipLabelNode = node.find('FLIP')

            flipLabel = int(flipLabelNode.text) if flipLabelNode is not None else 0

            appDocData = AppDocData.instance()

            project = appDocData.getCurrentProject()

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

            if os.path.isfile(svgFilePath):

                item[0] = SymbolSvgItem.createItem(_type, svgFilePath, uid, flip=flipLabel)

                item[0].setVisible(False)

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

                for prop_node in node.iter('PROPERTY'):

                    matches = [prop for prop in item[0]._properties.keys() if prop.Attribute == prop_node.attrib['Attribute']]

                    if matches:

                        matches[0].parse_xml(prop_node)

                        item[0]._properties[matches[0]] = uuid.UUID(prop_node.text) if prop_node.text and matches[0].is_selectable else prop_node.text if prop_node.text else ''

                ## assign area

                areaNode = node.find('AREA')

                if areaNode is None:

                    for area in appDocData.getAreaList():

                        if area.contains(pt):

                            item[0].area = area.name

                            break

                else:

                    item[0].area = areaNode.text

                ## up to here

                connectors = node.find('CONNECTORS')

                if connectors is not None:

                    iterIndex = 0

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

                        item[0].connectors[iterIndex].parse_xml(connector)

                        iterIndex += 1

                # get associations 

                attributeValue = node.find('ASSOCIATIONS')

                if attributeValue is not None:

                    for assoc in attributeValue.iter('ASSOCIATION'):

                        _type = assoc.attrib['TYPE']

                        if not _type in item[0]._associations:

                            item[0]._associations[_type] = []

                        item[0]._associations[_type].append(uuid.UUID(assoc.text))

                # up to here

                attributes = node.find('SYMBOLATTRIBUTES')

                if attributes is not None:

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

                        _attr = SymbolAttr.fromXml(attr)

                        if type(item[0]) is not QEngineeringSpecBreakItem:

                            item[0].attrs[_attr] = attr.text

                        else:

                            if _attr.AttributeType == 'Spec':

                                item[0].attrs[_attr] = [attr.text.split(',')[0], attr.text.split(',')[1]]

                            elif _attr.Attribute == 'UpStream':

                                for initKey in item[0].attrs.keys():

                                    if initKey.Attribute == 'UpStream':

                                        item[0].attrs[initKey] = attr.text

                            elif _attr.Attribute == 'DownStream':

                                for initKey in item[0].attrs.keys():

                                    if initKey.Attribute == 'DownStream':

                                        item[0].attrs[initKey] = 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))

                currentPointModeIndex = node.find('CURRENTPOINTMODEINDEX')

                if currentPointModeIndex is not None:

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

                if type(item[0]) is QEngineeringSpecBreakItem:

                    item[0].connectors[0].setPos((item[0].connectors[0].connectPoint[0], item[0].connectors[0].connectPoint[1]))

                item[1] = owner

        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)

        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, flip=0):

        from QEngineeringOPCItem import QEngineeringOPCItem

        from EngineeringEquipmentItem import QEngineeringEquipmentItem

        from EngineeringInstrumentItem import QEngineeringInstrumentItem

        from EngineeringNozzleItem import QEngineeringNozzleItem

        from EngineeringSpecBreakItem import QEngineeringSpecBreakItem

        from EngineeringReducerItem import QEngineeringReducerItem

        from EngineeringErrorItem import QEngineeringErrorItem

        from AppDocData import AppDocData

        docData = AppDocData.instance()

        item = None

        cateogry = docData.getSymbolCategoryByType(type)

        if type == "Piping OPC's":

            item = QEngineeringOPCItem(path, uid, flip=flip)

        elif cateogry == 'Equipment':

            item = QEngineeringEquipmentItem(path, uid, flip=flip)

        elif cateogry == 'Instrumentation':

            item = QEngineeringInstrumentItem(path, uid, flip=flip)

        elif type == 'Nozzles':

            item = QEngineeringNozzleItem(path, uid, flip=flip)

        elif type == 'Segment Breaks':

            item = QEngineeringSpecBreakItem(path, uid, flip=flip)

        elif type == 'Reducers':

            item = QEngineeringReducerItem(path, uid, flip=flip)

        elif type == 'Error':

            item = QEngineeringErrorItem(path, uid, flip=flip)

        else:

            item = SymbolSvgItem(path, uid, flip=flip)

        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

    '''