HYTOS

# coding: utf-8

""" This is engineering connector item module """

import os.path

import copy, sys

try:

    from PyQt5.QtCore import *

    from PyQt5.QtGui import *

    from PyQt5.QtWidgets import *

except ImportError:

    try:

        from PyQt4.QtCore import Qt, QRectF, pyqtSignal, QT_VERSION_STR

        from PyQt4.QtGui import QGraphicsView, QGraphicsScene, QImage, QPixmap, QPainterPath, QFileDialog

    except ImportError:

        raise ImportError("ImageViewerQt: Requires PyQt5 or PyQt4.")

from AppDocData import *

from EngineeringAbstractItem import QEngineeringAbstractItem

class NozzleData:

    """ this is nozzle data class """

    def __init__(self):

        """ constructor """

        self.pressure = None

        self.pressure_drop = None

        self.elevation = None

        self.over_design_cv = None

        self.cv_type = None

        self.desc = None

        self.pos = None

    def parse(self, row):

        """ parse given row """

        try:

            if not row['Pressure'] is None:

                self.pressure = float(row['Pressure'])

            if not row['Pressure_Drop'] is None:

                self.pressure_drop = float(row['Pressure_Drop'])

            if not row['Elevation'] is None:

                self.elevation = float(row['Elevation'])

            if not row['Over_Design_CV'] is None:

                self.over_design_cv = float(row['Over_Design_CV'])

            if not row['CV_Type'] is None:

                self.cv_type = row['CV_Type']

            if not row['Name'] is None:

                self.desc = row['Name']

            if not row['X'] is None and not row['Y'] is None:

                self.pos = (float(row['X']), float(row['Y']))

        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)

"""

    A {ConnectorItem} is the graphical representation of a {Symbol.Connectors}.

"""

class QEngineeringConnectorItem(QGraphicsEllipseItem):

    """ This is engineering connector item class """

    SMALL_SIZE = 10

    BIG_SIZE = 16

    HIGHLIGHT = '#BC4438'

    AXIS_MODE = 0

    FREE_MODE = 1

    def __init__(self, uid=None, parent=None, index=-1):

        """constructor of connector"""

        import uuid

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringEqpDescTextItem import QEngineeringEqpDescTextItem

        QGraphicsEllipseItem.__init__(self, parent)

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

        self.parent = parent

        self.buildItem()

        self._direction = 'AUTO'

        self._symbol_idx = '0'

        self._connectedItem = None

        self._connected_at = QEngineeringAbstractItem.CONNECTED_AT_PT  # default value is connected at pt

        self.connectPoint = None

        self._hoverItem = None

        self._data = None

        self.setAcceptHoverEvents(True)

        self.transfer = Transfer()

        self._drawing_mode = QEngineeringConnectorItem.AXIS_MODE

        if type(parent) is SymbolSvgItem:

            """ setup label for connector index """

            self._font = QFont('Arial', QEngineeringConnectorItem.SMALL_SIZE)

            self._font.setPointSizeF(5)

        self._conn_index = index

    def __repr__(self):

        """ return string represent parent item and connector index """

        return '{}_{}_N{}'.format(self.parentItem().name, self.parentItem().index, self._conn_index)

    @staticmethod

    def find_connector(uid):

        """ find a connector which has given uid """

        from App import App

        import uuid

        res = None

        if type(uid) is uuid.UUID or type(uid) is str:

            scene = App.mainWnd().graphicsView.scene

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

            res = matches[0] if matches else None

        return res

    @property

    def data(self):

        """ getter of nozzle data """

        return self._data

    @data.setter

    def data(self, value):

        """ setter of nozzle data """

        self._data = value

    @property

    def elevation(self):

        """ return elevation """

        return self.data.elevation

    @property

    def press_drop(self):

        return None

    @property

    def connectedItem(self):

        """ getter of connectedItem """

        import uuid

        if self.scene() and (type(self._connectedItem) is uuid.UUID or type(self._connectedItem) is str):

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

            if matches:

                self._connectedItem = matches[0]

            else:

                self._connectedItem = None

        return self._connectedItem

    @connectedItem.setter

    def connectedItem(self, value):

        """ setter of connectedItem """

        self._connectedItem = value

    '''

        @brief      getter of direction

        @author     humkyung

        @date       2018.09.01

    '''

    @property

    def direction(self):

        return self._direction

    '''

        @brief      setter of direction

        @author     humkyung

        @date       2018.09.01

    '''

    @direction.setter

    def direction(self, value):

        self._direction = value

    @property

    def symbol_idx(self):

        """ """

        return self._symbol_idx

    @symbol_idx.setter

    def symbol_idx(self, value):

        """ setter of symbol_idx """

        self._symbol_idx = value

    def validate(self):

        """validate connector's data"""

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringStreamlineItem import QEngineeringStreamlineItem

        res = []

        try:

            parent = self.parentItem()

            if type(parent) is SymbolSvgItem:

                if parent.category == 'Equipment - [ Pressurized ]':

                    if self.connectedItem and \

                            (self.data is None or (self.data.pressure is None or self.data.elevation is None)):

                        res.extend([self, 'pressure or elevation is invalid'])

                elif parent.category == 'Equipment - [ Pressure Drop ]' or parent.type == 'Flowmeter':

                    if self.connectedItem and \

                            (self.data is None or (self.data.pressure_drop is None or self.data.elevation is None)):

                        res.extend([self, 'pressure drop or elevation is invalid'])

                elif parent.category == 'Equipment - [ Rotating ]':

                    if self.connectedItem and parent.name.upper() in ['L_KOMP', 'R_KOMP', 'R_PUMP', 'L_PUMP', 'V_PUMP']:

                        if self.data is None or self.data.elevation is None:

                            res.extend([self, 'need to check elevation'])

                    elif self.connectedItem and parent.name.upper() in ['L_COMP', 'R_COMP']:

                        if self.data is None or self.data.pressure is None:

                            res.extend([self, 'need to check pressure'])

                        elif self.data is None or self.data.elevation is None:

                            res.extend([self, 'need to check elevation'])

                    elif self.connectedItem and (self.data.pressure_drop is None or self.data.elevation is None):

                        res.extend([self, 'need to check pressure drop and elevation'])

                elif self.connectedItem and parent.name in ['CV_H', 'CV_V']:

                    if self.data is None or self.data.elevation is None:

                        res.extend([self, 'need to check elevation'])

                elif parent.name == 'Line Splitter':  # set default value for line splitter

                    if self.connectedItem:

                        if self.data.pressure_drop is None:

                            self.data.pressure_drop = 0

                        if self.data.elevation is None:

                            self.data.elevation = 0

            elif type(parent) is QEngineeringStreamlineItem:

                pass

            # update connector's color

            if self.connectedItem and type(self.parentItem()) is SymbolSvgItem:

                self.setBrush(Qt.red) if res else self.setBrush(Qt.yellow)

            else:

                self.setBrush(Qt.yellow) if self.connectedItem else self.setBrush(Qt.blue)

            # up to here

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) in {}:{}'.format(repr(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

    def dir(self):

        """return direction vector"""

        if self._direction == 'LEFT':

            return -1, 0

        elif self._direction == 'RIGHT':

            return 1, 0

        elif self._direction == 'UP':

            return 0, -1

        elif self._direction == 'DOWN':

            return 0, 1

        return None

    def buildItem(self):

        """build connector item"""

        from EngineeringStreamlineItem import QEngineeringStreamlineItem

        self.setBrush(Qt.blue)

        if self.parentItem() is not None:

            self.setZValue(self.parentItem().zValue() + 1)

    '''

        @brief      return center of connector

        @author     humkyung

        @date       2018.07.23

    '''

    def center(self):

        pt = self.sceneBoundingRect().center()

        return (pt.x(), pt.y())

    '''

        @brief  set position of connector

        @author humkyung

        @date   2018.05.02

    '''

    def setPos(self, pos):

        self._loc = [pos[0], pos[1]]

        self.setRect(self._loc[0] - round(self.SMALL_SIZE * 0.5), self._loc[1] - round(self.SMALL_SIZE * 0.5),

                     self.SMALL_SIZE, self.SMALL_SIZE)

        self.update()

        if hasattr(self, '_label'):

            """ set label positon at center of connector """

            self._label.setPos(QPointF(self._loc[0] - self._label.boundingRect().width() * 0.5,

                                       self._loc[1] - self._label.boundingRect().height() * 0.5))

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

        """connect to given item where given position"""

        from SymbolSvgItem import SymbolSvgItem

        if item:

            self.connectedItem = item

            self._connected_at = at

        else:

            self.connectedItem = None

        self.validate()

        self.update()

    def hoverEnterEvent(self, event):

        """highlight connector"""

        from EngineeringStreamlineItem import QEngineeringStreamlineItem

        try:

            if type(self.parentItem()) is not QEngineeringStreamlineItem:

                items = self.scene().items(event.scenePos())

                matched = [item for item in items if type(item.parentItem()) is QEngineeringStreamlineItem]

                if matched:

                    matched[0].hoverEnterEvent(event)

                else:

                    self.highlight(True)

            else:

                self.highlight(True)

        finally:

            QApplication.setOverrideCursor(Qt.CrossCursor)

    def hoverLeaveEvent(self, event):

        """unhighlight connector"""

        try:

            self.highlight(False)

        finally:

            QApplication.restoreOverrideCursor()

    def highlight(self, flag):

        """highlight or unhighlight"""

        if flag:

            self.setRect(self._loc[0] - round(self.BIG_SIZE * 0.5), self._loc[1] - round(self.BIG_SIZE * 0.5),

                         self.BIG_SIZE, self.BIG_SIZE)

            c = QColor()

            c.setNamedColor(QEngineeringConnectorItem.HIGHLIGHT)

            self.setPen(Qt.red)

            # self.setBrush(c)

            if hasattr(self, '_label'):

                font = self._label.font()

                font.setBold(True)

                self._label.setFont(font)

            self.parentItem().highlight(flag)

        else:

            self.setRect(self._loc[0] - round(self.SMALL_SIZE * 0.5), self._loc[1] - round(self.SMALL_SIZE * 0.5),

                         self.SMALL_SIZE, self.SMALL_SIZE)

            self.setPen(Qt.black)

            # self.setBrush(Qt.yellow) if self.connectedItem else self.setBrush(Qt.blue)

            if hasattr(self, '_label'):

                font = self._label.font()

                font.setBold(False)

                self._label.setFont(font)

            self.parentItem().highlight(flag)

        if self.scene() and self.scene().sceneRect().contains(self.sceneBoundingRect()):

            self.update()

            if self.scene(): self.scene().update()

    '''

        @brief      

        @author     humkyung

        @date       2018.07.27

    '''

    def mousePressEvent(self, event):

        if self.parentItem():

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

                self._savedPos = self._loc

                self._savedConnectedItem = self.connectedItem

        QGraphicsEllipseItem.mousePressEvent(self, event)

    '''

        @brief      

        @author     humkyung

        @date       2018.07.27

        @history    humkyung 2018.08.23 unhighlight item if underitem exists

    '''

    def mouseReleaseEvent(self, event):

        import shapely

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringArrowItem import QEngineeringArrowItem

        from EngineeringTextItem import QEngineeringTextItem

        try:

            if self.parentItem() is not None and self._savedPos is not None:

                items = [item for item in self.scene().items(event.scenePos()) if

                         item is not self and item is not self.parentItem() and \

                         (issubclass(type(item), SymbolSvgItem) or issubclass(type(item), QEngineeringTextItem) or type(

                             item) is QEngineeringConnectorItem)]

                if items and type(items[0]) is QEngineeringConnectorItem:

                    self.setPos(items[0].center())

                    """ disconnect already connected item """

                    if self.connectedItem is not None:

                        self.connectedItem.connect(None)

                    """ connect each other """

                    self.connect(items[0])

                    items[0].connect(self)

                else:

                    pt = [event.scenePos().x(), event.scenePos().y()]

                    self.setPos(pt)

                    if self.connectedItem is not None:

                        self.connectedItem.connect(None)

                    self.connect(None)

                # unhighlight underitem

                if hasattr(self, '_underItem') and self._underItem is not None:

                    self._underItem.highlight(False)

                # up to here

                for symbol in [self.parentItem() for self in items if type(self.parentItem()) is SymbolSvgItem]:

                    symbol.transfer.on_pos_changed.connect(self.parent.on_symbol_pos_changed)

            if self.parentItem() is not None:

                self._savedPos = None

                self._savedConnectedItem = None

                self.transfer.onPosChanged.emit(self)

        finally:

            pass

        QGraphicsEllipseItem.mouseReleaseEvent(self, event)

    '''

        @brief      move connector's position while mouse drag

        @author     humkyung

        @date       2018.07.27

        @history    humkyung 2018.08.23 hightlight underitem

    '''

    def mouseMoveEvent(self, event):

        import shapely

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringDimensionItem import QEngineeringDimensionItem

        from EngineeringTextItem import QEngineeringTextItem

        if self.parentItem() and self._savedPos is not None:

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

                items = [item for item in self.scene().items(event.scenePos()) if

                         item is not self and item is not self.parentItem() and \

                         (issubclass(type(item), SymbolSvgItem) or issubclass(type(item), QEngineeringTextItem) or

                          type(item) is QEngineeringConnectorItem)]

                # highlight underitem

                if len(items) > 0:

                    if not hasattr(self, '_underItem') or self._underItem is not items[0]:

                        if hasattr(self, '_underItem') and self._underItem is not None:

                            self._underItem.highlight(False)

                        self._underItem = items[0]

                        self._underItem.highlight(True)

                elif hasattr(self, '_underItem') and self._underItem is not None:

                    self._underItem.hoverLeaveEvent(event)

                    self._underItem = None

                # up to here

                if items and type(items[0]) is QEngineeringConnectorItem:

                    self.setPos(items[0].center())

                else:

                    self.setPos([event.scenePos().x(), event.scenePos().y()])

                self.update()

        QGraphicsEllipseItem.mouseMoveEvent(self, event)

    def hasConnectedItem(self):

        if self.connectedItem is not None:

            return True

        return False

    '''

        @brief      reject if user press Escape key

        @author     humkyung

        @date       2018.07.27

    '''

    def keyPressEvent(self, event):

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

            if hasattr(self, '_savedPos') and self._savedPos is not None:

                self.setPos(self._savedPos)

                self.connectedItem = self._savedConnectedItem

                self._savedPos = None

                self.update()

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

            self._drawing_mode = QEngineeringConnectorItem.AXIS_MODE

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

            self._drawing_mode = QEngineeringConnectorItem.FREE_MODE

        QGraphicsEllipseItem.keyPressEvent(self, event)

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

        """override paint"""

        from SymbolSvgItem import SymbolSvgItem

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

        if type(self.parentItem()) is SymbolSvgItem:

            painter.setFont(self._font)

            painter.drawText(self.boundingRect(), str(self._conn_index), QTextOption(Qt.AlignCenter))

    '''

        @brief      check Overlap

        @author     kyouho

        @date       2018.08.30

    '''

    def isOverlapConnector(self, conn, toler=10):

        from shapely.geometry import Point

        x1 = self.center()[0]

        y1 = self.center()[1]

        x2 = conn.center()[0]

        y2 = conn.center()[1]

        if Point(x1, y1).distance(Point(x2, y2)) < toler:

            return True

        else:

            return False

    def parse_xml(self, node):

        """ parse given node """

        import uuid

        try:

            if 'UID' in node.attrib: self.uid = uuid.UUID(node.attrib['UID'], version=4)

            if 'CONNECTED_AT' in node.attrib:

                self._connected_at = QEngineeringAbstractItem.CONNECTED_AT_PT if node.attrib[

                                                                                     'CONNECTED_AT'] == '0' else QEngineeringAbstractItem.CONNECTED_AT_BODY

            else:

                self._connected_at = QEngineeringAbstractItem.CONNECTED_AT_PT

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

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

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

            self._connectedItem = uuid.UUID(connectedItemStr, version=4) if connectedItemStr != 'None' else None

            self.connectPoint = (float(connectPointStr[0]), float(connectPointStr[1]))

            self.sceneConnectPoint = (float(sceneConnectPointStr[0]), float(sceneConnectPointStr[1]))

            self.setBrush(Qt.yellow) if self._connectedItem else self.setBrush(Qt.blue)

        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)

    def toSql(self, index):

        """ generate sql string to save connectors to database """

        res = []

        try:

            cols = ['UID', 'Components_UID', '[Index]', 'X', 'Y']

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

            param = [str(self.uid), str(self.parent.uid), index, self.center()[0], self.center()[1]]

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

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

            cols = ['Points_UID', 'Pressure', 'Pressure_Drop', 'Elevation', 'Over_Design_CV', 'CV_Type']

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

            if self.data:

                pressure = self.data.pressure

                if pressure is None:

                    pressure = None

                else:

                    pressure = float(pressure)

                pressure_drop = self.data.pressure_drop

                if pressure_drop is None:

                    pressure_drop = None

                else:

                    pressure_drop = float(pressure_drop)

                elevation = self.data.elevation

                if elevation is None:

                    elevation = None

                else:

                    elevation = float(elevation)

                over_design_cv = self.data.over_design_cv

                if over_design_cv is None:

                    over_design_cv = None

                else:

                    over_design_cv = float(over_design_cv)

                cv_type = self.data.cv_type

                if cv_type is None:

                    cv_type = None

                else:

                    cv_type = str(cv_type)

                param = [str(self.uid), pressure, pressure_drop, elevation, over_design_cv, cv_type]

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

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

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) in {}:{}'.format(repr(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      The class transfer pyqtSignal Event. Cause Subclass of QGraphicsRectItem can't use pyqtSignal

    @author     Jeongwoo

    @date       2018.06.18

'''

class Transfer(QObject):

    onPosChanged = pyqtSignal(QGraphicsItem)

    onRemoved = pyqtSignal(QGraphicsItem)

    def __init__(self, parent=None):

        QObject.__init__(self, parent)