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 PyQt5.QtWidgets import QGraphicsView, QGraphicsScene, QFileDialog, QMessageBox

from AppDocData import *

from EngineeringAbstractItem import QEngineeringAbstractItem

from EngineeringConnectorItem import QEngineeringConnectorItem

from EngineeringEqpDescTextItem import QEngineeringEqpDescTextItem

class SymbolSvgItem(QGraphicsSvgItem, QEngineeringAbstractItem):

    """ This is symbolsvgitem class """

    clicked = pyqtSignal(QGraphicsSvgItem)

    ZVALUE = 100

    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 | QGraphicsItem.ItemSendsGeometryChanges)

        self.dbUid = None

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

        self.name = ''

        self.category = ''

        self.type = ''

        self.angle = 0

        self._scale = 1

        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:

            from App import App

            from AppDocData import MessageType

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

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

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

        finally:

            f.close()

        self.setZValue(SymbolSvgItem.ZVALUE)

        self._desc_label = QEngineeringEqpDescTextItem('eqp name<br>pressure drop<br>elevation', self)

    def __str__(self):

        """ return string represent uuid """

        return str(self.uid)

    '''

        @breif  getter owner

        @author humkyung

        @date   2018.05.10

    '''

    @property

    def owner(self):

        import uuid

        if self._owner and type(self._owner) is uuid.UUID:

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

            if matches: self._owner = matches[0]

        if type(self._owner) is not uuid.UUID and type(self._owner) is not str:

            return self._owner

        else:

            self._owner = None

            return None

    '''

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

            try:

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

                    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]

                if prop.Expression:

                    item = self._properties[prop]  # assign item

                    self._properties[prop] = eval(prop.Expression)

            except Exception as ex:

                from App import App

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

        if issubclass(type(value), QEngineeringAbstractItem): self.add_assoc_item(value, 0)

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

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

    def prop(self, name):

        """ return the value of given property with name """

        matches = [(prop, value) for prop, value in self.properties.items() if prop.Attribute == name]

        if matches: return matches[0][1]

        return None

    @property

    def desc_label(self):

        """ return equipment description label """

        return self._desc_label

    @property

    def Size(self):

        """ return valve's size """

        from QEngineeringSizeTextItem import QEngineeringSizeTextItem

        matches = [assoc for assoc in self.associations() if type(assoc) is QEngineeringSizeTextItem]

        if matches:

            return matches[0].text()

        else:

            return None

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

        """ return True if symbol contains given point else return False """

        rect = self.sceneBoundingRect()

        allowed_error = 0.1

        if abs(rect.x() - 0) <= allowed_error and abs(rect.y() - 0) <= allowed_error:

            # when first recognition step, symbols are not in scene(not yet added) therefore cannot use scenebounding rect

            minX = self.loc[0] - margin

            minY = self.loc[1] - margin

            maxX = minX + self.size[0] + margin

            maxY = minY + self.size[1] + margin

        else:

            minX = rect.x() - margin

            minY = rect.y() - margin

            maxX = minX + rect.width() + margin

            maxY = minY + rect.height() + margin

        # print([minX, minY, maxX, maxY])

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

    def toSql(self):

        """ convert valve data to sql query """

        import uuid

        from AppDocData import AppDocData

        res = []

        appDocData = AppDocData.instance()

        rect = self.sceneBoundingRect()

        cols = ['UID', 'Symbols_UID', 'X', 'Y', 'Rotation', 'Scale']

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

        param = [str(self.uid), str(self.dbUid), rect.left(), rect.top(), str(self.angle), self.transform().m11()]

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

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

        # save connectors to database

        index = 1

        for connector in self.connectors:

            res.extend(connector.toSql(index))

            index += 1

        # 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, scale, loc, origin, connPts, dbUid=None, pointsUids=None):

        try:

            if not hasattr(self, 'counters'): self.counters = {}

            if name in self.counters:

                self.counters[name] += 1

            else:

                self.counters[name] = 1

            self.name = name

            self.index = self.counters[name]

            self.type = _type

            self.angle = angle

            self._scale = scale

            self.loc = loc

            docData = AppDocData.instance()

            if dbUid is None:

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

            else:

                symbolInfo = docData.getSymbolByQuery('UID', dbUid)

            self.dbUid = symbolInfo.uid

            self.category = symbolInfo.sCategory

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

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

            # setting connectors

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

            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]

                if pointsUids:

                    self.set_connector(pointsUids[index], index + 1)

                else:

                    self.set_connector(None, index + 1)

                self.connectors[index].direction = direction

                self.connectors[index].symbol_idx = symbol_idx

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

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

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

            self.setToolTip(tooltip)

            self.build_label()

        except Exception as ex:

            from App import App

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

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

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

    def build_label(self):

        """ build equipment label """

        rect = self.boundingRect()

        if self.name in ('CV_H', 'CV_V') or self.name == 'Line_Splitter' or self.name in ('Filter_H', 'Filter_V'):

            data = self.connectors[0].data

            self.desc_label.setHtml(f"{self.name}<br>{data.pressure_drop} kg/cm2<br>{data.elevation} m")

        elif self.name in ('Y_Strainer_H', 'Y_Strainer_V'):

            data = self.connectors[0].data

            self.desc_label.setHtml(f"{self.name}<br>{data.pressure_drop} kg/cm2<br>{data.elevation} m")

        elif self.name in ('L_Pump', 'R_Pump', 'V_Pump'):

            data = self.connectors[0].data

            self.desc_label.setHtml(f"{self.name}<br>{data.pressure_drop} kg/cm2<br>{data.elevation} m")

        elif self.name in ('Ori_Flowmeter_H', 'Oth_Flowmeter_H', 'Ven_Flowmeter_H', 'Ori_Flowmeter_V', 'Oth_Flowmeter_V',

                           'Ven_Flowmeter_V'):

            data = self.connectors[0].data

            self.desc_label.setHtml(f"{self.name}<br>{data.pressure_drop} kg/cm2<br>{data.elevation} m")

        elif self.name in ('HEX_V', 'HEX_DP', 'HEX_H', 'HEX_K', 'HEX_V'):

            data = [conn.data for conn in self.connectors

                    if conn.data and (conn.data.pressure_drop is not None or conn.data.elevation is not None)]

            if data:

                self.desc_label.setHtml(f"{self.name}<br>{data[0].pressure_drop} kg/cm2<br>{data[0].elevation} m")

        elif self.name == 'M_DP_E':

            data = [conn.data for conn in self.connectors

                    if conn.data and (conn.data.pressure_drop is not None or conn.data.elevation is not None)]

            if data:

                self.desc_label.setHtml(f"{self.name}<br>{data[0].pressure_drop} kg/cm2<br>{data[0].elevation} m")

        elif self.type == 'Battery Limit':

            data = [conn.data for conn in self.connectors

                    if conn.data and (conn.data.pressure_drop is not None or conn.data.elevation is not None)]

            if data:

                self.desc_label.setHtml(f"{self.name}<br>{data[0].pressure} kg/cm2(g)<br>{data[0].elevation} m")

        else:

            self.desc_label.setHtml(f"{self.name}")

        self.desc_label.setPos(QPointF(rect.width(), 0))

    '''

        @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, item, toler=10):

        # from EngineeringLineItem import QEngineeringLineItem

        '''

        if False:#type(item) is QEngineeringLineItem:

            line = item

            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

        elif True:#issubclass(type(item), SymbolSvgItem):

        '''

        for connector in self.connectors:

            for iConnector in item.connectors:

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

                dy = connector.sceneConnectPoint[1] - iConnector.sceneConnectPoint[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):

        """ check 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 occurred({}) 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):

        from Resizer import Resizer

        self.highlight(True)

        ''' 잠시 주석 처리 

        """ create a resizer """

        resizer = Resizer.instance()

        resizer.connected = self

        resizerWidth = resizer.rect.width() / 2

        rect = self.sceneBoundingRect()

        resizerOffset = QPointF(resizerWidth, resizerWidth)

        resizer.setPos(rect.bottomRight() - resizerOffset)

        if resizer.receivers(resizer.resizeSignal) > 0: resizer.resizeSignal.disconnect()

        resizer.resizeSignal.connect(self.resize)

        try:

            self.transfer.on_pos_changed.disconnect(resizer.on_symbol_pos_changed)

        except Exception as ex:

            pass

        self.transfer.on_pos_changed.connect(resizer.on_symbol_pos_changed)

        resizer.setVisible(True)

        if not resizer.scene(): self.scene().addItem(resizer)

        '''

    '''

        @brief      unhighlight connector and attribute

        @author     humkyung

        @date       2018.05.02

        @history    kyouho 2018.07.18 edit ArrowCursor

    '''

    def hoverLeaveEvent(self, event):

        self.highlight(False)

    def highlight(self, flag):

        """ highlight/unhighlight the symbol """

        try:

            self.hover = flag

            self.setZValue(QEngineeringAbstractItem.HOVER_ZVALUE) if flag else self.setZValue(SymbolSvgItem.ZVALUE)

            self.update()

        except Exception as ex:

            from App import App

            message = 'error occurred({}) 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      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      call on_pos_changed signal

        @author     humkyung

        @date       19.07.17

    '''

    def mouseReleaseEvent(self, event):

        super().mouseReleaseEvent(event)

    def itemChange(self, change, value):

        """ call signals when item's position is changed """

        if change == QGraphicsItem.ItemPositionHasChanged:

            self.transfer.on_pos_changed.emit(self)

            return value

        return super().itemChange(change, value)

    def removeSelfAttr(self, attributeName):

        target = None

        for attr in self.attrs:

            if attr.Attribute == attributeName:

                target = attr

                break

        if target:

            del self.attrs[attr]

    '''

        @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 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 not self.isSelected(): return

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

            self.deleteSvgItemFromScene()

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

            self.mouseDoubleClickEvent(event)

    '''

        @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

        try:

            if clear:

                self.clear_attr_and_assoc_item()

            configs = AppDocData.instance().getConfigs('Range', 'Detection Ratio')

            ratio = float(configs[0].value) if 1 == len(configs) else 1.5

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

            center = self.sceneBoundingRect().center()

            minDist = None

            selected = None

            for attr in attributes:

                # size text and operation code text will find onwer themselves in findowner method

                if False:  # type(attr) is QEngineeringSizeTextItem or type(attr) is QEngineeringValveOperCodeTextItem:

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

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

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

                    if (length < dist) 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:

                            if self.add_assoc_item(attr):

                                attr.owner = self

            if selected is not None:

                if self.add_assoc_item(selected):

                    selected.owner = self

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

        func_map = [

            (('Equipment - [ Pressure Drop ]', 'Air Fin Cooler', 'AF_Cooler'), self.show_AirFinCooler),

            (('Equipment - [ Pressure Drop ]', 'Filter', ('Filter_H', 'Filter_V')), self.show_Filter),

            (('Equipment - [ Pressure Drop ]', 'Heat Exchanger', ('HEX_DP', 'HEX_H', 'HEX_K', 'HEX_V')),

             self.show_ShlTubHeatExchanger),

            (('Equipment - [ Pressure Drop ]', 'Heat Exchanger', ('HEX_P')), self.show_PlateHeatExchanger),

            (('Equipment - [ Pressure Drop ]', 'Miscellaneous', ('M_Coil')), self.show_Coil),

            (('Equipment - [ Pressure Drop ]', 'Miscellaneous', ('M_DP_E')), self.show_DP_Equipment),

            (('Equipment - [ Pressure Drop ]', 'Miscellaneous', ('M_React')), self.show_Reactor),

            (('Equipment - [ Pressure Drop ]', 'Strainer', ('T_Strainer_H', 'T_Strainer_V')), self.show_Strainer_T),

            (('Equipment - [ Pressure Drop ]', 'Strainer', ('Y_Strainer_H', 'Y_Strainer_V')), self.show_Strainer_Y),

            (('Equipment - [ Pressurized ]', 'Battery Limit', None), self.show_BatteryLimit),

            (('Equipment - [ Pressurized ]', 'Column', ('CwT')), self.show_Tray),

            (('Equipment - [ Pressurized ]', 'Column', ('CwP_Single')), self.show_SinglePacked),

            (('Equipment - [ Pressurized ]', 'Column', ('CwP_Dual')), self.show_DualPacked),

            (('Equipment - [ Pressurized ]', 'Drum', ('Drum_H')), self.show_Drum_Horizontal),

            (('Equipment - [ Pressurized ]', 'Drum', ('Drum_V')), self.show_Drum_Vertical),

            (('Equipment - [ Pressurized ]', 'Miscellaneous', ('ME')), self.show_Equipment),

            (('Equipment - [ Pressurized ]', 'Tank', ('Ball_Tank')), self.show_Ball),

            (('Equipment - [ Pressurized ]', 'Tank', ('CRT')), self.show_ConeRoof),

            (('Equipment - [ Pressurized ]', 'Tank', ('DRT')), self.show_DomeRoof),

            (('Equipment - [ Rotating ]', 'Compressor', ('L_Comp', 'R_Comp')), self.show_Compressor),

            (('Equipment - [ Rotating ]', 'Pump', ('L_Pump', 'R_Pump', 'V_Pump')), self.show_Pump),

            (('Instrument', 'Valve', ('CV_H', 'CV_V')), self.show_ValveControl),

            (('Instrument', 'Valve', ('MV_H', 'MV_V')), self.show_ValveManual),

            (('Instrument', 'Line Splitter', ('Line_Splitter')), self.show_LineSplitter),

            (('Instrument', 'Flowmeter', (

                'Ori_Flowmeter_H', 'Oth_Flowmeter_H', 'Ven_Flowmeter_H', 'Ori_Flowmeter_V', 'Oth_Flowmeter_V',

                'Ven_Flowmeter_V')), self.show_Flowmeter),

            (('Instrument', 'Reducer', ('Re_Ex_Dw', 'Re_Ex_L', 'Re_Ex_R', 'Re_Ex_Up')), self.show_Reducer)

        ]

        connectedItems = [connector for connector in self.connectors if connector.connectedItem is not None]

        if len(connectedItems) < 1:

            msg = QMessageBox()

            msg.setIcon(QMessageBox.Information)

            msg.setText(self.tr('Connect Line before Data input'))

            msg.setWindowTitle(self.tr("Notice"))

            msg.setStandardButtons(QMessageBox.Ok)

            msg.exec_()

            return

        matches = [func for func in func_map if func[0][0] == self.category and func[0][1] == self.type and (

                func[0][2] is None or self.name in func[0][2])]

        if matches: matches[0][1]()

    def show_AirFinCooler(self):

        from AirFinCooler import QAirFinCooler

        dialog = QAirFinCooler()

        dialog.showDialog(self)

    def show_Filter(self):

        from Filter import QFilter

        dialog = QFilter()

        dialog.showDialog(self)

    def show_Coil(self):

        from Coil import QCoil

        dialog = QCoil()

        dialog.showDialog(self)

    def show_DP_Equipment(self):

        from DP_Equipment import QDP_Equipment

        dialog = QDP_Equipment()

        dialog.showDialog(self)

    def show_Reactor(self):

        from Reactor import QReactor

        dialog = QReactor()

        dialog.showDialog(self)

    def show_Strainer_T(self):

        from Strainer_T import QStrainer_T

        dialog = QStrainer_T()

        dialog.showDialog(self)

    def show_Strainer_Y(self):

        from Strainer_Y import QStrainer_Y

        dialog = QStrainer_Y()

        dialog.showDialog(self)

    def show_BatteryLimit(self):

        from BatteryLimit import QBatteryLimit

        dialog = QBatteryLimit()

        dialog.showDialog(self)

    def show_Tray(self):

        from Tray import QTray

        dialog = QTray()

        dialog.showDialog(self)

    def show_SinglePacked(self):

        from SinglePacked import QSinglePacked

        dialog = QSinglePacked()

        dialog.showDialog(self)

    def show_DualPacked(self):

        from DualPacked import QDualPacked

        dialog = QDualPacked()

        dialog.showDialog(self)

    def show_Drum_Horizontal(self):

        from Drum_Horizontal import QDrum_Horizontal

        dialog = QDrum_Horizontal()

        dialog.showDialog(self)

    def show_Drum_Vertical(self):

        from Drum_Vertical import QDrum_Vertical

        dialog = QDrum_Vertical()

        dialog.showDialog(self)

    def show_PlateHeatExchanger(self):

        from PlateHeatExchanger import QPlateHeatExchanger

        dialog = QPlateHeatExchanger()

        dialog.showDialog(self)

    def show_Equipment(self):

        from Equipment import QEquipment

        dialog = QEquipment()

        dialog.showDialog(self)

    def show_Ball(self):

        from Ball import QBall

        dialog = QBall()

        dialog.showDialog(self)

    def show_ShlTubHeatExchanger(self):

        from ShlTubHeatExchanger import QShlTubHeatExchanger

        dialog = QShlTubHeatExchanger()

        dialog.showDialog(self)

    def show_ConeRoof(self):

        from ConeRoof import QConeRoof

        dialog = QConeRoof()

        dialog.showDialog(self)

    def show_DomeRoof(self):

        from DomeRoof import QDomeRoof

        dialog = QDomeRoof()

        dialog.showDialog(self)

    def show_Compressor(self):

        from Compressor import QCompressor

        dialog = QCompressor()

        dialog.showDialog(self)

    def show_Pump(self):

        from Pump import QPump

        dialog = QPump()

        dialog.showDialog(self)

    def show_ValveControl(self):

        from Valve_Control import QValve_Control

        dialog = QValve_Control()

        dialog.showDialog(self)

    def show_ValveManual(self):

        from Valve_Manual import QValve_Manual

        dialog = QValve_Manual()

        dialog.showDialog(self)

    def show_LineSplitter(self):

        from LineSplitter import QLineSplitter

        dialog = QLineSplitter()

        dialog.showDialog(self)

    def show_Flowmeter(self):

        from Flowmeter import QFlowmeter

        dialog = QFlowmeter()

        dialog.showDialog(self)

    def show_Reducer(self):

        from Reducer import QReducer

        dialog = QReducer()

        dialog.showDialog(self)

    @staticmethod

    def fromDatabase(componentInfos):

        """ create a componenet from database """

        item = None

        try:

            uid = componentInfos[0][0]  # uid@Components

            dbUid = componentInfos[0][2]  # Symbol_UID@Components

            category = componentInfos[0][3]  # Category@SymbolType

            _type = componentInfos[0][4]  # Type@SymbolType

            name = componentInfos[0][5]  # Name@Symbols

            originalPoint = componentInfos[0][6]  # OriginalPoint@Symbols

            x = componentInfos[0][7]  # X@Components

            y = componentInfos[0][8]  # Y@Components

            angle = componentInfos[0][9]  # Rotation@Components

            scale = componentInfos[0][10]  # Scale@Components

            pt = []

            pt.append(float(x))

            pt.append(float(y))

            origin = [float(x) for x in str(originalPoint).split(',')]

            connPts = []

            pointsUids = []

            for componentInfo in componentInfos:

                pointsUid = componentInfo[11]  # uid@Points

                pointsUids.append(pointsUid)

            app_doc_data = AppDocData.instance()

            svgFilePath = os.path.join(app_doc_data.symbol_file_path, category, _type, name + '.svg')

            if os.path.isfile(svgFilePath):

                item = SymbolSvgItem.createItem(_type, svgFilePath, uid)

                item.setVisible(False)

                item.buildItem(name, _type, float(angle), float(scale), pt, origin, connPts, dbUid, pointsUids)

        except Exception as ex:

            from App import App

            message = 'error occurred({}) 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, owner=None, flip=0):

        import uuid

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

        if owner is not None:

            item.owner = uuid.UUID(owner, version=4)

        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.changeAttributes('fill', color)

        self.changeAttributes('stroke', color)

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

        self.update()

    def getColor(self):

        """ return hover color if mouse is over otherwise reutrn owner's color if owner exist else this color """

        return SymbolSvgItem.HOVER_COLOR if self.hover else (

            self.owner._color if self.owner and hasattr(self.owner, '_color') else self._color)

    '''

        @brief  get attributes from svg file

        @author humkyung

        @date   2019.03.08

    '''

    def get_attribute(self, attName):

        root = self._document.documentElement()

        node = root.firstChild()

        while not node.isNull():

            if node.isElement():

                element = node.toElement()

                if element.hasAttribute(attName):

                    return element.attribute(attName)

                if element.hasChildNodes():

                    att_val = self.recursive_get_attribute(element.firstChild(), attName)

                    if att_val is not None: return att_val

            node = node.nextSibling()

        return None

    '''

        @brief  get recursively attribute

        @author humkyung