import java.applet.Applet;
import java.applet.AppletContext;
import java.awt.*;
import java.awt.image.MemoryImageSource;
import java.awt.image.PixelGrabber;

public class Rotate extends Applet implements Runnable {
//  Program Variables

    private Thread Rotate;
    private boolean Image_Loaded;
    private Graphics grafics;
    private Image currentImage;
    private Image nextImage;
    private Image buffer;

    private int BackGround_Color;
    private int Image_Width;
    private int Image_Height;
    private int Wide;
    private int High;
    private int counter;
    private int Step;
    private int Pause;
    private int pixels1[];
    private int pixels2[];  
    private String firstImage;
    private String color;
    private String step;
    private String pause;
    int mode = 0; //1.. next picture loaded, hide previous picture  2.. prev picture  hiden, 3.. shov picture 2,  4. picture 2 shown
	boolean changePicture = false;
// --------------------------------------------------------------------------
   public void init() {
// --------------------------------------------------------------------------

        Dimension d = size();
        Wide = d.width;
        High = d.height;
        buffer = createImage(Wide, High);
        color = getParameter("BackGround");
        if(color != null)
            BackGround_Color = Integer.parseInt(color,16);
        else
            BackGround_Color = Integer.parseInt("000000",16);
		firstImage = getParameter("firstImage");       
        step = getParameter("Steps");
        if(step != null)
            Step = Integer.parseInt(step);
        else
            Step = 255;

        if(Step > 255)
            Step = 255;

        Step = 255 / Step;

        pause = getParameter("Speed");
        if(pause != null)
            Pause = Integer.parseInt(pause);
        else
            Pause = 10;
		loadImage(firstImage);
    }
	
	public void loadImage(String slika) {
        setBackground(new Color(BackGround_Color));
		Image_Loaded = false;
        repaint();
        grafics = getGraphics();
        MediaTracker tracker = new MediaTracker(this);
        nextImage = getImage(getDocumentBase(), slika);
		if (mode ==0) currentImage = nextImage;  // this is the first image
        tracker.addImage(nextImage, 0);
        try {
            tracker.waitForAll();
            Image_Loaded = !tracker.isErrorAny();
        }
        catch(InterruptedException e) { }
        if(!Image_Loaded){
            stop();
            grafics.drawString("slike ne morem naloziti!", 10, 10);
            return;
        }
        putPictureInBuffer();
		if (mode >0) changePicture = true;  // first picture will not be rotated
		mode = 1;
	}
   
    private void putPictureInBuffer() {
	    Image_Width  = currentImage.getWidth(this);
        Image_Height = currentImage.getHeight(this);
        int area = Image_Width * Image_Height;
        pixels1  = new int[area];
        pixels2  = new int[area];
        try {
            PixelGrabber pg = new PixelGrabber(currentImage, 0, 0, Image_Width, Image_Height, pixels1, 0, Image_Width);
            pg.grabPixels();
        }
        catch(InterruptedException e) { }
        for(int j = 0; j < area; j += Image_Width) {
            for(int i = 0; i < Image_Width; i++)
                pixels2[i + j] = pixels1[(j + Image_Width) - i - 1];
        }
        Image_Width = size().width;
        Image_Height = size().height;
	}
// --------------------------------------------------------------------------
   public void start() {
// --------------------------------------------------------------------------

        if(Rotate == null)
        {
            Rotate = new Thread(this);
            Rotate.start();
        }
    }


// --------------------------------------------------------------------------
   public void run() {
// --------------------------------------------------------------------------

        do
		   	if(changePicture) {
            try
            {   
				if (mode ==1)
                for(counter = 0; counter < Image_Width; counter += Step ) {
                    displayImage(grafics);
                    Thread.sleep(Pause);
                }
                mode = 2;
                currentImage = nextImage;
				putPictureInBuffer();
                for(counter = Image_Width; counter > 0; counter -= Step) {
                    displayImage(grafics);
                    Thread.sleep(Pause);
                }
				mode = 1; changePicture = false; // picture loaded, stop rotation
            }
            catch(InterruptedException e) { stop();}
			}
        while(true);
    }


// --------------------------------------------------------------------------
   public void paint(Graphics g) {
// --------------------------------------------------------------------------

        Rectangle r = g.getClipRect();
        if(Image_Loaded)
        {
            g.clearRect(r.x, r.y, r.width + Step, r.height + Step);
            displayImage(g);
        }
        else
        {
            g.clearRect(r.x, r.y, r.width, r.height);
        }
    }



// --------------------------------------------------------------------------
   private void displayImage(Graphics g) {
// --------------------------------------------------------------------------

        Graphics Logo = null;
        if(!Image_Loaded) {
            return;
        }
        else {
            Logo = g;
            g = buffer.getGraphics();
            g.clearRect((size().width - Image_Width) / 2, (size().height - Image_Height) / 2, Image_Width, Image_Height);
            g.drawImage(currentImage, ((size().width - Image_Width) + counter) / 2, (size().height - Image_Height) / 2, Image_Width - counter, Image_Height, null);
            Logo.drawImage(buffer, 0, 0, null);
            return;
        }
    }

// --------------------------------------------------------------------------
   public void stop() {
// --------------------------------------------------------------------------
        if(Rotate != null)
        {
            Rotate.stop();
            Rotate = null;
        }
    }
}

