import java.applet.Applet;
import java.awt.*;
import java.util.Vector;

/**  class SequenceDiagram
 *   creates a sequence of diagrams using the sequential layout manager
 *   1, 2, 3, 4, or an array of diagrams can be used
 *   There are 5 additional constructors that allow the direction of the
 *   flow of the diagram to be designated by the first parameter which
 *   indicates if the diagram is to be reversed
 */
public class SequenceDiagram extends Diagram{

    // There are 10 constructors for this class.  5 are the constructors
    // for 1, 2, 3, 4 diagrams or an array of diagrams.  The additional
    // 5 constructors repeat the code for these but add an extra parameter
    // to indicate that the diagram should be reversed (for sequences
    // embedded in loops).  It was decided during design that the few
    // times this happens does not warrant requiring the direction of flow
    // for every sequence.  The builder of the diagrams needs to be
    // aware of this feature.
    //
    // Each constructor adds a simple connector to the beginning and
    // the end of the completed diagram.
    // The inner diagrams are added with connectors between each pair
    //
    // The constructors with an extra parameter check the direction of
    // flow and add the inner diagrams in the appropriate order
    //
    //1 in sequence
    public SequenceDiagram(Diagram diagram1) {
        setLayout (new SequentialLayout());
        Dimension dim = diagram1.preferredSize();
        Diagram connect1 = new Connector (connectorSize);
        Diagram connect2 = new Connector (connectorSize);
        add (connect1);
        add (diagram1);
        add (connect2);
        connectorLocation = diagram1.connectorLocation;
    }

    //2 in sequence
    public SequenceDiagram(Diagram diagram1,
                        Diagram diagram2) {

        setLayout (new SequentialLayout());
        Diagram connect1 = new Connector (connectorSize);
        Diagram connect2 = new Connector (connectorSize);
        Diagram connect3 = new Connector (connectorSize);
        add (connect1);
        add (diagram1);
        add (connect2);
        add (diagram2);
        add (connect3);
         connectorLocation = Math.max(diagram1.connectorLocation,
                                    diagram2.connectorLocation);
    }

    //3 in sequence
    public SequenceDiagram(Diagram diagram1,
                           Diagram diagram2,
                           Diagram diagram3) {
        setLayout (new SequentialLayout());
        Diagram connect1 = new Connector (connectorSize);
        Diagram connect2 = new Connector (connectorSize);
        Diagram connect3 = new Connector (connectorSize);
        Diagram connect4 = new Connector (connectorSize);
        add (connect1);
        add (diagram1);
        add (connect2);
        add (diagram2);
        add (connect3);
        add (diagram3);
        add (connect4);
         connectorLocation = Math.max(diagram1.connectorLocation,
                            Math.max(diagram2.connectorLocation,
                                    diagram3.connectorLocation));
    }

    //4 in sequence
    public SequenceDiagram(Diagram diagram1,
                        Diagram diagram2,
                        Diagram diagram3,
                        Diagram diagram4) {
        setLayout (new SequentialLayout());
        Diagram connect1 = new Connector (connectorSize);
        Diagram connect2 = new Connector (connectorSize);
        Diagram connect3 = new Connector (connectorSize);
        Diagram connect4 = new Connector (connectorSize);
        Diagram connect5 = new Connector (connectorSize);
        add (connect1);
        add (diagram1);
        add (connect2);
        add (diagram2);
        add (connect3);
        add (diagram3);
        add (connect4);
        add (diagram4);
        add (connect5);
         connectorLocation = Math.max(diagram1.connectorLocation,
                            Math.max(diagram2.connectorLocation,
                            Math.max(diagram3.connectorLocation,
                                    diagram4.connectorLocation)));
    }

    //an array of diagrams in sequence
    public SequenceDiagram(Diagram diagram[], int size) {

        initFromArray(diagram, size);
    }

    //a Vector of diagrams in sequence
    public SequenceDiagram(Vector vect) {

	int size = vect.size();
	Diagram[] diag = new Diagram[size];
	vect.copyInto((Object[])diag);

	if (size > 0) {
            initFromArray(diag, size);
	} else {
	    System.out.println("Error instantiating SequenceDiagram");
	    System.out.println("    Diagram vector parameter is empty");
	}
    }

    //1 in sequence
    public SequenceDiagram(boolean reversed,
                            Diagram diagram1) {

        setLayout (new SequentialLayout());
        Dimension dim = diagram1.preferredSize();
        Diagram connect1 = new Connector (connectorSize);
        Diagram connect2 = new Connector (connectorSize);
        add (connect1);
        add (diagram1);
        add (connect2);
        connectorLocation = diagram1.connectorLocation;
    }

    //2 in sequence
    public SequenceDiagram(boolean reversed,
                        Diagram diagram1,
                        Diagram diagram2) {

        setLayout (new SequentialLayout());
        Diagram connect1 = new Connector (connectorSize);
        Diagram connect2 = new Connector (connectorSize);
        Diagram connect3 = new Connector (connectorSize);
        add (connect1);
        if (!reversed){
            add (diagram1);
            add (connect2);
            add (diagram2);
        }
        else{
            add (diagram2);
            add (connect2);
            add (diagram1);
        }
        add (connect3);
         connectorLocation = Math.max(diagram1.connectorLocation,
                                    diagram2.connectorLocation);
    }

    //3 in sequence
    public SequenceDiagram(boolean reversed,
                           Diagram diagram1,
                           Diagram diagram2,
                           Diagram diagram3) {

        setLayout (new SequentialLayout());
        Diagram connect1 = new Connector (connectorSize);
        Diagram connect2 = new Connector (connectorSize);
        Diagram connect3 = new Connector (connectorSize);
        Diagram connect4 = new Connector (connectorSize);
        add (connect1);
        if (!reversed){
            add (diagram1);
            add (connect2);
            add (diagram2);
            add (connect3);
            add (diagram3);
        }
        else{
            add (diagram3);
            add    (connect3);
            add (diagram2);
            add (connect2);
            add (diagram1);
        }
        add (connect4);
         connectorLocation = Math.max(diagram1.connectorLocation,
                            Math.max(diagram2.connectorLocation,
                                    diagram3.connectorLocation));
    }

    //4 in sequence
    public SequenceDiagram(boolean reversed,
                        Diagram diagram1,
                        Diagram diagram2,
                        Diagram diagram3,
                        Diagram diagram4) {

        setLayout (new SequentialLayout());
        Diagram connect1 = new Connector (connectorSize);
        Diagram connect2 = new Connector (connectorSize);
        Diagram connect3 = new Connector (connectorSize);
        Diagram connect4 = new Connector (connectorSize);
        Diagram connect5 = new Connector (connectorSize);
        add (connect1);
        if (!reversed){
            add (diagram1);
            add (connect2);
            add (diagram2);
            add (connect3);
            add (diagram3);
            add (connect4);
            add (diagram4);
        }
        else{
            add (diagram4);
            add (connect4);
            add (diagram3);
            add    (connect3);
            add (diagram2);
            add (connect2);
            add (diagram1);
        }
        add (connect5);
         connectorLocation = Math.max(diagram1.connectorLocation,
                            Math.max(diagram2.connectorLocation,
                            Math.max(diagram3.connectorLocation,
                                    diagram4.connectorLocation)));
    }

    //an array of diagrams in sequence
    public SequenceDiagram(boolean reversed,
                           Diagram diagram[], int size) {

	initFromArray(reversed, diagram, size);
    }

    //a Vector of diagrams in sequence
    public SequenceDiagram(boolean reversed, Vector vect) {

	int size = vect.size();
	Diagram[] diag = new Diagram[size];
	vect.copyInto((Object[])diag);

	if (size > 0) {
            initFromArray(reversed, diag, size);
	} else {
	    System.out.println("Error instantiating SequenceDiagram");
	    System.out.println("    Diagram vector parameter is empty");
	}
    }

    //initialize the sequence from an array of Diagrams
    private void initFromArray(Diagram diagram[], int size) {

        Dimension dim = diagram[0].preferredSize();
        Diagram connect = new Connector (connectorSize);
        setLayout (new SequentialLayout());

        connectorLocation = 0;
        add (connect);
        for (int i = 0; i < size; i++){
            add (diagram[i]);
            connect = new Connector (connectorSize);
            add (connect);
            connectorLocation = Math.max(connectorLocation,
                                         diagram[i].connectorLocation);
        }
    }

    //initialize the sequence from an array of Diagrams
    private void initFromArray(boolean reversed,
			       Diagram diagram[], int size) {

        Dimension dim = diagram[0].preferredSize();
        Diagram connect = new Connector (connectorSize);
        setLayout (new SequentialLayout());

        connectorLocation = 0;
        add (connect);
        if (!reversed){
            for (int i = size - 1; i <= 0; i--){
                add (diagram[i]);
                connect = new Connector (connectorSize);
                add (connect);
                connectorLocation = Math.max(connectorLocation,
                                diagram[i].connectorLocation);
            }
        }
        else{
            for (int i = 0; i < size; i++){
                add (diagram[i]);
                connect = new Connector (connectorSize);
                add (connect);
                connectorLocation = Math.max(connectorLocation,
                                diagram[i].connectorLocation);
            }
        }
    }

}
