---

Line.java

Go to the documentation of this file.

/* Cyclops
 * FER - SPVP
 * Fakultet elektrotehnike i racunarstva (http://www.fer.hr/)
 * Unska 3, 10000 Zagreb, Hrvatska
 * (c) 2001 FER, Zagreb.
 */

package hr.fer.zesoi.cyclops;

import java.util.*;
import java.awt.*;


public class Line
{

    protected boolean show_capacity = true;

    protected boolean deleted = false;

    public LineEnd left_end;

    public LineEnd right_end;

    protected Node left_node;

    protected Node right_node;

    protected int left_capacity;

    protected int right_capacity;

    public Line (Node left, Node right, int capacity)
    {
        left_end = new LineEnd(this);
        right_end = new LineEnd(this);
        left_node = left;
        right_node = right;
        left_node.attach(left_end, right_node);
        right_node.attach(right_end, left_node);
        left_capacity = capacity;
        right_capacity = capacity;
        left_end.setCapacity(left_capacity);
        right_end.setCapacity(right_capacity);
    }
    /* Line */

    public Line (Node left, Node right, int leftCapacity, int rightCapacity)
    {
        left_end = new LineEnd(this);
        right_end = new LineEnd(this);
        left_node = left;
        right_node = right;
        left_end.setCapacity(left_capacity);
        right_end.setCapacity(right_capacity);
        left_node.attach(left_end, right_node);
        right_node.attach(right_end, left_node);
        this.left_capacity = left_capacity;
        this.right_capacity = right_capacity;
    }
    /* Line */

    public void transmitAll ()
    {
        Object packet;
        while ( !left_end.isEmpty() )
            {
                packet = left_end.get();
                right_node.receive(packet);
            }
        while ( !right_end.isEmpty() )
            {
                packet = right_end.get();
                left_node.receive(packet);
            }
    }
    /* transmitAll */

    public int getCapacity ()
    {
        if (left_capacity < right_capacity)
            {
                return left_capacity;
            }
        else
            {
                return right_capacity;
            }
    }
    /* getCapacity */

    public int getLeftToRightCapacity ()
    {
        return left_capacity;
    }
    /* getLeftToRightCapacity */


    public int getRightToLeftCapacity ()
    {
        return right_capacity;
    }
    /* getRightToLeftCapacity */


    public void setCapacity (int capacity)
    {
        left_capacity = capacity;
        right_capacity = capacity;
        left_end.setCapacity(left_capacity);
        right_end.setCapacity(right_capacity);
    }
    /* setCapacity */

    public void setLeftToRightCapacity (int capacity)
    {
        left_capacity = capacity;
        left_end.setCapacity(left_capacity);
    }
    /* setLeftToRightCapacity */

    public void setRightToLeftCapacity (int capacity)
    {
        right_capacity = capacity;
        right_end.setCapacity(right_capacity);
    }
    /* setRightToLeftCapacity */

    public void delete()
    {
        right_node.detach(right_end);
        left_node.detach(left_end);
        deleted = true;
    }
    /* delete */

    public boolean isDisconnected ()
    {
        return deleted;
    }
    /* isDisconnected */

    public boolean areEndingNodes(Node first_node, Node second_node)
    {
        if (left_node == first_node)
            {
                if (right_node == second_node)
                    {
                        return true;
                    }
            }
        else if (right_node == first_node)
            {
                if (left_node == second_node)
                    {
                        return true;
                    }
            }
        return false;
    }
    /* areEndingNodes */

    public void paint (Graphics g, FontMetrics metrics, Color line_color)
    {
        int x1;
        int y1;
        int x2;
        int y2;

        x1 = left_node.getXCoordinate();
        y1 = left_node.getYCoordinate();
        x2 = right_node.getXCoordinate();
        y2 = right_node.getYCoordinate();
        g.setColor(line_color);
        g.drawLine(x1, y1, x2, y2);
        if (show_capacity)
            {
                String capacity;
                if (left_capacity < right_capacity)
                    {
                        capacity = String.valueOf(left_capacity);
                    }
                else
                    {
                        capacity = String.valueOf(left_capacity);
                    }
                g.setColor(Color.black);
                g.drawString(capacity, x1 + (x2 - x1) / 2, y1 + (y2 - y1) / 2);
            }
    }
    /* paint */

    public void paint (Graphics g, FontMetrics metrics,
                       Color line_color, Color left_packet_color, Color right_packet_color,
                       Color traced_packet_color,
                       boolean show_line_capacity, boolean show_all_packets
                       )
    {
        int x1;
        int y1;
        int x2;
        int y2;
        int x;
        int y;
        int i;
        Packet packet;

        x1 = left_node.getXCoordinate();
        y1 = left_node.getYCoordinate();
        x2 = right_node.getXCoordinate();
        y2 = right_node.getYCoordinate();
        g.setColor(line_color);
        g.drawLine(x1, y1, x2, y2);
        x = x1 + (x2 - x1) / 2;
        y = y1 + (y2 - y1) / 2;
        if (show_line_capacity)
            {
                String capacity;
                if (left_capacity < right_capacity)
                    {
                        capacity = String.valueOf(left_capacity);
                    }
                else
                    {
                        capacity = String.valueOf(left_capacity);
                    }
                g.setColor(Color.black);
                g.drawString(capacity, x, y);
            }
        /* if */ /* show_line_capacity */
        boolean axis = Math.abs(y2 - y1) > Math.abs(x2 - x1);
        if (show_all_packets)
            {
                x = x1 + (x2 - x1) / 2;
                y = y1 + (y2 - y1) / 2;
                for (i=0; i<left_end.size(); i++)
                    {
                        if (axis) y = y + 6;
                        else x = x + 6;
                        packet = (Packet)left_end.elementAt(i);
                        if (packet.getDrawingFlag())
                            {
                                packet.paint(g, metrics, traced_packet_color, x, y);
                            }
                        else
                            {
                                packet.paint(g, metrics, left_packet_color, x, y);
                            }
                    }
                /* for */
                for (i=0; i<right_end.size(); i++)
                    {
                        if (axis) y = y + 6;
                        else x = x + 6;
                        packet = (Packet)right_end.elementAt(i);
                        if (packet.getDrawingFlag())
                            {
                                packet.paint(g, metrics, traced_packet_color, x, y);
                            }
                        else
                            {
                                packet.paint(g, metrics, right_packet_color, x, y);
                            }
                    }
                /* for */
            }
        else
            {
                x = x1 + (x2 - x1) / 2;
                y = y1 + (y2 - y1) / 2;
                for (i=0; i<left_end.size(); i++)
                    {
                        packet = (Packet)left_end.elementAt(i);
                        if (packet.getDrawingFlag())
                            {
                                if (axis) y = y + 6;
                                else x = x + 6;
                                packet.paint(g, metrics, traced_packet_color, x, y);
                            }
                    }
                /* for */
                for (i=0; i<right_end.size(); i++)
                    {
                        packet = (Packet)right_end.elementAt(i);
                        if (packet.getDrawingFlag())
                            {
                                if (axis) y = y + 6;
                                else x = x + 6;
                                packet.paint(g, metrics, traced_packet_color, x, y);
                            }
                    }
                /* for */
            }
        /* if else */ /* show_all_packets */
    }
    /* paint */

}
/* Line */

---