def setUp(self):
     port = Port()
     self.source_block = self.create_block()
     self.source_block.ports.append(port)
     self.source_block = Block(self.create_diagram(), self.create_block())
     self.diagram = self.create_diagram()
     self.connector = Connector(self.diagram, self.source_block, port)
Beispiel #2
0
    def setUp(self):
        """Do the test basic setup."""
        win = MainWindow()
        diagram = Diagram(win)

        blockmodel = BlockModel()
        source = Block(diagram, blockmodel)

        # NAO TRATA NONE
        # source = None
        source_port = 0
        conn_type = None
        self.connector = Connector(diagram, source, source_port, conn_type)
Beispiel #3
0
class TestConnector(TestCase):

    def setUp(self):
        """Do the test basic setup."""
        win = MainWindow()
        diagram = Diagram(win)

        blockmodel = BlockModel()
        source = Block(diagram, blockmodel)

        # NAO TRATA NONE
        # source = None
        source_port = 0
        conn_type = None
        self.connector = Connector(diagram, source, source_port, conn_type)

    # ----------------------------------------------------------------------x
    def test_delete(self):
        self.assertIsNone(self.connector.delete())

    # ----------------------------------------------------------------------x
    def test_update_tracking(self):
        newEnd = None
        self.assertIsNone(self.connector.update_tracking(newEnd))
        newEnd = [0, 0]
        self.assertIsNone(self.connector.update_tracking(newEnd))
        newEnd = [1, 1]
        self.assertIsNone(self.connector.update_tracking(newEnd))
        newEnd = [2, 1]
        self.assertIsNone(self.connector.update_tracking(newEnd))
        newEnd = [1, 2]
        self.assertIsNone(self.connector.update_tracking(newEnd))
        newEnd = [2, 2]
        self.assertIsNone(self.connector.update_tracking(newEnd))
        newEnd = [70, 70]
        self.assertIsNone(self.connector.update_tracking(newEnd))
        newEnd = [190, 70]
        self.assertIsNone(self.connector.update_tracking(newEnd))


    # ----------------------------------------------------------------------x
    def test_update_flow(self):
        # NOTE: NAO TRATA NONE. SE INICIALIZAR CONNECTOR,
        # QUE INICIALIZARA CONNECTORMODEL, O ATRIBUTO
        # SINK SERA NONE. E, COM ISSO, RESULTARA EM
        # ERRO. E SINK E DO TIPO BLOCK, ALGO DIFICIL
        # DE SER INICIALIZADO POR MEIO DE TESTE.
        self.assertIsNone(self.connector.update_flow())
Beispiel #4
0
    def start_connection(self, block, port):
        """
        This method start a connection.

            Parameters:
                * **block**
                * **output**

        """
        self.__abort_connection()  # abort any possibly running connections
        self.curr_connector = Connector(self, block, port)
        self.get_root_item().add_child(self.curr_connector, -1)
        self.update_flows()
Beispiel #5
0
    def test_delete_connection(self):

        from mosaicode.GUI.connector import Connector

        blockmodel = BlockModel()

        source = Block(self.diagram, blockmodel)
        # NOTE: NAO TRATA None
        # source = None

        source_port = 0
        conn_type = None
        connection = Connector(self.diagram, source, source_port, conn_type)

        self.assertIsNone(self.diagram.delete_connection(connection))
class TestConnector(TestBase):
    def setUp(self):
        port = Port()
        self.source_block = self.create_block()
        self.source_block.ports.append(port)
        self.source_block = Block(self.create_diagram(), self.create_block())
        self.diagram = self.create_diagram()
        self.connector = Connector(self.diagram, self.source_block, port)

    def test_update_flow(self):
        self.connector.input = None
        self.connector.update_flow()
        point = (0, 0)
        self.connector.update_flow(point)
        self.connector.input = Block(self.create_diagram(),
                                     self.create_block())
        self.connector.input.move(100, 100)
        self.connector.input_port = Port()
        System.get_preferences().connection = "Curve"
        self.connector.update_flow()
        System.get_preferences().connection = "Line"
        self.connector.update_flow()
        System.get_preferences().connection = "Square"
        self.connector.update_flow()

    def test_events(self):
        gdkevent = Gdk.Event()
        gdkevent.key.type = Gdk.EventType.MOTION_NOTIFY

        self.connector.emit("enter-notify-event", self.connector, gdkevent)
        self.refresh_gui()
        self.connector.is_selected = True
        self.connector.emit("leave-notify-event", self.connector, gdkevent)
        self.refresh_gui()

        self.connector.is_selected = False
        gdkevent.key.type = Gdk.EventType.DOUBLE_BUTTON_PRESS
        self.connector.emit("button-press-event", self.connector, gdkevent)
        self.refresh_gui()
        gdkevent.button = 3
        self.connector.emit("button-press-event", self.connector, gdkevent)
        self.refresh_gui()
        self.connector.is_selected = True
        self.connector.emit("button-press-event", self.connector, gdkevent)
        self.refresh_gui()
Beispiel #7
0
    def redraw(self):
        """
        This method redraw the diagram.
        """
        # First, remove all items from the diagram
        while self.get_root_item().get_n_children() != 0:
            self.get_root_item().remove_child(0)
        self.__draw_grid()

        # Check diagram content
        # Create Block widgets
        for key in self.blocks:
            block = self.blocks[key]
            if not isinstance(block, Block):
                block = Block(self, self.blocks[key])
                self.blocks[key] = block

        # Create Connection Widgets
        i = 0
        to_remove = []

        for connector in self.connectors:

            # If it is not an instance of a connector, it is a connection model
            # Probably it it the first time we draw this diagram
            if not isinstance(connector, Connector):
                outb = self.blocks[connector.output.id]
                conn = Connector(self, outb, connector.output_port)
                conn.input = self.blocks[connector.input.id]
                conn.input_port = connector.input_port
                connector = conn
                self.connectors[i] = conn

            if connector.output:
                if  connector.output.id not in self.blocks or \
                        connector.input.id not in self.blocks:
                    to_remove.append(connector)
            i = i + 1
        for conn in to_remove:
            self.connectors.remove(conn)

        # Create Comment Widgets
        i = 0
        for comment in self.comments:
            if not isinstance(comment, Comment):
                comm = Comment(self)
                comm.move(comment.x, comment.y)
                comm.update_flow()
                self.comments[i] = comm
            i = i + 1

        # Redraw Blocks
        for key in self.blocks:
            block = self.blocks[key]
            if not isinstance(block, Block):
                block = Block(self, self.blocks[key])
                self.blocks[key] = block
            self.get_root_item().add_child(block, -1)
            block.adjust_position()
        i = 0

        # Redraw Connections
        for connector in self.connectors:
            if not isinstance(connector, Connector) and connector.output:
                outb = self.blocks[connector.output.id]
                conn = Connector(self, outb, connector.output_port)
                conn.input = self.blocks[connector.input.id]
                conn.input_port = connector.input_port
                connector = conn
                self.connectors[i] = conn
            if isinstance(connector, GooCanvas.CanvasItem):
                self.get_root_item().add_child(connector, -1)
            i = i + 1

        # Redraw Comments
        for comment in self.comments:
            self.get_root_item().add_child(comment, -1)
            comment.adjust_position()

        self.update_flows()