source: trunk/gsdl/src/java/org/nzdl/gsdl/GsdlCollageApplet/CollageImage.java@ 6816

package org.nzdl.gsdl.GsdlCollageApplet;

import java.awt.*;
import java.awt.geom.*;
import java.io.*;

/** 
 *  @author Katrina Edgar
 *  @author David Bainbridge
 *
 *  Data Structure to store an image once it is displayed in the applet.
 *  This structure remembers the images graphical representation, source url,
 *  name, width, height, position on the screen and whether or not it has
 *  previously been displayed. It provides methods to set the dimensions and
 *  position of the image. It also provides access methods to the translated
 *  x and y co-ordinates of the image */
public class CollageImage {

    /** Graphical representation of the image */
    Image image_        = null;
    /** Source url of the image */
    String from_url_    = null;
    /** Name of the image */
    String name_        = null;
    /** Width of the image */
    int image_x_dim_    = 0;
    /** Height of the image */
    int image_y_dim_    = 0;
    /** Indicates whether or not the image has been drawn on the applet previously */
    boolean fresh       = true;

    /** Reflects the translation of the image from the origin to its position on the screen */
    AffineTransform af_ = null;
    /** Left x co-ordinate */
    protected int xl_ = 0;
    /** Top y co-ordinate */
    protected int yt_ = 0;
    /** Right x co-ordinate */
    protected int xr_ = 0;
    /** Bottom y co-ordinate */
    protected int yb_ = 0;

    /** Constructs an CollageImage from the three specified parameters
     *
     *  @param image The graphical representation of the image
     *  @param from_url The source url for the image
     *  @param name The file name of the image */
    public CollageImage(Image image, String from_url, String name)
    {
    image_    = image;
    from_url_ = from_url;
    name_     = name;
    }

    /** Sets the width and height of the image
     *
     *  @param x_dim The new width of the image
     *  @param y_dim The new height of the image */
    public void setDimensions(int x_dim, int y_dim)
    {
    image_x_dim_ = x_dim;
    image_y_dim_ = y_dim;
    }

    /** Sets the translation for the image from the origin
     *  And regenerate the image as the scaled version
     *
     *  @param af The AffineTransform translation that has been calculated */
    public void setAffineTransform(MyAffineTransform af, boolean is_java2_)
    {   
    image_x_dim_ = (int) (image_x_dim_ * af.scaleX);
    image_y_dim_ = (int) (image_y_dim_ * af.scaleY);
    image_ = image_.getScaledInstance(image_x_dim_, image_y_dim_, Image.SCALE_DEFAULT);
    
    if (is_java2_) {
        af_ = new AffineTransform();
        af_.translate(af.translateX, af.translateY);
        af_.scale(1.0, 1.0);
    
        calculate_rect();
    }
    else {
        double trans_x = af.translateX;
        double trans_y = af.translateY;
        
        xl_ = Math.round((float)trans_x);
        xr_ = Math.round((float)(trans_x + image_x_dim_)) -1;
        yt_ = Math.round((float)trans_y);
        yb_ = Math.round((float)(trans_y + image_y_dim_)) -1; 
    }
    }

    public void expand () {
    
    // still expands a little too fast... how to fix this?
    magnify(new Rectangle((int) (xl_ + (image_x_dim_ * 0.000001)),
                  (int) (yt_ + (image_y_dim_ * 0.000001)),
                  (int) (image_x_dim_ * 0.999998),
                  (int) (image_y_dim_ * 0.999998)));
    
    }
    
    public void magnify(Rectangle border) {
    
    double magX = image_x_dim_/(double)border.width;
    double magY = image_y_dim_/(double)border.height;
    int x = border.x + border.width/2;
    int y = border.y + border.height/2;
    paintImage(x,y,magX, magY);
    }
    
    public void paintImage(int magCenterX, int magCenterY, double magX, double magY){
    
    try {
        //Point2D mgp = null;
        //mgp = af_.inverseTransform((new Point(magCenterX, magCenterY)),(Point)mgp);
        //double x = (mgp.getX()*magX)-mgp.getX();
        //double y = (mgp.getY()*magY)-mgp.getY();
        //scale(-x,-y, magX, magY);
    }catch (Exception e) {System.out.println(e); }
    }
    
    public void scale(double magOffsetX, double magOffsetY, double magX, double magY){
    
    af_.translate(magOffsetX,magOffsetY);
    af_.scale(magX, magY);
    }
    
    /** Calculates the new image co-ordinates after translation has occurred */
    protected void calculate_rect()
    {
    double trans_x = af_.getTranslateX();
    double trans_y = af_.getTranslateY();

    xl_ = Math.round((float)trans_x);
    xr_ = Math.round((float)(trans_x + image_x_dim_)) -1;
    yt_ = Math.round((float)trans_y);
    yb_ = Math.round((float)(trans_y + image_y_dim_)) -1; 
    }

    /** Determines whether a given co-ordinate is inside this image
     *
     *  @param x The x co-ordinate
     *  @param y The y co-ordinate */
    public boolean inside(int x, int y)
    {
    return ((x>=xl_) && (x<=xr_)) && ((y>=yt_) && (y<=yb_));
    }

    /** Gets the width of the translated image */
    public double getX() {
    return af_.getTranslateX();
    }

    /** Gets the height of the translated image */
    public double getY() {
    return af_.getTranslateY();
    }
}