Ignore:
Timestamp:
10/29/12 15:18:29 (18 months ago)
Author:
Ales Erjavec <ales.erjavec@…>
Branch:
default
Message:

Removed control points from the annotation graphics items.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • Orange/OrangeCanvas/canvas/items/annotationitem.py

    r11160 r11161  
    55    QGraphicsItem, QGraphicsPathItem, QGraphicsWidget, 
    66    QGraphicsTextItem, QPainterPath, QPainterPathStroker, 
    7     QPolygonF 
     7    QPen, QPolygonF 
    88) 
    99 
     
    1717 
    1818from .graphicspathobject import GraphicsPathObject 
    19 from .controlpoints import ControlPointLine, ControlPointRect 
    2019 
    2120 
     
    2827 
    2928class TextAnnotation(Annotation): 
    30     """Text annotation for the canvas scheme. 
     29    """Text annotation item for the canvas scheme. 
    3130 
    3231    """ 
    3332    editingFinished = Signal() 
     33    """Emitted when the editing is finished (i.e. the item loses focus).""" 
     34 
    3435    textEdited = Signal() 
     36    """Emitted when the edited text changes.""" 
    3537 
    3638    def __init__(self, parent=None, **kwargs): 
     
    4446        rect = self.geometry().translated(-self.pos()) 
    4547        self.__framePathItem = QGraphicsPathItem(self) 
    46         self.__controlPoints = ControlPointRect(self) 
    47         self.__controlPoints.setRect(rect) 
    48         self.__controlPoints.rectEdited.connect(self.__onControlRectEdited) 
    49         self.geometryChanged.connect(self.__updateControlPoints) 
     48        self.__framePathItem.setPen(QPen(Qt.NoPen)) 
    5049 
    5150        self.__textItem = QGraphicsTextItem(self) 
     
    5857        layout.documentSizeChanged.connect(self.__onDocumentSizeChanged) 
    5958 
     59        self.setFocusProxy(self.__textItem) 
     60 
    6061        self.__updateFrame() 
    61  
    62         self.__controlPoints.hide() 
    6362 
    6463    def adjustSize(self): 
     
    7170        geom = QRectF(self.pos(), size + QSizeF(left + right, top + bottom)) 
    7271        self.setGeometry(geom) 
     72 
     73    def setFramePen(self, pen): 
     74        """Set the frame pen. By default Qt.NoPen is used (i.e. the frame 
     75        is not shown). 
     76 
     77        """ 
     78        self.__framePathItem.setPen(pen) 
     79 
     80    def framePen(self): 
     81        """Return the frame pen. 
     82        """ 
     83        return self.__framePathItem.pen() 
    7384 
    7485    def setPlainText(self, text): 
     
    140151                self.__textInteractionFlags & Qt.TextEditable: 
    141152            self.startEdit() 
    142  
    143     def focusInEvent(self, event): 
    144         # Reparent the control points item to the scene 
    145         self.__controlPoints.setParentItem(None) 
    146         self.__controlPoints.show() 
    147         self.__controlPoints.setZValue(self.zValue() + 3) 
    148         self.__updateControlPoints() 
    149         Annotation.focusInEvent(self, event) 
    150  
    151     def focusOutEvent(self, event): 
    152         self.__controlPoints.hide() 
    153         # Reparent back to self 
    154         self.__controlPoints.setParentItem(self) 
    155         Annotation.focusOutEvent(self, event) 
    156153 
    157154    def startEdit(self): 
     
    194191                      exc_info=True) 
    195192 
    196     def __onControlRectEdited(self, newrect): 
    197         # The control rect has been edited by the user 
    198         # new rect is ins scene coordinates 
    199         try: 
    200             newpos = newrect.topLeft() 
    201             parent = self.parentItem() 
    202             if parent: 
    203                 newpos = parent.mapFromScene(newpos) 
    204  
    205             geom = QRectF(newpos, newrect.size()) 
    206             self.setGeometry(geom) 
    207         except Exception: 
    208             log.error("An error occurred in '__onControlRectEdited'", 
    209                       exc_info=True) 
    210  
    211193    def __updateFrame(self): 
    212194        rect = self.geometry() 
     
    216198        self.__framePathItem.setPath(path) 
    217199 
    218     def __updateControlPoints(self, *args): 
    219         """Update the control points geometry. 
    220         """ 
    221         if not self.__controlPoints.isVisible(): 
    222             return 
    223  
    224         try: 
    225             geom = self.geometry() 
    226             parent = self.parentItem() 
    227             # The control rect is in scene coordinates 
    228             if parent is not None: 
    229                 geom = QRectF(parent.mapToScene(geom.topLeft()), 
    230                               geom.size()) 
    231             self.__controlPoints.setRect(geom) 
    232         except Exception: 
    233             log.error("An error occurred in '__updateControlPoints'", 
    234                       exc_info=True) 
    235  
    236200    def resizeEvent(self, event): 
    237201        width = event.newSize().width() 
     
    239203        self.__textItem.setTextWidth(max(width - left - right, 0)) 
    240204        self.__updateFrame() 
    241         self.__updateControlPoints() 
    242205        QGraphicsWidget.resizeEvent(self, event) 
    243206 
     
    266229    def setLine(self, line): 
    267230        if self.__line != line: 
    268             self.__line = line 
     231            self.__line = QLineF(line) 
    269232            self.__updateArrowPath() 
    270233 
    271234    def line(self): 
    272         return self.__line 
     235        return QLineF(self.__line) 
    273236 
    274237    def setLineWidth(self, lineWidth): 
     
    329292        self.__arrowItem.setLine(line) 
    330293        self.__arrowItem.setBrush(Qt.red) 
    331         self.__arrowItem.setPen(Qt.NoPen) 
    332         self.__controlPointLine = ControlPointLine(self) 
    333         self.__controlPointLine.setLine(line) 
    334         self.__controlPointLine.hide() 
    335         self.__controlPointLine.lineEdited.connect(self.__onLineEdited) 
     294        self.__arrowItem.setPen(QPen(Qt.NoPen)) 
    336295 
    337296    def setLine(self, line): 
    338         """Set the arrow base line (a QLineF in object coordinates). 
     297        """Set the arrow base line (a `QLineF` in object coordinates). 
    339298        """ 
    340299        if self.__line != line: 
    341300            self.__line = line 
    342 #            self.__arrowItem.setLine(line) 
    343             # Check if the line does not fit inside the geometry. 
    344301 
    345302            geom = self.geometry().translated(-self.pos()) 
     
    347304            if geom.isNull() and not line.isNull(): 
    348305                geom = QRectF(0, 0, 1, 1) 
    349             line_rect = QRectF(line.p1(), line.p2()) 
     306            line_rect = QRectF(line.p1(), line.p2()).normalized() 
    350307 
    351308            if not (geom.contains(line_rect)): 
     
    362319    def adjustGeometry(self): 
    363320        """Adjust the widget geometry to exactly fit the arrow inside 
    364         preserving the arrow path scene geometry. 
     321        while preserving the arrow path scene geometry. 
    365322 
    366323        """ 
     
    380337 
    381338    def line(self): 
    382         return self.__line 
     339        return QLineF(self.__line) 
    383340 
    384341    def setLineWidth(self, lineWidth): 
     
    387344    def lineWidth(self): 
    388345        return self.__arrowItem.lineWidth() 
    389  
    390     def focusInEvent(self, event): 
    391         self.__controlPointLine.setParentItem(None) 
    392         self.__controlPointLine.show() 
    393         self.__controlPointLine.setZValue(self.zValue() + 3) 
    394         self.__updateControlLine() 
    395         self.geometryChanged.connect(self.__onGeometryChange) 
    396         return Annotation.focusInEvent(self, event) 
    397  
    398     def focusOutEvent(self, event): 
    399         self.__controlPointLine.hide() 
    400         self.__controlPointLine.setParentItem(self) 
    401         self.geometryChanged.disconnect(self.__onGeometryChange) 
    402         return Annotation.focusOutEvent(self, event) 
    403  
    404     def __updateControlLine(self): 
    405         if not self.__controlPointLine.isVisible(): 
    406             return 
    407  
    408         line = self.__line 
    409         line = QLineF(self.mapToScene(line.p1()), 
    410                       self.mapToScene(line.p2())) 
    411         self.__controlPointLine.setLine(line) 
    412  
    413     def __onLineEdited(self, line): 
    414         line = QLineF(self.mapFromScene(line.p1()), 
    415                       self.mapFromScene(line.p2())) 
    416         self.setLine(line) 
    417  
    418     def __onGeometryChange(self): 
    419         if self.__controlPointLine.isVisible(): 
    420             self.__updateControlLine() 
    421346 
    422347    def shape(self): 
Note: See TracChangeset for help on using the changeset viewer.