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)

        self._pressed_position = None

    @property

    def undo_stack(self):

        return self._undo_stack

    def addItem(self, item):

        """add given item to scene"""

        if hasattr(item, 'transfer'):

            item.transfer.onRemoved.connect(self.parent().itemRemoved)

        QGraphicsScene.addItem(self, item)

        self.contents_changed.emit()

    def removeItem(self, item):

        """remove given item from scene"""

        if hasattr(item, 'transfer') and item.transfer.receivers(item.transfer.onRemoved) > 0:

            item.transfer.onRemoved.disconnect(self.parent().itemRemoved)

        QGraphicsScene.removeItem(self, item)

        self.contents_changed.emit()

    def keyPressEvent(self, event: QKeyEvent):

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringTextItem import QEngineeringTextItem

        from EngineeringLineItem import QEngineeringLineItem

        from QEngineeringTrimLineNoTextItem import QEngineeringLineNoTextItem

        from EngineeringSpecBreakItem import QEngineeringSpecBreakItem

        from EngineeringVendorItem import QEngineeringVendorItem

        from DeleteCommand import DeleteCommand

        from RotateCommand import RotateCommand

        from FlipCommand import FlipCommand

        from AppDocData import AppDocData

        try:

            #print('scene : ' + str(event.key()))

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

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

                self._undo_stack.push(cmd)

            elif event.key() in [Qt.Key_S, Qt.Key_D, Qt.Key_H]:

                if self.selectedItems():

                    items = [text for text in self.selectedItems() if type(text) is QEngineeringLineNoTextItem]

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

                    if items:

                        for item in items:

                            item.keyPressEvent(event)

                    event.accept()

                    return

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

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

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

                    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_C and event.modifiers() & Qt.ControlModifier:

                from xml.etree import ElementTree

                import XmlGenerator as xg

                app_doc_data = AppDocData.instance()

                xml, result = xg.write_to_xml(app_doc_data.activeDrawing.file_path, app_doc_data.activeDrawing.width,

                                              app_doc_data.activeDrawing.height, self.selectedItems(), [])

                if xml:

                    QApplication.clipboard().setText(ElementTree.tostring(xml, encoding='unicode'))

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

                from App import App

                import uuid

                from QtImageViewer import QtImageViewer

                from TextInfo import TextInfo

                app_doc_data = AppDocData.instance()

                clipboard = QApplication.clipboard()

                mime_data = clipboard.mimeData()

                if mime_data.hasText():

                    text = mime_data.text()

                    if text.find('<DWG>') != -1 and text.find('</DWG>') != -1:

                        from xml.etree import ElementTree

                        origin = self.views()[0].mapFromGlobal(QCursor.pos())

                        origin = self.views()[0].mapToScene(origin)

                        delta = None

                        root = ElementTree.fromstring(text)

                        for symbol in root.find('SYMBOLS').iter('SYMBOL'):

                            item = SymbolSvgItem.fromXml(symbol)

                            svg = QtImageViewer.createSymbolObject(item.name)

                            if not delta:

                                delta = origin - QPointF(item.origin[0], item.origin[1])

                            if type(svg) is QEngineeringSpecBreakItem:

                                specBreakAttrsFull = [attr for attr in app_doc_data.getSymbolAttribute('Segment Breaks') if attr.AttributeType == 'Spec' or attr.AttributeType == 'String']

                                from_attrs = item.attrs

                                to_attrs = svg.getAttributes()

                                for key in from_attrs.keys():

                                    if key.Attribute == 'UpStream' or key.Attribute == 'DownStream':

                                        continue

                                    for full in specBreakAttrsFull:

                                        if full.Attribute == key.Attribute:

                                            to_attrs[full] = from_attrs[key].copy()

                                if item.prop('Freeze'):

                                    svg.set_property('Freeze', True)

                                if item.prop('Show'):

                                    svg.set_property('Show', True)

                            QtImageViewer.matchSymbolToLine(self, svg, QPointF(item.origin[0], item.origin[1]) + delta, item.angle)

                            '''

                            # uid 새로 할당

                            item.uid = uuid.uuid4()

                            for connector in item.connectors:

                                connector.connectedItem = None

                            item.origin[0], item.origin[1] = origin.x(), origin.y()

                            item.transfer.onRemoved.connect(App.mainWnd().itemRemoved)

                            item.addSvgItemToScene(self, True)

                            item.setVisible(True)

                            '''

                        for text in root.find('TEXTINFOS').iter('ATTRIBUTE'):

                            width = float(text.find('WIDTH').text)

                            height = float(text.find('HEIGHT').text)

                            angle = float(text.find('ANGLE').text)

                            tokens = text.find('LOCATION').text.split(',')

                            loc = QPointF(float(tokens[0]), float(tokens[1]))

                            if not delta:

                                delta = origin - loc

                            pos = loc + delta

                            textInfo = TextInfo(text.find('VALUE').text, pos.x(), pos.y(), width, height, angle)

                            item = QEngineeringTextItem.create_text_with(self, textInfo)

                            item.transfer.onRemoved.connect(App.mainWnd().itemRemoved)

                        for node in root.find('LINEINFOS').iter('LINE'):

                            startPoint = [float(x) for x in node.find('STARTPOINT').text.split(',')]

                            endPoint = [float(x) for x in node.find('ENDPOINT').text.split(',')]

                            loc = QPointF(startPoint[0], startPoint[1])

                            if not delta:

                                delta = origin - loc

                            line = QEngineeringLineItem(vertices=[[startPoint[0] + delta.x(), startPoint[1] + delta.y()],

                                                                  [endPoint[0] + delta.x(), endPoint[1] + delta.y()]]) #.fromXml(node)

                            if line:

                                '''lineF = line.line()

                                loc = QPointF(lineF.x1(), lineF.y1())

                                if not anchor:

                                    anchor = loc

                                delta = origin - loc - anchor

                                lineF.translate(delta)

                                line.setLine(lineF)

                                line.setVisible(True)'''

                                self.addItem(line)

                        for vendor in root.find('VENDORS').iter('VENDOR'):

                            _type = vendor.attrib['Type'] if 'Type' in vendor.attrib else 'Vendor Package'

                            pointNode = vendor.find('POINT')

                            strPoints = pointNode.text

                            points = []

                            for strPoint in strPoints.split(QEngineeringVendorItem.DELIMITER):

                                point = strPoint.split(',')

                                points.append(QPoint(float(point[0]), float(point[1])))

                            polygon = QPolygonF(points)

                            item = QEngineeringVendorItem(polygon, pack_type=_type)

                            item.area = vendor.find('AREA').text

                            self.addItem(item)

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

                #self._undo_stack.undo()

                pass

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

                #self._undo_stack.redo()

                pass

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

                self._undo_stack.push(RotateCommand(self, self.selectedItems()))

            elif self.selectedItems() and event.key() == Qt.Key_F and not(event.modifiers() & Qt.ControlModifier):

                self._undo_stack.push(FlipCommand(self, self.selectedItems()))

            super(QtImageViewerScene, self).keyPressEvent(event)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \

                      f"{sys.exc_info()[-1].tb_lineno}"

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

    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 mousePressEvent(self, event: 'QGraphicsSceneMouseEvent') -> None:

        if self.selectedItems():

            self._pressed_position = event.scenePos()

        elif not self.selectedItems() and self.items(event.scenePos()):

            self._pressed_position = event.scenePos()

        super(QtImageViewerScene, self).mousePressEvent(event)

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

        from MoveCommand import MoveCommand

        if self._pressed_position and self._pressed_position != event.scenePos() and self.selectedItems():

            self._undo_stack.push(MoveCommand(self, event.scenePos() - self._pressed_position))

        self._pressed_position = None

        super(QtImageViewerScene, self).mouseReleaseEvent(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()))