HYTOS

# coding: utf-8

"""

This is Polyline item module

"""

import sys

import os.path

import copy

try:

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

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

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

except ImportError:

    try:

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

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

    except ImportError:

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

from EngineeringAbstractItem import QEngineeringAbstractItem

class QEngineeringPolylineItem(QGraphicsPathItem, QEngineeringAbstractItem):

    """

    This is EngineeringPolylineItem Class

    """

    AXIS_MODE = 0

    FREE_MODE = 1

    onRemoved = pyqtSignal(QGraphicsItem)

    '''

        @history    2018.05.11  Jeongwoo    Declare variable self.pen

                    2018.05.15  Jeongwoo    Change method to call parent's __init__

                    2018.05.25  Jeongwoo    Change self.pen's default color (red → blue)

    '''

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

        import uuid

        try:

            QGraphicsPathItem.__init__(self, parent)

            QEngineeringAbstractItem.__init__(self)

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

            self.uid = uuid.uuid4() if uid is None else uid

            self._vertices = []

            self.isCreated = False

            self._pt = None

            self._pol = QPolygonF()

            self._path = None

            self.setPen(QPen(Qt.blue, 4, Qt.SolidLine)) # set default pen

            self.transfer = Transfer()

            self._drawing_mode = QEngineeringPolylineItem.AXIS_MODE

        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)

    @property

    def drawing_mode(self):

        return self._drawing_mode

    @drawing_mode.setter

    def drawing_mode(self, value):

        self._drawing_mode = value

    '''

        @brief  construct a polyline

    '''

    def process(self, param):

        if ('mousePressEvent' == param[0]) and (param[1].button() == Qt.LeftButton):

            self._vertices.append(param[2])

        elif ('mouseMoveEvent' == param[0]):

            self._pt = param[2]

        elif ('mouseReleaseEvent' == param[0]) and (param[1].button() == Qt.RightButton):

            self.isCreated = True

    '''

        @brief  clone an object

    '''

    def clone(self):

        clone = QEngineeringPolylineItem()

        clone._vertices = copy.deepcopy(self._vertices)

        clone.isCreated = self.isCreated

        return clone

    def init(self):

        self._vertices = []

        self._pol.clear()

        self._pt = None

        self.isCreated = False

    '''

        @build  build path

        @author humkyung

        @date   2018.04.23

    '''

    def buildItem(self):

        self._path = QPainterPath()

        self._path.addPolygon(self._pol)

        self.setPath(self._path)

        self.isCreated = True

    '''

        @brief      return bouding rectangle of polyline

        @author     humkyung

        @date       2018.07.23

    '''

    def boundingRect(self):

        rect = QRectF()

        if self.isCreated:

            rect = self.path().boundingRect()

            rect = QRectF(rect.left() - 5, rect.top() - 5, rect.width() + 10, rect.height() + 10)

        else:

            minX = None

            minY = None

            maxX = None

            maxY = None

            for pt in self._vertices:

                if minX is None or pt[0] < minX:

                    minX = pt[0]

                if minY is None or pt[1] < minY:

                    minY = pt[1]

                if maxX is None or pt[0] > maxX:

                    maxX = pt[0]

                if maxY is None or pt[1] > maxY:

                    maxY = pt[1]

            if self._pt is not None:

                if minX is None or self._pt[0] < minX:

                    minX = self._pt[0]

                if minY is None or self._pt[1] < minY:

                    minY = self._pt[1]

                if maxX is None or self._pt[0] > maxX:

                    maxX = self._pt[0]

                if maxY is None or self._pt[1] > maxY:

                    maxY = self._pt[1]

            if minX is not None and minY is not None and maxX is not None and maxY is not None:

                rect = QRectF(minX - 5, minY - 5, maxX - minX + 10, maxY - minY + 10)

        return rect

    '''

        @brief      

        @author     humkyung

        @date       2018.07.26

    '''

    def onMouseMoved(self, event, scenePos):

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringConnectorItem import QEngineeringConnectorItem

        # get connection point near by mouse point

        pt = (scenePos.x(), scenePos.y())

        item = self.scene().itemAt(scenePos, QTransform())

        if (item is not None) and (type(item) is SymbolSvgItem):

            connPt = item.getConnectionPointCloseTo(pt, 5)

            if connPt is not None: pt = connPt

        elif (item is not None) and (type(item) is QEngineeringConnectorItem):

            pt = item.center()

        # up to here

        if self.drawing_mode == QEngineeringPolylineItem.AXIS_MODE and len(self._vertices) > 0:

            dx = abs(self._vertices[-1][0] - pt[0])

            dy = abs(self._vertices[-1][1] - pt[1])

            if dx < dy:

                self._pt = (self._vertices[-1][0], pt[1])

            else:

                self._pt = (pt[0], self._vertices[-1][1])

        else:

            self._pt = pt

        self.update()

    '''

        @brief      Return real item position

        @authro     Jeongwoo

        @date       2018.05.29

    '''

    def boundingRectOnScene(self):

        rect = self.boundingRect()

        sp = self.startPoint()

        rect.moveTo(sp[0], sp[1])

        return rect

    '''

        @brief  paint

        @history    2018.05.11  Jeongwoo Change variable pen → self.pen

    '''

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

        if self.isCreated:

            painter.setPen(self.pen())

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

        elif len(self._vertices) > 0:

            painter.setPen(self.pen())

            for i in range(len(self._vertices)-1):

                painter.drawLine(self._vertices[i][0], self._vertices[i][1], self._vertices[i+1][0], self._vertices[i+1][1])

            if self._pt is not None:

                painter.drawLine(self._vertices[-1][0], self._vertices[-1][1], self._pt[0], self._pt[1])

    '''

        @brief      Set Color. Override QEngineeringAbstractItem's

        @author     Jeongwoo

        @date       2018.05.11

        @history    2018.05.11  Jeongwoo    Add self.setPen() Method

        @history    humkyung 2018.05.13 call setPen method to apply changed color

    '''

    def setColor(self, color):

        c = QColor()

        c.setNamedColor(color)

        _pen = self.pen()

        _pen.setColor(c)

        self.setPen(_pen)

        self.update()

'''

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