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

from EngineeringAbstractItem import QEngineeringAbstractItem

from EngineeringConnectorItem import QEngineeringConnectorItem

from UserInputAttribute import UserInputAttribute

from Resizer import Resizer

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

            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)

    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 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 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 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', 'Drawings_UID', 'Symbols_UID', 'X', 'Y', 'Rotation', 'Scale']

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

        param = [str(self.uid), str(appDocData.activeDrawing.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:

            self.name = 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.setConnector(pointsUids[index], index+1)    

                else:

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

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

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

            #for assoc in self.associations():

            #    assoc.highlight(flag)

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

        from EngineeringTextItem import QEngineeringTextItem

        from QEngineeringSizeTextItem import QEngineeringSizeTextItem

        from EngineeringInstrumentItem import QEngineeringInstrumentItem

        from EngineeringValveOperCodeTextItem import QEngineeringValveOperCodeTextItem

        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', 'Air Fin Cooler'), self.show_AirFinCooler),

            (('Equipment - [ Pressure Drop ]', 'Filter', ('Horizontal','Vertical')), self.show_Filter),

            (('Equipment - [ Pressure Drop ]', 'Heat Exchanger', ('Double Pipe','Horizontal','Vertical','Kettle')), self.show_ShlTubHeatExchanger),

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

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

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

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

            (('Equipment - [ Pressure Drop ]', 'Strainer', ('Horizontal T','Vertical T')), self.show_Strainer_T),

            (('Equipment - [ Pressure Drop ]', 'Strainer', ('Horizontal Y','Vertical Y')), self.show_Strainer_Y),

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

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

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

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

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

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

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

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

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

            (('Equipment - [ Rotating ]', 'Compressor', ('Left','Right')), self.show_Compressor),

            (('Equipment - [ Rotating ]', 'Pump', ('Horizontal Left','Horizontal Right','Vertical')), self.show_Pump),

            (('Instrument', 'Valve', ('Horizontal Control','Vertical Control')), self.show_ValveControl),

            (('Instrument', 'Valve', ('Horizontal Manual','Vertical Manual')), self.show_ValveManual),

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

            (('Instrument', 'Flowmeter', ('Horizontal Orifice','Horizontal Others','Horizontal Venturi','Vertical Orifice','Vertical Others','Vertical Venturi')), self.show_Flowmeter),

            (('Instrument', 'Reducer', ('Down','Left','Right','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)

            appDocData = AppDocData.instance()

            project = appDocData.getCurrentProject()

            svgFilePath = os.path.join(project.getSvgFilePath(), 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)

                for area in appDocData.getAreaList():

                    if area.contains(pt):

                        item.area = area.name

                        break

        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, owner=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 EngineeringEndBreakItem import QEngineeringEndBreakItem

        from EngineeringStreamlineItem import QEngineeringStreamlineItem

        from AppDocData import AppDocData

        import uuid

        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)

        elif type == 'End Break':

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

        elif type == 'Line':

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

        elif type == 'Steam Line':

            item = QEngineeringStreamlineItem(uid)

        else:

            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

        @date   2019.03.08

    '''

    def recursive_get_attribute(self, node, attName):

        while not node.isNull():

            if node.isElement():

                element = node.toElement()

                if element.hasAttribute(attName):

                    return element.attribute(attName)

                if node.hasChildNodes():

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

                    if att_val is not None: return att_val

            node = node.nextSibling()

        return None

    '''

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