Example #1
0
    def __init__(self, node, name, layout, ui, left):
        super(FWidget, self).__init__()

        self.node = node
        self.name = name
        self.plugRect = None
        self.labelRect = None
        self.links = WeakList()
        self.linked = WeakList()

        self._over = False
        self._base_color = QtCore.Qt.cyan
        self._color = self._base_color

        widget = UiFactory.widget(ui)

        self.widget = widget

        if left:
            widget.setLayoutDirection(QtCore.Qt.RightToLeft)
            widget.setStyleSheet("background: green")
        else:
            widget.setLayoutDirection(QtCore.Qt.LeftToRight)
            widget.setStyleSheet("background: red")

        widget.setMouseTracking(True)
        widget.setFocusPolicy(QtCore.Qt.NoFocus)
        widget.installEventFilter(self)

        layout.addWidget(widget)
Example #2
0
    def updateSelection(self, rect):
        selected = self.items(rect)
        selected = [item for item in selected if hasattr(item, "selected")]

        modifier = QtGui.QApplication.keyboardModifiers()
        ctrl = modifier & QtCore.Qt.ControlModifier

        selection = WeakList()

        for item in self.selection:
            if item in selected:
                continue

            if ctrl:
                selection.append(item)
            else:
                item.selected = False

        for item in selected:
            if not item.selected:
                item.selected = True
            selection.append(item)

        self.selection = selection
Example #3
0
    def onRunTimer(self):
        view = self.views()[0]
        rect = view.mapToScene(view.viewport().rect()).boundingRect()
        # rect = self.sceneRect()

        if not hasattr(self, "balls"):
            self.balls = WeakList()
            num_balls = self.num_balls
            upd = QtGui.QGraphicsView.BoundingRectViewportUpdate

            if num_balls > 100:
                view.setViewportUpdateMode(upd)

            for _ in xrange(num_balls):
                size = random.randint(30, 60)
                ball = Ball(size, rect)
                self.addItem(ball)
                self.balls.append(ball)

        try:
            for ball in self.balls:
                ball.go(rect)
        except KeyboardInterrupt:
            sys.exit(0)
Example #4
0
class FWidget(QtCore.QObject):
    def __init__(self, node, name, layout, ui, left):
        super(FWidget, self).__init__()

        self.node = node
        self.name = name
        self.plugRect = None
        self.labelRect = None
        self.links = WeakList()
        self.linked = WeakList()

        self._over = False
        self._base_color = QtCore.Qt.cyan
        self._color = self._base_color

        widget = UiFactory.widget(ui)

        self.widget = widget

        if left:
            widget.setLayoutDirection(QtCore.Qt.RightToLeft)
            widget.setStyleSheet("background: green")
        else:
            widget.setLayoutDirection(QtCore.Qt.LeftToRight)
            widget.setStyleSheet("background: red")

        widget.setMouseTracking(True)
        widget.setFocusPolicy(QtCore.Qt.NoFocus)
        widget.installEventFilter(self)

        layout.addWidget(widget)

    def scene(self):
        return self.node.scene()

    @WeakProperty
    def node(self):
        return

    @property
    def over(self):
        return self._over

    @over.setter
    def over(self, state):
        if self._over == state:
            return

        self._over = state
        self.updateColor()

        self.node.update()

    def updateColor(self):
        if self._over:
            color = COLORS.OVER
        elif self.node._selected:
            color = COLORS.SELECTED
        else:
            color = self._base_color

        self._color = color

        for link in self.links:
            link.updateColor(color)

    @WeakProperty
    def widget(self):
        return

    def paint(self, painter, options, widget):
        if not self.widget:
            return
        if not self.plugRect:
            return

        dbg3("PAINT {0}", self)

        painter.setBrush(self._color)
        painter.drawEllipse(self.plugRect)

        if self.over:
            painter.setBrush(self._color)
            painter.drawRect(self.labelRect)

    def repaintLinks(self):
        for link in self.links:
            link.setVisible(True)
            link.fetchPath()
            link.update()
        for link in self.linked:
            link.setVisible(True)
            link.fetchPath()
            link.update()

    def hideLinks(self):
        for link in self.links:
            link.setVisible(False)
        for link in self.linked:
            link.setVisible(False)

    def __str__(self):
        return self.name

    def __repr__(self):
        return self.__str__()

    def getPlugRect(self):
        icon = self.widget.plug

        pos = icon.pos()
        rect = icon.rect()
        rect.translate(pos)
        rect = self.mapToParent(rect)

        return rect

    def getLabelRect(self):
        icon = self.widget.label

        pos = icon.pos()
        rect = icon.rect()
        rect.translate(pos)
        rect = self.mapToParent(rect)

        return rect

    def updateLayout(self):
        if not self.widget:
            return

        rect = self.getPlugRect()

        if rect == self.plugRect:
            return

        self.plugRect = rect
        self.labelRect = self.getLabelRect()

        self.updateLinks()

    def updateLinks(self):
        rect = self.plugRect

        if not rect:
            return

        for link in self.links:
            link.updatePath(root=self.mapToScene(rect.center()))

        for link in self.linked:
            link.updatePath(tip=self.mapToScene(rect.center()))

    def eventFilter(self, widget, event):
        etype = event.type()

        dbg4("FILTER {0} {1}", self, etype)

        if etype == QtCore.QEvent.Paint:
            self.updateLayout()
        elif etype == QtCore.QEvent.Enter:
            self.over = True
        elif etype == QtCore.QEvent.Leave:
            self.over = False
        elif etype == QtCore.QEvent.MouseButtonPress:
            self.scene().dragged = self

        return False

    def mapToParent(self, rect):
        p1 = self.widget.mapToParent(rect.topLeft())
        p2 = self.widget.mapToParent(rect.bottomRight())
        return QtCore.QRect(p1, p2)

    def mapToScene(self, value):
        return self.node.mapToScene(value)

    def connectField(self, target):
        dbg3("CONNECT {0} to {1}".format(self, target))
        lnk = Link(self, target)
        self.scene().addItem(lnk)
        self.links.append(lnk)
        target.linked.append(lnk)

        lnk.fetchPath()

    def dropped(self, source):
        source.connectField(self)

    def disconnectField(self, target, link=None):
        if link is None:
            for item in self.links:
                if item.target == target:
                    link = item
                    break

        if link in self.links:
            self.links.remove(link)
        if target and link in target.linked:
            target.linked.remove(link)

        self.scene().removeItem(link)

    def release(self):
        for link in self.links:
            link.breakLink()
        for link in self.linked:
            link.breakLink()
Example #5
0
class Scene(QtGui.QGraphicsScene):
    def __init__(self, num_balls=0):
        self.selection = WeakList()
        self.dragged = None
        self.num_balls = num_balls
        super(Scene, self).__init__()

    def update(self, *args, **kwargs):
        dbg("UPDATE SCENE")
        super(Scene, self).update(*args, **kwargs)

    @WeakProperty
    def dragged(self):
        return

    def keyPressEvent(self, event):
        key = event.key()

        if key == QtCore.Qt.Key_Delete:
            dbg("Key DELETE")
            self.deleteSelection()
        elif key == QtCore.Qt.Key_F:
            self.fit()
        elif key == QtCore.Qt.Key_C:
            self.views()[0].createItems()
        else:
            dbg("Key PRESS {0}", key)

    def fit(self):
        if self.selection:
            nodes, _ = self.isolateItems(self.selection)
        else:
            nodes, _ = self.isolateItems(self.items())

        rect = self.itemsRect(nodes)

        if not rect:
            return

        dbg("FIT {0}", rect)
        for view in self.views():
            view.fitInView(rect, QtCore.Qt.KeepAspectRatio)

    def itemsRect(self, nodes):
        rect = None

        for item in nodes:
            item_rect = item.mapToScene(item.boundingRect())
            item_rect = item_rect.boundingRect()

            if rect is None:
                rect = QtCore.QRectF(item_rect)
            else:
                rect = rect.united(item_rect)

        return rect

    def isolateItems(self, items):
        nodes = list()
        links = list()

        for item in items:
            if isinstance(item, Link):
                links.append(item)
            elif isinstance(item, PWidget):
                nodes.append(item)

        return (nodes, links)

    def deleteSelection(self):
        nodes, links = self.isolateItems(self.selection)

        if nodes:
            for node in nodes:
                self.deleteNode(node)
        elif links:
            for link in links:
                link.breakLink()

    def deleteNode(self, node):
        node.release()

        if node in self.items():
            self.removeItem(node)

    def clearSelection(self):
        dbg("CLEAR SELECTION")
        for item in self.selection:
            item.selected = False
        self.selection = WeakList()

    def updateSelection(self, rect):
        selected = self.items(rect)
        selected = [item for item in selected if hasattr(item, "selected")]

        modifier = QtGui.QApplication.keyboardModifiers()
        ctrl = modifier & QtCore.Qt.ControlModifier

        selection = WeakList()

        for item in self.selection:
            if item in selected:
                continue

            if ctrl:
                selection.append(item)
            else:
                item.selected = False

        for item in selected:
            if not item.selected:
                item.selected = True
            selection.append(item)

        self.selection = selection

    def repaintSelectionLinks(self):
        items = self.selection

        if not items:
            return

        for item in self.selection:
            if isinstance(item, PWidget):
                item.repaintLinks()

    def onRunTimer(self):
        view = self.views()[0]
        rect = view.mapToScene(view.viewport().rect()).boundingRect()
        # rect = self.sceneRect()

        if not hasattr(self, "balls"):
            self.balls = WeakList()
            num_balls = self.num_balls
            upd = QtGui.QGraphicsView.BoundingRectViewportUpdate

            if num_balls > 100:
                view.setViewportUpdateMode(upd)

            for _ in xrange(num_balls):
                size = random.randint(30, 60)
                ball = Ball(size, rect)
                self.addItem(ball)
                self.balls.append(ball)

        try:
            for ball in self.balls:
                ball.go(rect)
        except KeyboardInterrupt:
            sys.exit(0)
Example #6
0
    dt = Datas(42)
    dt2 = Datas(777)

    # bench(num)
    dtc(num, dt, dt2)


class tst(object):
    def __init__(self, var):
        self.var = var

    def __str__(self):
        return "<tst {0}>".format(self.var)

    def __repr__(self):
        return self.__str__()

    def __del__(self):
        print "destroying tst {0}".format(self.var)


if __name__ == "__main__":
    s = weakref.WeakSet()
    d = weakref.WeakValueDictionary()
    l = WeakList()

    o1 = tst(42)
    o2 = tst(66)
    l.append(o1)
    l.append(o2)