HYTOS

# coding: utf-8

import os.path

import copy

import sys

try:

    from PyQt5.QtCore import Qt, QPointF, QRectF, pyqtSignal, QObject, QT_VERSION_STR, QRect

    from PyQt5.QtGui import QImage, QPixmap, QPainterPath, QBrush, QPen, QTransform, QFont, QColor, QFontMetricsF

    from PyQt5.QtWidgets import QGraphicsView, QGraphicsScene, QFileDialog, QGraphicsItem, QAbstractGraphicsShapeItem, \

        QGraphicsPathItem

except ImportError:

    try:

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

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

            QColor, QFontMetricsF

    except ImportError:

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

from AppDocData import *

from EngineeringAbstractItem import QEngineeringAbstractItem

class QEngineeringDimensionItem(QGraphicsPathItem, QEngineeringAbstractItem):

    selected_change = pyqtSignal(QGraphicsItem)

    ARROW_SIZE = 10

    DIMENSION_DEPTH = 30

    HIGHLIGHT = '#BC4438'

    ZVALUE = 210

    def __init__(self, uid=None, pts=None):

        import uuid

        QGraphicsPathItem.__init__(self, None)

        QEngineeringAbstractItem.__init__(self)

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

        self.type = 'Dimension'

        self.loc = None

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

        self.setAcceptHoverEvents(True)

        self.setAcceptTouchEvents(True)

        self._selected_idx = None

        self.setPath(self.create_path(pts))

        self.setBrush(Qt.black)

        self.transfer = Transfer()

        self.setZValue(QEngineeringDimensionItem.ZVALUE)

    def __str__(self):

        """ return string represent uuid """

        return str(self.uid)

    @property

    def pos(self):

        """return dimension position"""

        path = self.mapToScene(self.path())

        return [QPointF(path.elementAt(0).x, path.elementAt(0).y), QPointF(path.elementAt(1).x, path.elementAt(1).y)]

    def set_pos(self, pts):

        """set dimension positions"""

        if pts and 2 == len(pts):

            self.setPath(self.create_path(pts))

    def create_path(self, pts):

        """create a path"""

        import math

        from EngineeringConnectorItem import QEngineeringConnectorItem

        #self.resetTransform()

        path = QPainterPath()

        if pts:

            if 1 == len(pts):

                pts.append(QPointF(pts[0].x() + 10, pts[0].y() + 10))

            path.moveTo(pts[0])

            path.lineTo(pts[1])

            dx = pts[1].x() - pts[0].x()

            dy = pts[1].y() - pts[0].y()

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

            if length:

                _dir = [dx / length, dy / length]

                arrow_size = QEngineeringDimensionItem.ARROW_SIZE * 0.25

                perpendicular = (-_dir[1], _dir[0])

                polygon = QPolygonF()

                polygon.append(QPointF(

                    pts[1].x() - _dir[0] * QEngineeringDimensionItem.ARROW_SIZE + perpendicular[0] * arrow_size,

                    pts[1].y() - _dir[1] * QEngineeringDimensionItem.ARROW_SIZE + perpendicular[1] * arrow_size))

                polygon.append(QPointF(

                    pts[1].x() - _dir[0] * QEngineeringDimensionItem.ARROW_SIZE - perpendicular[0] * arrow_size,

                    pts[1].y() - _dir[1] * QEngineeringDimensionItem.ARROW_SIZE - perpendicular[1] * arrow_size))

                polygon.append(pts[1])

                polygon.append(polygon[0])

                path.addPolygon(polygon)

                polygon = QPolygonF()

                polygon.append(QPointF(

                    pts[0].x() + _dir[0] * QEngineeringDimensionItem.ARROW_SIZE + perpendicular[0] * arrow_size,

                    pts[0].y() + _dir[1] * QEngineeringDimensionItem.ARROW_SIZE + perpendicular[1] * arrow_size))

                polygon.append(QPointF(

                    pts[0].x() + _dir[0] * QEngineeringDimensionItem.ARROW_SIZE - perpendicular[0] * arrow_size,

                    pts[0].y() + _dir[1] * QEngineeringDimensionItem.ARROW_SIZE - perpendicular[1] * arrow_size))

                polygon.append(pts[0])

                polygon.append(polygon[0])

                path.moveTo(pts[0].x() - perpendicular[0]*5, pts[0].y() - perpendicular[1]*5)

                path.lineTo(pts[0].x() + perpendicular[0]*QEngineeringDimensionItem.DIMENSION_DEPTH,

                            pts[0].y() + perpendicular[1]*QEngineeringDimensionItem.DIMENSION_DEPTH)

                path.moveTo(pts[1].x() - perpendicular[0]*5, pts[1].y() - perpendicular[1]*5)

                path.lineTo(pts[1].x() + perpendicular[0] * QEngineeringDimensionItem.DIMENSION_DEPTH,

                            pts[1].y() + perpendicular[1] * QEngineeringDimensionItem.DIMENSION_DEPTH)

                path.addPolygon(polygon)

                path.addEllipse(pts[0], 4, 4)

                path.addEllipse(pts[1], 4, 4)

                """

                if not self.connectors:

                    conn = QEngineeringConnectorItem(uid=None, parent=self, index=0)

                    conn.setFlags(

                        QGraphicsItem.ItemIsSelectable | QGraphicsItem.ItemIsFocusable | QGraphicsItem.ItemIsMovable)

                    conn.transfer.onPosChanged.connect(self.on_connector_pos_changed)

                    self.connectors.append(conn)

                    conn = QEngineeringConnectorItem(uid=None, parent=self, index=1)

                    conn.setFlags(

                        QGraphicsItem.ItemIsSelectable | QGraphicsItem.ItemIsFocusable | QGraphicsItem.ItemIsMovable)

                    conn.transfer.onPosChanged.connect(self.on_connector_pos_changed)

                    self.connectors.append(conn)

                self.connectors[0].setPos((self._pts[0].x(), self._pts[0].y()))

                self.connectors[1].setPos((self._pts[1].x(), self._pts[1].y()))

                """

        return path

    """

    def on_connector_pos_changed(self, conn):

        #rebuild stream line

        self._pts[conn._conn_index] = QPointF(conn.center()[0], conn.center()[1])

        self.setPath(self.create_path())

    """

    '''

        @brief      hover event

        @authro     humkyung

        @date       

    '''

    def hoverEnterEvent(self, event):

        self.highlight(True)

    def hoverLeaveEvent(self, event):

        self.highlight(False)

    def highlight(self, flag):

        """highlight dimension"""

        if flag:

            _pen = self.pen()

            _pen.setColor(QColor(QEngineeringAbstractItem.HOVER_COLOR))

        else:

            _pen = self.pen()

            _pen.setColor(Qt.black)

        self.setPen(_pen)

        self.update()

    def hoverMoveEvent(self, event):

        pass

    def mousePressEvent(self, event):

        import math

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

            toler = 5

            pos = event.scenePos()

            path = self.mapToScene(self.path())

            pts = [QPointF(path.elementAt(0).x, path.elementAt(0).y), QPointF(path.elementAt(1).x, path.elementAt(1).y)]

            dx = pts[0].x() - pos.x()

            dy = pts[0].y() - pos.y()

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

                self._selected_idx = 0

                return

            dx = pts[1].x() - pos.x()

            dy = pts[1].y() - pos.y()

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

                self._selected_idx = 1

                return

        super(QEngineeringDimensionItem, self).mousePressEvent(event)

    def mouseMoveEvent(self, event):

        """reshape dimension"""

        if event.buttons() == Qt.LeftButton and (self._selected_idx == 0 or self._selected_idx == 1):

            path = self.mapToScene(self.path())

            pts = [QPointF(path.elementAt(0).x, path.elementAt(0).y), QPointF(path.elementAt(1).x, path.elementAt(1).y)]

            pts[self._selected_idx] = event.scenePos()

            self.setPath(self.create_path(pts))

            return

        super(QEngineeringDimensionItem, self).mouseMoveEvent(event)

    def mouseReleaseEvent(self, event: 'QGraphicsSceneMouseEvent') -> None:

        self._selected_idx = None

        super(QEngineeringDimensionItem, self).mouseReleaseEvent(event)

    def itemChange(self, change, value):

        if change == QGraphicsItem.ItemSelectedChange:

            pass

        return value

    def setColor(self, color):

        pass

    @staticmethod

    def fromDatabase(componentInfos):

        """ create a callout from database """

        from PlaceDimensionCommand import PlaceDimensionCommand

        item = None

        try:

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

            tag_no = componentInfos[0]['Name']  # name@Components

            index = componentInfos[0]['Comp_Index']

            dbUid = componentInfos[0]['Symbols_UID']  # Symbol_UID@Components

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

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

            name = componentInfos[0]['Symbol_Name']  # Name@Symbols

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

            x = componentInfos[0]['Comp_X']  # X@Components

            y = componentInfos[0]['Comp_Y']  # Y@Components

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

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

            pt = QPointF(float(x), float(y))

            item = PlaceDimensionCommand.create_item(pt)

        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

    def toSql(self):

        """convert callout data to sql query"""

        from AppDocData import AppDocData

        """ generate sql string to save label to database """

        res = []

        try:

            cols = ['UID', 'Symbols_UID', 'Name', 'X', 'Y']

            values = ['?', "(select uid from Symbols where Name='Callout')", '?', '?', '?']

            param = [str(self.uid), self.toHtml(), self.pos().x(), self.pos().y()]

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

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

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

            param = [str(self.uid), str(self.uid), 0, self.pos().x(), self.pos().y()]

            sql = 'insert or replace into Points({}) 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):

    onRemoved = pyqtSignal(QGraphicsItem)

    def __init__(self, parent=None):

        QObject.__init__(self, parent)