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 EngineeringAbstractItem import QEngineeringAbstractItem

class NozzleData:

    """ this is nozzle data class """

    def __init__(self):

        """ constructor """

        self.pressure = None

        self.elevation = None

"""

    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

    '''

        @brief  

        @author 

        @date   

        @history        humkyung 2018.07.27 add member for connectedItem

                        humkyung 2018.09.03 remove code to add connector item

    '''

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

        import uuid

        from SymbolSvgItem import SymbolSvgItem

        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._spec_break = None

        self._connectedItem = None

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

        self.sceneConnectPoint = None

        self.connectPoint = None

        self._hoverItem = None

        self._nozzle_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

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

        """ getter of nozzle data """

        return self._nozzle_data

    @nozzle_data.setter

    def nozzle_data(self, value):

        """ setter of nozzle data """

        self._nozzle_data = value

    @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

    @property

    def spec_break(self):

        """

        getter of spec break

        """

        return self._spec_break

    @spec_break.setter

    def spec_idx(self, value):

        """

        setter of spec_break

        """

        self._spec_break = value

    '''

        @brief      return direction vector

        @author     humkyung

        @date       2018.09.01

    '''

    def dir(self):

        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 __repr__(self):

        return '{},{},{},{}'.format(self._direction, self.sceneConnectPoint[0], self.sceneConnectPoint[1] , self._symbol_idx)

    '''

        @brief  build connector item

        @author humkyung

        @date   2018.05.02

    '''

    def buildItem(self):

        color = Qt.blue

        self.setBrush(color)

        if self.parent is not None:

            self.setZValue(self.parent.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 """

        if item:

            self.connectedItem = item

            self._connected_at = at

        else:

            self.connectedItem = None

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

    '''

        @brief  highlight connector

        @authro humkyung

        @date   2018.05.09

    '''

    def hoverEnterEvent(self, event):

        try:

            self.highlight(True)

        finally:

            QApplication.setOverrideCursor(Qt.CrossCursor)

    '''

        @brief  unhighlight connector

        @author humkyung

        @date   2018.05.09

    '''

    def hoverLeaveEvent(self, event):

        try:

            self.highlight(False)

        finally:

            QApplication.restoreOverrideCursor()

    def highlight(self, flag):

        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)

        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)

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

        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() is not None:

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

            #self.ungrabKeyboard()

            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 EngineeringArrowItem import QEngineeringArrowItem

        from EngineeringTextItem import QEngineeringTextItem

        if self.parentItem() is not None 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.parent 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:

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

                    self.setPos(pt)

                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)

    '''

        @brief  override paint(draw connection points)

        @author humkyung

        @date   2018.04.21

    '''

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

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

    @staticmethod

    def fromXml(node):

        """ generate connector instance from xml node """

        attr = QEngineeringConnectorItem()

        return attr

    def toXml(self):

        """ generate xml code for connector """

        import uuid

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

        try:

            node = Element('CONNECTOR')

            node.attrib['UID'] = str(self.uid)

            node.attrib['CONNECTED_AT'] = str(self._connected_at)

            connectedItemNode = Element('CONNECTEDITEM')

            connectedItemNode.text = str(self.connectedItem.uid) if self.connectedItem and not type(self.connectedItem) is uuid.UUID else 'None'

            connectPointNode = Element('CONNECTPOINT')

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

            sceneConnectPointNode = Element('SCENECONNECTPOINT')

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

            node.append(connectedItemNode)

            node.append(connectPointNode)

            node.append(sceneConnectPointNode)

        except Exception as ex:

            from App import App 

            from AppDocData import MessageType

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

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

            return None

        return node

    def toSql(self, index):

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

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

        return (sql, tuple(param))

'''

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