Changeset 11161:981b2bbe3262 in orange


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.

Location:
Orange/OrangeCanvas/canvas/items
Files:
3 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): 
  • Orange/OrangeCanvas/canvas/items/controlpoints.py

    r11160 r11161  
    109109    rectEdited = Signal(QRectF) 
    110110 
     111    editingStarted = Signal() 
     112    editingFinished = Signal() 
     113 
    111114    def __init__(self, parent=None, rect=None, constraints=0, **kwargs): 
    112115        QGraphicsObject.__init__(self, parent, **kwargs) 
    113116        self.setFlag(QGraphicsItem.ItemHasNoContents) 
     117        self.setFlag(QGraphicsItem.ItemIsFocusable) 
    114118 
    115119        self.__rect = rect if rect is not None else QRectF() 
     
    132136            self.__installFilter() 
    133137 
     138        for p in points: 
     139            p.setFlag(QGraphicsItem.ItemIsFocusable) 
     140            p.setFocusProxy(self) 
     141 
    134142        self.controlPoint(ControlPoint.Top).setConstraint(Qt.Vertical) 
    135143        self.controlPoint(ControlPoint.Bottom).setConstraint(Qt.Vertical) 
     
    149157    def setRect(self, rect): 
    150158        if self.__rect != rect: 
    151             self.__rect = rect 
     159            self.__rect = QRectF(rect) 
    152160            self.__pointsLayout() 
    153161            self.prepareGeometryChange() 
     
    183191    def setConstraints(self, constraints): 
    184192        pass 
     193 
     194    def focusInEvent(self, event): 
     195        QGraphicsObject.focusInEvent(self, event) 
     196        if event.isAccepted(): 
     197            self.editingStarted.emit() 
     198 
     199    def focusOutEvent(self, event): 
     200        QGraphicsObject.focusOutEvent(self, event) 
     201        if event.isAccepted(): 
     202            self.editingFinished.emit() 
    185203 
    186204    def itemChange(self, change, value): 
     
    292310    lineEdited = Signal(QLineF) 
    293311 
     312    editingStarted = Signal() 
     313    editingFinished = Signal() 
     314 
    294315    def __init__(self, parent=None, **kwargs): 
    295316        QGraphicsObject.__init__(self, parent, **kwargs) 
    296317        self.setFlag(QGraphicsItem.ItemHasNoContents) 
     318        self.setFlag(QGraphicsItem.ItemIsFocusable) 
    297319 
    298320        self.__line = QLineF() 
     
    306328        if self.scene(): 
    307329            self.__installFilter() 
     330        for p in self.__points: 
     331            p.setFlag(QGraphicsItem.ItemIsFocusable) 
     332            p.setFocusProxy(self) 
    308333 
    309334    def setLine(self, line): 
     
    318343    def line(self): 
    319344        return self.__line 
     345 
     346    def focusInEvent(self, event): 
     347        QGraphicsObject.focusInEvent(self, event) 
     348        if event.isAccepted(): 
     349            self.editingStarted.emit() 
     350 
     351    def focusOutEvent(self, event): 
     352        QGraphicsObject.focusOutEvent(self, event) 
     353        if event.isAccepted(): 
     354            self.editingFinished.emit() 
    320355 
    321356    def __installFilter(self): 
  • Orange/OrangeCanvas/canvas/items/tests/test_controlpoints.py

    r11160 r11161  
    1 from PyQt4.QtGui import QPainterPath, QBrush, QPen, QColor 
    2 from PyQt4.QtCore import QPointF 
     1from PyQt4.QtGui import QGraphicsRectItem, QGraphicsLineItem 
     2from PyQt4.QtCore import QRectF, QMargins, QLineF 
    33 
    44from . import TestItems 
    55 
    6 from ..controlpoints import ControlPoint 
     6from ..controlpoints import ControlPoint, ControlPointRect, ControlPointLine 
     7 
    78 
    89class TestControlPoints(TestItems): 
    910    def test_controlpoint(self): 
    1011        point = ControlPoint() 
     12 
     13        self.scene.addItem(point) 
     14 
     15        point.setAnchor(ControlPoint.Left) 
     16        self.assertEqual(point.anchor(), ControlPoint.Left) 
     17 
     18    def test_controlpointrect(self): 
     19        control = ControlPointRect() 
     20        rect = QGraphicsRectItem(QRectF(10, 10, 100, 200)) 
     21        self.scene.addItem(rect) 
     22        self.scene.addItem(control) 
     23 
     24        control.setRect(rect.rect()) 
     25        control.setFocus() 
     26        control.rectChanged.connect(rect.setRect) 
     27 
     28        control.setRect(QRectF(20, 20, 100, 200)) 
     29        self.assertEqual(control.rect(), rect.rect()) 
     30        self.assertEqual(control.rect(), QRectF(20, 20, 100, 200)) 
     31 
     32        control.setControlMargins(5) 
     33        self.assertEqual(control.controlMargins(), QMargins(5, 5, 5, 5)) 
     34        control.rectEdited.connect(rect.setRect) 
     35 
     36        self.view.show() 
     37        self.app.exec_() 
     38 
     39        self.assertEqual(rect.rect(), control.rect()) 
     40 
     41    def test_controlpointline(self): 
     42        control = ControlPointLine() 
     43        line = QGraphicsLineItem(10, 10, 200, 200) 
     44 
     45        self.scene.addItem(line) 
     46        self.scene.addItem(control) 
     47 
     48        control.setLine(line.line()) 
     49        control.setFocus() 
     50        control.lineChanged.connect(line.setLine) 
     51 
     52        control.setLine(QLineF(30, 30, 180, 180)) 
     53        self.assertEqual(control.line(), line.line()) 
     54        self.assertEqual(line.line(), QLineF(30, 30, 180, 180)) 
     55 
     56        control.lineEdited.connect(line.setLine) 
     57 
     58        self.view.show() 
     59        self.app.exec_() 
     60 
     61        self.assertEqual(control.line(), line.line()) 
Note: See TracChangeset for help on using the changeset viewer.