public ParameterBlock() 
{

}

A dummy constructor.

 public ParameterBlock(Vector sources) 
{
        setSources(sources);
}

Constructs a ParameterBlock with a given Vector of sources.

Parameters:

sources - a Vector of source images

 public ParameterBlock(Vector sources,
    Vector parameters) 
{
        setSources(sources);
        setParameters(parameters);
}

Constructs a ParameterBlock with a given Vector of sources and Vector of parameters.

Parameters:

sources - a Vector of source images

parameters - a Vector of parameters to be used in the rendering operation

 public ParameterBlock add(Object obj) 
{
        parameters.addElement(obj);
        return this;
}

Adds an object to the list of parameters.

 public ParameterBlock add(byte b) 
{
        return add(new Byte(b));
}

Adds a Byte to the list of parameters.

 public ParameterBlock add(char c) 
{
        return add(new Character(c));
}

Adds a Character to the list of parameters.

 public ParameterBlock add(short s) 
{
        return add(new Short(s));
}

Adds a Short to the list of parameters.

 public ParameterBlock add(int i) 
{
        return add(new Integer(i));
}

Adds a Integer to the list of parameters.

 public ParameterBlock add(long l) 
{
        return add(new Long(l));
}

Adds a Long to the list of parameters.

 public ParameterBlock add(float f) 
{
        return add(new Float(f));
}

Adds a Float to the list of parameters.

 public ParameterBlock add(double d) 
{
        return add(new Double(d));
}

Adds a Double to the list of parameters.

 public ParameterBlock addSource(Object source) 
{
        sources.addElement(source);
        return this;
}

Adds an image to end of the list of sources. The image is stored as an object in order to allow new node types in the future.

 public Object clone() 
{
        ParameterBlock theClone;
        try {
            theClone = (ParameterBlock) super.clone();
        } catch (Exception e) {
            // We can't be here since we implement Cloneable.
            return null;
        }
        if (sources != null) {
            theClone.setSources((Vector)sources.clone());
        }
        if (parameters != null) {
            theClone.setParameters((Vector)parameters.clone());
        }
        return (Object) theClone;
}

Creates a copy of a ParameterBlock. The source and parameter Vectors are cloned, but the actual sources and parameters are copied by reference. This allows modifications to the order and number of sources and parameters in the clone to be invisible to the original ParameterBlock. Changes to the shared sources or parameters themselves will still be visible.

 public byte getByteParameter(int index) 
{
        return ((Byte)parameters.elementAt(index)).byteValue();
}

A convenience method to return a parameter as a byte. An exception is thrown if the parameter is null or not a Byte.

 public char getCharParameter(int index) 
{
        return ((Character)parameters.elementAt(index)).charValue();
}

A convenience method to return a parameter as a char. An exception is thrown if the parameter is null or not a Character.

 public double getDoubleParameter(int index) 
{
        return ((Double)parameters.elementAt(index)).doubleValue();
}

A convenience method to return a parameter as a double. An exception is thrown if the parameter is null or not a Double.

 public float getFloatParameter(int index) 
{
        return ((Float)parameters.elementAt(index)).floatValue();
}

A convenience method to return a parameter as a float. An exception is thrown if the parameter is null or not a Float.

 public int getIntParameter(int index) 
{
        return ((Integer)parameters.elementAt(index)).intValue();
}

A convenience method to return a parameter as an int. An exception is thrown if the parameter is null or not an Integer.

 public long getLongParameter(int index) 
{
        return ((Long)parameters.elementAt(index)).longValue();
}

A convenience method to return a parameter as a long. An exception is thrown if the parameter is null or not a Long.

 public int getNumParameters() 
{
        return parameters.size();
}

Returns the number of parameters (not including source images).

 public int getNumSources() 
{
        return sources.size();
}

Returns the number of source images.

 public Object getObjectParameter(int index) 
{
        return parameters.elementAt(index);
}

Gets a parameter as an object.

 public Class[] getParamClasses() 
{
        int numParams = getNumParameters();
        Class [] classes = new Class[numParams];
        int i;
        for (i = 0; i <  numParams; i++) {
            Object obj = getObjectParameter(i);
            if (obj instanceof Byte) {
              classes[i] = byte.class;
            } else if (obj instanceof Character) {
              classes[i] = char.class;
            } else if (obj instanceof Short) {
              classes[i] = short.class;
            } else if (obj instanceof Integer) {
              classes[i] = int.class;
            } else if (obj instanceof Long) {
              classes[i] = long.class;
            } else if (obj instanceof Float) {
              classes[i] = float.class;
            } else if (obj instanceof Double) {
              classes[i] = double.class;
            } else {
              classes[i] = obj.getClass();
            }
        }
        return classes;
}

Returns an array of Class objects describing the types of the parameters.

 public Vector getParameters() 
{
        return parameters;
}

Returns the entire Vector of parameters.

 public RenderableImage getRenderableSource(int index) 
{
        return (RenderableImage) sources.elementAt(index);
}

Returns a source as a RenderableImage. This method is a convenience method. An exception will be thrown if the sources is not a RenderableImage.

 public RenderedImage getRenderedSource(int index) 
{
        return (RenderedImage) sources.elementAt(index);
}

Returns a source as a RenderedImage. This method is a convenience method. An exception will be thrown if the source is not a RenderedImage.

 public short getShortParameter(int index) 
{
        return ((Short)parameters.elementAt(index)).shortValue();
}

A convenience method to return a parameter as a short. An exception is thrown if the parameter is null or not a Short.

 public Object getSource(int index) 
{
        return sources.elementAt(index);
}

Returns a source as a general Object. The caller must cast it into an appropriate type.

 public Vector getSources() 
{
        return sources;
}

Returns the entire Vector of sources.

 public  void removeParameters() 
{
        parameters = new Vector();
}

Clears the list of parameters.

 public  void removeSources() 
{
        sources = new Vector();
}

Clears the list of source images.

 public ParameterBlock set(Object obj,
    int index) 
{
        int oldSize = parameters.size();
        int newSize = index + 1;
        if (oldSize <  newSize) {
            parameters.setSize(newSize);
        }
        parameters.setElementAt(obj, index);
        return this;
}

Replaces an Object in the list of parameters. If the index lies beyond the current source list, the list is extended with nulls as needed.

 public ParameterBlock set(byte b,
    int index) 
{
        return set(new Byte(b), index);
}

Replaces an Object in the list of parameters with a Byte. If the index lies beyond the current source list, the list is extended with nulls as needed.

 public ParameterBlock set(char c,
    int index) 
{
        return set(new Character(c), index);
}

Replaces an Object in the list of parameters with a Character. If the index lies beyond the current source list, the list is extended with nulls as needed.

 public ParameterBlock set(short s,
    int index) 
{
        return set(new Short(s), index);
}

Replaces an Object in the list of parameters with a Short. If the index lies beyond the current source list, the list is extended with nulls as needed.

 public ParameterBlock set(int i,
    int index) 
{
        return set(new Integer(i), index);
}

Replaces an Object in the list of parameters with an Integer. If the index lies beyond the current source list, the list is extended with nulls as needed.

 public ParameterBlock set(long l,
    int index) 
{
        return set(new Long(l), index);
}

Replaces an Object in the list of parameters with a Long. If the index lies beyond the current source list, the list is extended with nulls as needed.

 public ParameterBlock set(float f,
    int index) 
{
        return set(new Float(f), index);
}

Replaces an Object in the list of parameters with a Float. If the index lies beyond the current source list, the list is extended with nulls as needed.

 public ParameterBlock set(double d,
    int index) 
{
        return set(new Double(d), index);
}

Replaces an Object in the list of parameters with a Double. If the index lies beyond the current source list, the list is extended with nulls as needed.

 public  void setParameters(Vector parameters) 
{
        this.parameters = parameters;
}

Sets the entire Vector of parameters to a given Vector.

 public ParameterBlock setSource(Object source,
    int index) 
{
        int oldSize = sources.size();
        int newSize = index + 1;
        if (oldSize <  newSize) {
            sources.setSize(newSize);
        }
        sources.setElementAt(source, index);
        return this;
}

Replaces an entry in the list of source with a new source. If the index lies beyond the current source list, the list is extended with nulls as needed.

 public  void setSources(Vector sources) 
{
        this.sources = sources;
}

Sets the entire Vector of sources to a given Vector.

 public Object shallowClone() 
{
        try {
            return super.clone();
        } catch (Exception e) {
            // We can't be here since we implement Cloneable.
            return null;
        }
}

Creates a shallow copy of a ParameterBlock. The source and parameter Vectors are copied by reference -- additions or changes will be visible to both versions.