source: orange/Orange/OrangeCanvas/canvas/items/linkitem.py @ 11182:70ae8e72389b

Revision 11182:70ae8e72389b, 11.4 KB checked in by Ales Erjavec <ales.erjavec@…>, 17 months ago (diff)

Showing the dynamic link state in the canvas.

Line 
1"""
2Link Item
3
4"""
5
6from PyQt4.QtGui import (
7    QGraphicsItem, QGraphicsEllipseItem, QGraphicsPathItem, QGraphicsObject,
8    QGraphicsTextItem, QGraphicsDropShadowEffect, QPen, QBrush, QColor,
9    QPainterPath, QFont, QTransform
10)
11
12from PyQt4.QtCore import Qt, QPointF
13
14from .nodeitem import SHADOW_COLOR
15
16
17class LinkCurveItem(QGraphicsPathItem):
18    """Link curve item. The main component of `LinkItem`.
19    """
20    def __init__(self, parent):
21        QGraphicsPathItem.__init__(self, parent)
22        assert(isinstance(parent, LinkItem))
23
24        self.__canvasLink = parent
25        self.setAcceptHoverEvents(True)
26        self.setAcceptedMouseButtons(Qt.RightButton)
27        self.setAcceptedMouseButtons(Qt.LeftButton)
28
29        self.shadow = QGraphicsDropShadowEffect(
30            blurRadius=5, color=QColor(SHADOW_COLOR),
31            offset=QPointF(0, 0)
32        )
33
34        self.normalPen = QPen(QBrush(QColor("#9CACB4")), 2.0)
35        self.hoverPen = QPen(QBrush(QColor("#7D7D7D")), 2.1)
36        self.setPen(self.normalPen)
37        self.setGraphicsEffect(self.shadow)
38        self.shadow.setEnabled(False)
39
40        self.__hover = False
41
42    def linkItem(self):
43        """Return the :class:`LinkItem` instance this curve belongs to.
44
45        """
46        return self.__canvasLink
47
48    def setHoverState(self, state):
49        self.__hover = state
50        self.__update()
51
52    def setCurvePenSet(self, pen, hoverPen):
53        if pen is not None:
54            self.normalPen = pen
55        if hoverPen is not None:
56            self.hoverPen = hoverPen
57        self.__update()
58
59    def itemChange(self, change, value):
60        if change == QGraphicsItem.ItemEnabledHasChanged:
61            # Update the pen style
62            self.__update()
63
64        return QGraphicsPathItem.itemChange(self, change, value)
65
66    def __update(self):
67        shadow_enabled = self.__hover
68        if self.shadow.isEnabled() != shadow_enabled:
69            self.shadow.setEnabled(shadow_enabled)
70
71        link_enabled = self.isEnabled()
72        if link_enabled:
73            pen_style = Qt.SolidLine
74        else:
75            pen_style = Qt.DashLine
76
77        if self.__hover:
78            pen = self.hoverPen
79        else:
80            pen = self.normalPen
81
82        pen.setStyle(pen_style)
83        self.setPen(pen)
84
85
86class LinkAnchorIndicator(QGraphicsEllipseItem):
87    """A visual indicator of the link anchor point at both ends
88    of the `LinkItem`.
89
90    """
91    def __init__(self, *args):
92        QGraphicsEllipseItem.__init__(self, *args)
93        self.setRect(-3, -3, 6, 6)
94        self.setPen(QPen(Qt.NoPen))
95        self.normalBrush = QBrush(QColor("#9CACB4"))
96        self.hoverBrush = QBrush(QColor("#7D7D7D"))
97        self.setBrush(self.normalBrush)
98        self.__hover = False
99
100    def setHoverState(self, state):
101        """The hover state is set by the LinkItem.
102        """
103        self.__hover = state
104        if state:
105            self.setBrush(self.hoverBrush)
106        else:
107            self.setBrush(self.normalBrush)
108
109
110class LinkItem(QGraphicsObject):
111    """A Link in the canvas.
112    """
113
114    Z_VALUE = 0
115    """Z value of the item"""
116
117    def __init__(self, *args):
118        QGraphicsObject.__init__(self, *args)
119        self.setFlag(QGraphicsItem.ItemHasNoContents, True)
120        self.setAcceptedMouseButtons(Qt.RightButton)
121        self.setAcceptHoverEvents(True)
122
123        self.setZValue(self.Z_VALUE)
124
125        self.sourceItem = None
126        self.sourceAnchor = None
127        self.sinkItem = None
128        self.sinkAnchor = None
129        self.curveItem = LinkCurveItem(self)
130        self.sourceIndicator = LinkAnchorIndicator(self)
131        self.sinkIndicator = LinkAnchorIndicator(self)
132        self.sourceIndicator.hide()
133        self.sinkIndicator.hide()
134
135        self.linkTextItem = QGraphicsTextItem(self)
136        self.linkTextItem.setFont(QFont("Helvetica", 11))
137
138        self.__sourceName = ""
139        self.__sinkName = ""
140
141        self.__dynamic = False
142        self.__dynamicEnabled = False
143
144        self.hover = False
145
146    def setSourceItem(self, item, anchor=None):
147        """Set the source `item` (:class:`CanvasNodeItem`). Use `anchor`
148        (:class:`AnchorPoint) as the curve start point (if `None` a new
149        output anchor will be created).
150
151        Setting item to `None` and a valid anchor is a valid operation
152        (for instance while mouse dragging one and of the link).
153
154        """
155        if item is not None and anchor is not None:
156            if anchor not in item.outputAnchors():
157                raise ValueError("Anchor must be belong to the item")
158
159        if self.sourceItem != item:
160            if self.sourceAnchor:
161                # Remove a previous source item and the corresponding anchor
162                self.sourceAnchor.scenePositionChanged.disconnect(
163                    self._sourcePosChanged
164                )
165
166                if self.sourceItem is not None:
167                    self.sourceItem.removeOutputAnchor(self.sourceAnchor)
168
169                self.sourceItem = self.sourceAnchor = None
170
171            self.sourceItem = item
172
173            if item is not None and anchor is None:
174                # Create a new output anchor for the item if none is provided.
175                anchor = item.newOutputAnchor()
176
177            # Update the visibility of the start point indicator.
178            self.sourceIndicator.setVisible(bool(item))
179
180        if anchor != self.sourceAnchor:
181            if self.sourceAnchor is not None:
182                self.sourceAnchor.scenePositionChanged.disconnect(
183                    self._sourcePosChanged
184                )
185
186            self.sourceAnchor = anchor
187
188            if self.sourceAnchor is not None:
189                self.sourceAnchor.scenePositionChanged.connect(
190                    self._sourcePosChanged
191                )
192
193        self.__updateCurve()
194
195    def setSinkItem(self, item, anchor=None):
196        """Set the sink `item` (:class:`CanvasNodeItem`). Use `anchor`
197        (:class:`AnchorPoint) as the curve end point (if `None` a new
198        input anchor will be created).
199
200        Setting item to `None` and a valid anchor is a valid operation
201        (for instance while mouse dragging one and of the link).
202        """
203        if item is not None and anchor is not None:
204            if anchor not in item.inputAnchors():
205                raise ValueError("Anchor must be belong to the item")
206
207        if self.sinkItem != item:
208            if self.sinkAnchor:
209                # Remove a previous source item and the corresponding anchor
210                self.sinkAnchor.scenePositionChanged.disconnect(
211                    self._sinkPosChanged
212                )
213
214                if self.sinkItem is not None:
215                    self.sinkItem.removeInputAnchor(self.sinkAnchor)
216
217                self.sinkItem = self.sinkAnchor = None
218
219            self.sinkItem = item
220
221            if item is not None and anchor is None:
222                # Create a new input anchor for the item if none is provided.
223                anchor = item.newInputAnchor()
224
225            # Update the visibility of the end point indicator.
226            self.sinkIndicator.setVisible(bool(item))
227
228        if self.sinkAnchor != anchor:
229            if self.sinkAnchor is not None:
230                self.sinkAnchor.scenePositionChanged.disconnect(
231                    self._sinkPosChanged
232                )
233
234            self.sinkAnchor = anchor
235
236            if self.sinkAnchor is not None:
237                self.sinkAnchor.scenePositionChanged.connect(
238                    self._sinkPosChanged
239                )
240
241        self.__updateCurve()
242
243    def setChannelNamesVisible(self, visible):
244        self.linkTextItem.setVisible(visible)
245
246    def setSourceName(self, name):
247        if self.__sourceName != name:
248            self.__sourceName = name
249            self.__updateText()
250
251    def sourceName(self):
252        return self.__sourceName
253
254    def setSinkName(self, name):
255        if self.__sinkName != name:
256            self.__sinkName = name
257            self.__updateText()
258
259    def sinkName(self):
260        return self.__sinkName
261
262    def _sinkPosChanged(self, *arg):
263        self.__updateCurve()
264
265    def _sourcePosChanged(self, *arg):
266        self.__updateCurve()
267
268    def __updateCurve(self):
269        self.prepareGeometryChange()
270        if self.sourceAnchor and self.sinkAnchor:
271            source_pos = self.sourceAnchor.anchorScenePos()
272            sink_pos = self.sinkAnchor.anchorScenePos()
273            source_pos = self.curveItem.mapFromScene(source_pos)
274            sink_pos = self.curveItem.mapFromScene(sink_pos)
275            # TODO: get the orthogonal angle to the anchors path.
276            path = QPainterPath()
277            path.moveTo(source_pos)
278            path.cubicTo(source_pos + QPointF(60, 0),
279                         sink_pos - QPointF(60, 0),
280                         sink_pos)
281
282            self.curveItem.setPath(path)
283            self.sourceIndicator.setPos(source_pos)
284            self.sinkIndicator.setPos(sink_pos)
285            self.__updateText()
286        else:
287            self.setHoverState(False)
288            self.curveItem.setPath(QPainterPath())
289
290    def __updateText(self):
291        if self.__sourceName or self.__sinkName:
292            text = "{0} --> {1}".format(self.__sourceName, self.__sinkName)
293        else:
294            text = ""
295        self.linkTextItem.setPlainText(text)
296
297        path = self.curveItem.path()
298        if not path.isEmpty():
299            center = path.pointAtPercent(0.5)
300            angle = path.angleAtPercent(0.5)
301
302            brect = self.linkTextItem.boundingRect()
303
304            transform = QTransform()
305            transform.translate(center.x(), center.y())
306            transform.rotate(-angle)
307
308            # Center and move above the curve path.
309            transform.translate(-brect.width() / 2, -brect.height())
310
311            self.linkTextItem.setTransform(transform)
312
313    def removeLink(self):
314        self.setSinkItem(None)
315        self.setSourceItem(None)
316        self.__updateCurve()
317
318    def setHoverState(self, state):
319        if self.hover != state:
320            self.hover = state
321            self.sinkIndicator.setHoverState(state)
322            self.sourceIndicator.setHoverState(state)
323            self.curveItem.setHoverState(state)
324
325    def hoverEnterEvent(self, event):
326        self.setHoverState(True)
327        return QGraphicsObject.hoverEnterEvent(self, event)
328
329    def hoverLeaveEvent(self, event):
330        self.setHoverState(False)
331        return QGraphicsObject.hoverLeaveEvent(self, event)
332
333    def boundingRect(self):
334        return self.childrenBoundingRect()
335
336    def shape(self):
337        return self.curveItem.shape()
338
339    def setEnabled(self, enabled):
340        QGraphicsObject.setEnabled(self, enabled)
341
342    def setDynamicEnabled(self, enabled):
343        if self.__dynamicEnabled != enabled:
344            self.__dynamicEnabled = enabled
345            if self.__dynamic:
346                self.__updatePen()
347
348    def isDynamicEnabled(self):
349        return self.__dynamicEnabled
350
351    def setDynamic(self, dynamic):
352        if self.__dynamic != dynamic:
353            self.__dynamic = dynamic
354            self.__updatePen()
355
356    def isDynamic(self):
357        return self.__dynamic
358
359    def __updatePen(self):
360        if self.__dynamic:
361            if self.__dynamicEnabled:
362                color = QColor(0, 150, 0, 150)
363            else:
364                color = QColor(150, 0, 0, 150)
365
366            normal = QPen(QBrush(color), 2.0)
367            hover = QPen(QBrush(color.darker(120)), 2.1)
368        else:
369            normal = QPen(QBrush(QColor("#9CACB4")), 2.0)
370            hover = QPen(QBrush(QColor("#7D7D7D")), 2.1)
371
372        self.curveItem.setCurvePenSet(normal, hover)
Note: See TracBrowser for help on using the repository browser.