HYTOS

# coding: utf-8

""" This is image viewer scene module """

import sys

import os.path

from SingletonInstance import SingletonInstance

try:

    from PyQt5.QtCore import *

    from PyQt5.QtGui import *

    from PyQt5.QtWidgets import *

except ImportError:

    try:

        from PyQt4.QtCore import *

        from PyQt4.QtGui import *

    except ImportError:

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

__author__ = "humkyung <humkyung.doftech.co.kr>"

__version__ = '1.0.0'

class QtImageViewerScene(QGraphicsScene):

    """ This is image viewer scene class """

    contents_changed = pyqtSignal()

    def __init__(self, parent):

        QGraphicsScene.__init__(self, parent)

        self._undo_stack = QUndoStack(self)

        self._delta = QPointF()

        self._pressed_keys = set()

        self.contours = []

        self.contour_color = None

        self.circles = None

        self.guidesEnabled = False

        self._guidePen = QPen()

        self._guidePen.setColor(QColor(180, 180, 180))

        self._guidePen.setStyle(Qt.DashLine)

        self._guidePen.setWidthF(0.3)

    @property

    def undo_stack(self):

        return self._undo_stack

    def addItem(self, item):

        """ add given item to scene """

        QGraphicsScene.addItem(self, item)

        self.contents_changed.emit()

    def removeItem(self, item):

        """ remove given item from scene """

        QGraphicsScene.removeItem(self, item)

        self.contents_changed.emit()

    def keyPressEvent(self, event: QKeyEvent):

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringTextItem import QEngineeringTextItem

        from DeleteCommand import DeleteCommand

        try:

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

                cmd = DeleteCommand(self, [item for item in self.selectedItems() if hasattr(item, 'transfer')])

                self._undo_stack.push(cmd)

            elif event.key() in [Qt.Key_Up, Qt.Key_Down, Qt.Key_Left, Qt.Key_Right]:

                if self.selectedItems():

                    items = [text for text in self.selectedItems() if

                             issubclass(type(text), QEngineeringTextItem) or issubclass(type(text), SymbolSvgItem)]

                    self._pressed_keys.add(event.key())

                    if items:

                        for item in items:

                            item.keyPressEvent(event)

                    modifiers = QApplication.keyboardModifiers()

                    delta = 10 if modifiers == Qt.ControlModifier else 1

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

                        self._delta.setY(self._delta.y() - delta)

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

                        self._delta.setY(self._delta.y() + delta)

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

                        self._delta.setX(self._delta.x() - delta)

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

                        self._delta.setX(self._delta.x() + delta)

                    event.accept()

                    return

            elif event.key() == Qt.Key_Z and event.modifiers() & Qt.ControlModifier:

                self._undo_stack.undo()

            elif event.key() == Qt.Key_R and event.modifiers() & Qt.ControlModifier:

                self._undo_stack.redo()

            super(QtImageViewerScene, self).keyPressEvent(event)

        except Exception as ex:

            print('error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename,

                                                       sys.exc_info()[-1].tb_lineno))

    def keyReleaseEvent(self, event: QKeyEvent):

        from MoveCommand import MoveCommand

        if event.key() in [Qt.Key_Up, Qt.Key_Down, Qt.Key_Left, Qt.Key_Right] and not event.isAutoRepeat():

            if self.selectedItems() and not self._delta.isNull():

                self._undo_stack.push(MoveCommand(self, QPointF(self._delta)))

                self._delta.setX(0)

                self._delta.setY(0)

        super(QtImageViewerScene, self).keyReleaseEvent(event)

    def clear(self):

        """clear undo stack"""

        self._undo_stack.clear()

        super(QtImageViewerScene, self).clear()

    def drawForeground(self, painter: QPainter, rect: QRectF) -> None:

        """draw foreground"""

        if self.contours:

            pen = QPen(Qt.DotLine)

            pen.setColor(Qt.red)

            pen.setWidthF(2)

            painter.setPen(pen)

            for contour in self.contours:

                path = QPainterPath()

                poly = QPolygonF()

                for pt in contour:

                    poly.append(QPointF(pt[0], pt[1]))

                poly.append(poly[0])

                path.addPolygon(poly)

                painter.fillPath(path, QBrush(Qt.darkRed if self.contour_color is None else self.contour_color,

                                              Qt.SolidPattern))

        if self.circles:

            for circle in self.circles:

                painter.drawEllipse(circle[0], circle[1], circle[2], circle[2])

                pass

        """draw guid line"""

        if hasattr(self, 'coords') and self.guidesEnabled:

            painter.setClipRect(rect)

            painter.setPen(self._guidePen)

            painter.drawLine(round(self.coords.x()), round(rect.top()), round(self.coords.x()), round(rect.bottom()))

            painter.drawLine(round(rect.left()), round(self.coords.y()), round(rect.right()), round(self.coords.y()))