/ - Diff - HYTOS - 일정관리

개정판 e05a52a4

ID	e05a52a47ebe7e9afe7ec240009d0af2d4535af7
상위	590ec615
하위	67cd9ddb

백흠경이(가) 약 5년 전에 추가함

issue #366: Undo/Redo for rotating

Change-Id: I37102ba275d3b8f38c06d22917c41c3d23f326b1

     # coding: utf-8
     """ This is rotate command module """
     import os.path
     import sys
     from SymbolSvgItem import SymbolSvgItem
     from EngineeringErrorItem import QEngineeringErrorItem
     from PyQt5.QtCore import *
     from PyQt5.QtGui import *
     from PyQt5.QtWidgets import *
     class RotateCommand(QUndoCommand):
         def __init__(self, scene, items, angle = None, parent=None):
             from SymbolSvgItem import SymbolSvgItem
             super(RotateCommand, self).__init__(parent)
             self._scene = scene
             self._items = [item for item in items if issubclass(type(item), SymbolSvgItem) and
                            type(self) is not QEngineeringErrorItem]
             self._params = [angle]*len(items) if angle else None
             self._rotated = True if angle else False
         def undo(self):
             """undo"""
             import math
             for idx, item in enumerate(self._items):
                 item.rotate(math.radians(self._params[idx]))
             self._scene.update()
             self._rotated = False
         def redo(self):
             """redo"""
             import math
             if not self._rotated:
                 _params = []
                 for idx, item in enumerate(self._items):
                     _params.append(item.rotation())
                     item.rotate(math.radians((_params[idx] + 90) % 360))
                 self._params = _params
                 self._scene.update()

                         svg.hit_ratio = symbol.hitRate
                         svg.buildItem(name, _type, angle, pt, size, origin, connPts, parentSymbol, childSymbol,
                                       hasInstrumentLabel)
                         svg.reCalculationRotatedItem()
                         # svg.reCalculationRotatedItem()
                         svg.area = 'Drawing'
                         # set owner - 2018.07.20 added by humkyung

             from SymbolSvgItem import SymbolSvgItem
             from EngineeringTextItem import QEngineeringTextItem
             from DeleteCommand import DeleteCommand
             from RotateCommand import RotateCommand
             try:
                 if event.key() == Qt.Key_Delete:
-...
                     self._undo_stack.undo()
                 elif event.key() == Qt.Key_R and event.modifiers() & Qt.ControlModifier:
                     self._undo_stack.redo()
                 elif self.selectedItems() and event.key() == Qt.Key_R and not(event.modifiers() & Qt.ControlModifier):
                     self._undo_stack.push(RotateCommand(self, self.selectedItems()))
                 super(QtImageViewerScene, self).keyPressEvent(event)
             except Exception as ex:

         def mouseReleaseEvent(self, event):
             if hasattr(self, '_rotating') and event.button() == Qt.RightButton:
                 from RotateCommand import RotateCommand
                 self.angle = -self._angle if self._angle > -math.pi and self._angle < 0 else 2 * math.pi - self._angle
                 self.scene().undo_stack.push(RotateCommand(self.scene(), [self,], self._rotating))
                 self.ungrabMouse()
                 del self._rotating
-...
                     cross = int(np.cross([1, 0], [dx, dy]))
                     self._angle = -self._angle if cross < 0 else self._angle
                     self.rotate(self.getCurrentPoint(), -self._angle)
                     self.rotate(-self._angle)
         def removeSelfAttr(self, attributeName):
             target = None
-...
                 return
             if event.key() == Qt.Key_B:
                 self.bind_close_items()
             """
             elif event.key() == Qt.Key_R and QApplication.keyboardModifiers() != Qt.ControlModifier and \
                     type(self) is not QEngineeringErrorItem:
                 self.rotateSymbol()
             elif event.key() == Qt.Key_O and type(self) is not QEngineeringErrorItem:
             """
             if event.key() == Qt.Key_O and type(self) is not QEngineeringErrorItem:
                 pass
             elif event.key() == Qt.Key_C and type(self) is not QEngineeringErrorItem:
                 self.changeConnPoint()
             elif event.key() == Qt.Key_F and type(self) is not QEngineeringErrorItem:
                 self.flipSymbol()
                 self.flip = 1 if self.flip is 0 else 0
                 self.flip_symbol()
             elif event.key() == Qt.Key_Return:
                 return
                 # disable
-...
                     self.angle = angle
                     self.loc = [x - self.symbolOrigin[0], y - self.symbolOrigin[1]]
                     self.origin = [x, y]
                     self.rotate(self.getCurrentPoint(), self.angle)
                     self.rotate(self.angle)
                     self.setZValue(z)
             elif event.key() == Qt.Key_Escape:
                 if hasattr(self, '_rotating'):
                     self.ungrabMouse()
                     transform = QTransform()
                     transform.translate((self.loc[0] + self.symbolOrigin[0]), (self.loc[1] + self.symbolOrigin[1]))
                     transform.rotateRadians(self.angle)
                     transform.translate(-self.symbolOrigin[0], -self.symbolOrigin[1])
                     self.setTransform(transform)
                     self.rotate(math.radians(self._rotating))
                     del self._rotating
             elif event.key() == Qt.Key_Up:  # translate up/down/left/right symbol
                 modifiers = QApplication.keyboardModifiers()
-...
         def mouseDoubleClickEvent(self, event):
             if not hasattr(self, '_rotating'):
                 self._rotating = True
                 self._rotating = self.rotation()
                 self.grabMouse()
         '''
-...
         '''
         def addSvgItemToScene(self, scene):
             self.rotate(self.getCurrentPoint(), self.angle)
             self.setTransformOriginPoint(QPointF(self.symbolOrigin[0], self.symbolOrigin[1]))
             if self.flip:
                 self.flip_symbol()
             self.moveBy(-self.symbolOrigin[0], -self.symbolOrigin[1])
             self.setRotation(math.degrees(-self.angle))
             self.moveBy(self.loc[0] + self.symbolOrigin[0], self.loc[1] + self.symbolOrigin[1])
             # self.rotate_symbol(self.angle, self.getCurrentPoint())
             scene.addItem(self)
             self.size[0], self.size[1] = round(self.sceneBoundingRect().width()), round(self.sceneBoundingRect().height())
             trans = self.transform()
-...
             @date       2018.05.25
         '''
         def boundingRectOnScene(self):
         def roundingRectOnScene(self):
             rect = self.boundingRect()
             rect.moveTo(self.loc[0], self.loc[1])
             return rect
         def flipSymbol(self):
             '''
                 @brief  remove item when user press delete key
                 @author humkyung
                 @date   2018.04.23
             '''
             if self.flip is 0:
                 self.flip = 1
             else:
                 self.flip = 0
             currentPoint = self.getCurrentPoint()
             self.rotate(currentPoint, self.angle)
         def flip_symbol(self) -> None:
             """flip symbol"""
         '''
             @brief      rotate Symbol
             @author     kyouho
             @date       2018.07.24
         '''
         def rotateSymbol(self, angle=None):
             if angle is None:
                 # degree 0
                 if 0 == self.angle:
                     self.angle = 1.57
                 # degree 90
                 elif (1.57 == self.angle):
                     self.angle = 3.14
                 # degree 180
                 elif 3.14 == self.angle:
                     self.angle = 4.71
                 # degree 270
                 elif 4.71 == self.angle:
                     self.angle = 0
                 else:
                     self.angle = 0
             else:
                 self.angle = angle
             currentPoint = self.getCurrentPoint()
             self.rotate(currentPoint, self.angle)
         def get_transform(self, pt, angle):
             """ return a transform """
             transform = QTransform()
             transform.translate(self.loc[0] + self.symbolOrigin[0], self.loc[1] + self.symbolOrigin[1])
             transform.rotateRadians(-angle)
             transform.translate(-pt[0], -pt[1])
             if self.flip is 1:
                 rect = self.boundingRect()
                 transform.scale(-1.0, 1.0)
                 transform.translate(-2 * self.symbolOrigin[0], 0)
                 transform.translate(-rect.width(), 0)
             return transform
             self.setTransform(transform)
         '''
             @brief      resetting rotate Symbol
             @author     kyouho
             @date       2018.07.24
         '''
         def rotate(self, standardPoint, angle):
             self.setTransform(self.get_transform(standardPoint, angle))
             self.setRotation(0)  # force to emit itemChange signal
         def rotate(self, angle: float) -> None:
             """rotate symbol by given angle in radian"""
             import math
             self.setRotation(math.degrees(angle))
         '''
             @brief      change Conn point
-...
             currentPoint = self.getCurrentPoint()
             #self.reSettingSymbol(currentPoint, self.angle)
         '''
             @brief      get standard point
             @author     kyouho
             @date       2018.07.25
         '''
         def getCurrentPoint(self):
             """return transform origin point"""
             pointList = []
             pointList.append(self.symbolOrigin)
             for connector in self.connectors:
-...
             @date       18.08.06
         '''
         """
         def reCalculationRotatedItem(self):
             goPoint = self.get_transform(self.getCurrentPoint(), self.angle).map(
                 QPoint(self.symbolOrigin[0], self.symbolOrigin[1]))
             self.loc = [self.loc[0] + self.origin[0] - goPoint.x(), self.loc[1] + self.origin[1] - goPoint.y()]
         """
     def recursiveChangeAttributes(node, attName, attValue):

내보내기 Unified diff

프로젝트

일반

사용자정보

HYTOS

개정판 e05a52a4