/* @(#)PaintableSequenceComposite.java   2.4.0   25 May 2005
 *
 * Copyright 2005
 * College of Computer and Information Science
 * Northeastern University
 * Boston, MA  02115
 *
 * The Java Power Tools software may be used for educational
 * purposes as long as this copyright notice is retained intact
 * at the top of all source files.
 *
 * To discuss possible commercial use of this software, 
 * contact Richard Rasala at Northeastern University, 
 * College of Computer and Information Science,
 * 617-373-2462 or rasala@ccs.neu.edu.
 *
 * The Java Power Tools software has been designed and built
 * in collaboration with Viera Proulx and Jeff Raab.
 *
 * Should this software be modified, the words "Modified from 
 * Original" must be included as a comment below this notice.
 *
 * All publication rights are retained.  This software or its 
 * documentation may not be published in any media either
 * in whole or in part without explicit permission.
 *
 * This software was created with support from Northeastern 
 * University and from NSF grant DUE-9950829.
 */

package edu.neu.ccs.gui;

import edu.neu.ccs.*;
import edu.neu.ccs.util.*;

import java.awt.*;
import java.awt.geom.*;
import javax.swing.*;
import java.beans.*;

/**
 * <p>The class <code>PaintableSequenceComposite</code> is a base
 * class for the construction of <code>Paintable</code> classes.
 * Although the class is not abstract, nothing useful can be done
 * with it directly.</p>
 *
 * <p>A derived class can control exactly what is inserted into the
 * internal <code>PaintableSequence</code> via the protected access
 * method <code>getPaintableSequence()</code> but this sequence is
 * not visible to a public caller.  Thus, all features of a
 * <code>PaintableSequence</code> are available to a derived class
 * without public exposure of this implementation.</p>
 *
 * <p>Aside from the protected access method
 * <code>getPaintableSequence()</code>,
 * all methods simply implement the two interfaces
 * <code>Paintable()</code> and <code>SupportsPropertyChange()</code>
 * and do this by delegation to the internal paintable sequence.</p>
 *
 * <p>In 2.3.5, the class was refactored to be consistent with
 * the new <code>Paintable</code> interface and
 * the new <code>AbstractPaintable</code> class.
 *
 * <p>In 2.4.0, this class was updated to be consistent with
 * refinements to the <code>Paintable</code> interface.</p>
 *
 * @author  Richard Rasala
 * @version 2.4.0
 * @since   2.3.2
 */
public class PaintableSequenceComposite
    implements Paintable, SupportsPropertyChange, JPTConstants
{
    /** The internal paintable sequence. */
    private PaintableSequence sequence = new PaintableSequence();
    
    
    /**
     * <p>Returns the internal paintable sequence.</p>
     *
     * @return the internal paintable sequence
     */
    protected PaintableSequence getPaintableSequence() {
        return sequence;
    }
    
    
    /* Delegate Paintable interface calls to the internal sequence. */
    
    
    public void paint(Graphics g) {
        sequence.paint(g);
    }
    
    public void paintAt(Graphics g, double x, double y) {
        sequence.paintAt(g, x, y);
    }
    
    public void paintAt(Graphics g, Point2D p) {
        sequence.paintAt(g, p);
    }
    
    public void paintAt(Graphics g, AffineTransform T, double x, double y) {
        sequence.paintAt(g, T, x, y);
    }
    
    public void paintAt(Graphics g, AffineTransform T, Point2D p) {
        sequence.paintAt(g, T, p);
    }
    
    public XRect getBounds2D() {
        return sequence.getBounds2D();
    }
    
    public XPoint2D getCenter() {
        return sequence.getCenter();
    }
    
    public XPoint2D getCorner() {
        return sequence.getCorner();
    }
    
    public void setDefaultBounds2D(Rectangle2D rectangle) {
        sequence.setDefaultBounds2D(rectangle);
    }
    
    public XRect getDefaultBounds2D() {
        return sequence.getDefaultBounds2D();
    }
    
    public void setDefaultCenter(Point2D center) {
        sequence.setDefaultCenter(center);
    }
    
    public XPoint2D getDefaultCenter() {
        return sequence.getDefaultCenter();
    }
    
    public boolean contains(double x, double y) {
        return sequence.contains(x, y);
    }
    
    public boolean contains(Point2D p) {
         return sequence.contains(p);
    }
    
    public void originalPaint(Graphics g) {
        sequence.originalPaint(g);
    }
    
    public XRect getOriginalBounds2D() {
         return sequence.getOriginalBounds2D();
    }
    
    public XRect getActualBounds2D() {
         return sequence.getActualBounds2D();
    }
    
    public XPoint2D getOriginalCenter() {
         return sequence.getOriginalCenter();
    }
    
    public void setDefaultOriginalBounds2D(Rectangle2D rectangle) {
        sequence.setDefaultOriginalBounds2D(rectangle);
    }
    
    public XRect getDefaultOriginalBounds2D() {
        return sequence.getDefaultOriginalBounds2D();
    }
    
    public void setDefaultOriginalCenter(Point2D center) {
        sequence.setDefaultOriginalCenter(center);
    }
    
    public XPoint2D getDefaultOriginalCenter() {
        return sequence.getDefaultOriginalCenter();
    }
    
    public boolean originalContains(double x, double y) {
        return sequence.originalContains(x, y);
    }
    
    public boolean originalContains(Point2D p) {
         return sequence.originalContains(p);
    }
    
    public void setVisible(boolean visible) {
        sequence.setVisible(visible);
    }
    
    public boolean isVisible() {
        return sequence.isVisible();
    }
    
    public void setOpacity(float opacity) {
        sequence.setOpacity(opacity);
    }
    
    public float getOpacity() {
        return sequence.getOpacity();
    }
    
    public void applyOpacity(Graphics2D h) {
        sequence.applyOpacity(h);
    }
    
    public Graphics2D getPreparedGraphics2D(Graphics g) {
        return sequence.getPreparedGraphics2D(g);
    }
    
    public void setMutator(AffineTransform M) {
        sequence.setMutator(M);
    }
    
    public void setMutator(Mutator.Strategy strategy) {
        sequence.setMutator(strategy);
    }
    
    public void addPreMutation(AffineTransform M) {
        sequence.addPreMutation(M);
    }
    
    public void addPreMutation(Mutator.Strategy strategy) {
        sequence.addPreMutation(strategy);
    }
    
    public void addPostMutation(AffineTransform M) {
        sequence.addPostMutation(M);
    }
    
    public void addPostMutation(Mutator.Strategy strategy) {
        sequence.addPostMutation(strategy);
    }
    
    public AffineTransform getMutator() {
        return sequence.getMutator();
    }
    
    public AffineTransform getMutatorInverse() {
        return sequence.getMutatorInverse();
    }
    
    public void mutate(AffineTransform M) {
        sequence.mutate(M);
    }
    
    public void mutate(Mutator.Strategy strategy) {
        sequence.mutate(strategy);
    }
    
    public void move(double x, double y) {
        sequence.move(x, y);
    }
    
    public void move(Point2D p) {
        sequence.move(p);
    }
    
    public void moveCenterTo(double x, double y) {
        sequence.moveCenterTo(x, y);
    }
    
    public void moveCenterTo(Point2D p) {
        sequence.moveCenterTo(p);
    }
    
    public void moveCornerTo(double x, double y) {
        sequence.moveCornerTo(x, y);
    }
    
    public void moveCornerTo(Point2D p) {
        sequence.moveCornerTo(p);
    }
    
    public void rotate(double degrees) {
        sequence.rotate(degrees);
    }
    
    public void reflect(double degrees) {
        sequence.reflect(degrees);
    }
    
    public void hreflect() {
        sequence.hreflect();
    }
    
    public void vreflect() {
        sequence.vreflect();
    }
    
    public void scale(double s) {
        sequence.scale(s);
    }
    
    public void scale(double degrees, double s, double t) {
        sequence.scale(degrees, s, t);
    }
    
    public void shear(double degrees, double s) {
        sequence.shear(degrees, s);
    }
    
    public void glide(double degrees, double distance) {
        sequence.glide(degrees, distance);
    }
    
    public void glidereflect(double degrees, double distance) {
        sequence.glidereflect(degrees, distance);
    }
    
    public void lineartransform
        (double m00, double m10, double m01, double m11)
    {
        sequence.lineartransform(m00, m10, m01, m11);
    }
    
    public void affinetransform
        (double m00, double m10, double m01, double m11, double m02, double m12)
    {
        sequence.affinetransform(m00, m10, m01, m11, m02, m12);
    }
    
    /* Delegate SupportsPropertyChange interface calls to the internal sequence. */
    
    public void addPropertyChangeListener(PropertyChangeListener listener) {
        sequence.addPropertyChangeListener(listener);
    }
    
    public void addPropertyChangeListener(
        String propertyName,
        PropertyChangeListener listener)
    {
        sequence.addPropertyChangeListener(propertyName, listener);
    }
    
    public void addPropertyChangeListeners(PropertyChangeListener[] listeners)
    {
        sequence.addPropertyChangeListeners(listeners);
    }
    
    public void addPropertyChangeListeners(
        String propertyName,
        PropertyChangeListener[] listeners)
    {
        sequence.addPropertyChangeListeners(propertyName, listeners);
    }
    
    public void removePropertyChangeListener(PropertyChangeListener listener)
    {
        sequence.removePropertyChangeListener(listener);
    }
    
    public void removePropertyChangeListener(
        String propertyName,
        PropertyChangeListener listener)
    {
        sequence.removePropertyChangeListener(propertyName, listener);
    }
    
    public PropertyChangeListener[] getPropertyChangeListeners()
    {
        return sequence.getPropertyChangeListeners();
    }
    
    public PropertyChangeListener[] getPropertyChangeListeners(String propertyName)
    {
        return sequence.getPropertyChangeListeners(propertyName);
    }
    
    public boolean hasListeners(String propertyName)
    {
        return sequence.hasListeners(propertyName);
    }
    
    public void firePropertyChange(
        String propertyName,
        Object oldValue,
        Object newValue)
    {
        sequence.firePropertyChange(propertyName, oldValue, newValue);
    }
    
    public void firePropertyChange(
        String propertyName,
        boolean oldValue,
        boolean newValue)
    {
        sequence.firePropertyChange(propertyName, oldValue, newValue);
    }
    
    public void firePropertyChange(
        String propertyName,
        char oldValue,
        char newValue)
    {
        sequence.firePropertyChange(propertyName, oldValue, newValue);
    }
    
    public void firePropertyChange(
        String propertyName,
        byte oldValue,
        byte newValue)
    {
        sequence.firePropertyChange(propertyName, oldValue, newValue);
    }
    
    public void firePropertyChange(
        String propertyName,
        short oldValue,
        short newValue)
    {
        sequence.firePropertyChange(propertyName, oldValue, newValue);
    }
    
    public void firePropertyChange(
        String propertyName,
        int oldValue,
        int newValue)
    {
        sequence.firePropertyChange(propertyName, oldValue, newValue);
    }
    
    public void firePropertyChange(
        String propertyName,
        long oldValue,
        long newValue)
    {
        sequence.firePropertyChange(propertyName, oldValue, newValue);
    }
    
    public void firePropertyChange(
        String propertyName,
        float oldValue,
        float newValue)
    {
        sequence.firePropertyChange(propertyName, oldValue, newValue);
    }
    
    public void firePropertyChange(
        String propertyName,
        double oldValue,
        double newValue)
    {
        sequence.firePropertyChange(propertyName, oldValue, newValue);
    }
    
    public void firePropertyChange(PropertyChangeEvent evt)
    {
        sequence.firePropertyChange(evt);
    }
    
    public PropertyChangeForwardingListener getForwardingListener()
    {
        return sequence.getForwardingListener();
    }
    
    public void addForwardingListener(Object object)
    {
        sequence.addForwardingListener(object);
    }
    
    public void removeForwardingListener(Object object)
    {
        sequence.removeForwardingListener(object);
    }
    
    public void removeAndAddForwardingListener(Object oldobject, Object newobject)
    {
        sequence.removeAndAddForwardingListener(oldobject, newobject);
    }
       
}