//Import av nödvändiga klasser
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import javax.swing.*;

/**
 * MINT - Uppgift 2f
 * En applet som visar en bild som man kan förändra genom att
 * applicera flera olika filter.
 *
 * @author Blanca Larkeson
 */

public class ImageFilter extends Applet implements ActionListener {

  	private Image image;
  	private BildPanel bildPanel;
  	private Label titel;
  	private Panel knappPanel;
	private Button button1, button2, button3, button4, button5, button6, button7;
	private Cursor c;
 	private Font fonten = new Font("Arial", Font.BOLD, 26);

	//Initiering av appleten och placering av komponenter
  	public void init() {
		setSize(480, 350);
		setLayout(new BorderLayout());

    	titel = new Label("ImaGe ShoW", Label.CENTER);
    	titel.setFont(fonten);
    	titel.setForeground(new Color(255, 204, 051));
    	titel.setBackground(new Color(051, 000, 102));
    	add(titel, BorderLayout.NORTH);

  	  	image = getImage (getCodeBase(), "footprints.jpg");
  	  	bildPanel = new BildPanel(image);
		add(bildPanel, BorderLayout.CENTER);

		knappPanel = new Panel();
		knappPanel.setLayout(new GridLayout(7,1,5,5));
		knappPanel.setBackground(new Color(051, 000, 102));
		add(knappPanel, BorderLayout.EAST);

      	button1 = new Button(" GrayDay ");
      	button1.setForeground(new Color(051, 000, 102));
      	button1.setBackground(new Color(153, 153, 204));
	    c = Cursor.getPredefinedCursor(Cursor.HAND_CURSOR);
	    button1.setCursor(c);
	    button1.addActionListener(this);
		knappPanel.add(button1);

      	button2 = new Button(" FlipFlop ");
      	button2.setForeground(new Color(051, 000, 102));
      	button2.setBackground(new Color(153, 153, 204));
	    button2.setCursor(c);
	    button2.addActionListener(this);
        knappPanel.add(button2);

      	button3 = new Button(" BlueBayou ");
      	button3.setForeground(new Color(051, 000, 102));
      	button3.setBackground(new Color(153, 153, 204));
	    button3.setCursor(c);
	    button3.addActionListener(this);
        knappPanel.add(button3);

      	button4 = new Button(" SunShine ");
      	button4.setForeground(new Color(051, 000, 102));
      	button4.setBackground(new Color(153, 153, 204));
	    button4.setCursor(c);
	    button4.addActionListener(this);
        knappPanel.add(button4);

      	button5 = new Button(" GreenLight ");
      	button5.setForeground(new Color(051, 000, 102));
      	button5.setBackground(new Color(153, 153, 204));
	    button5.setCursor(c);
	    button5.addActionListener(this);
        knappPanel.add(button5);

      	button6 = new Button(" PaintFantasy ");
      	button6.setForeground(new Color(051, 000, 102));
      	button6.setBackground(new Color(153, 153, 204));
	    button6.setCursor(c);
	    button6.addActionListener(this);
        knappPanel.add(button6);

      	button7 = new Button(" Återställ ");
      	button7.setForeground(new Color(051, 000, 102));
      	button7.setBackground(new Color(153, 153, 204));
	    button7.setCursor(c);
	    button7.addActionListener(this);
        knappPanel.add(button7);
	}


	//Metod som lyssnar till knapphändelser
	public void actionPerformed(ActionEvent event){

        Object source = event.getSource();

		if (source == button1) {
			bildPanel.filter(new GrayFilter ());
		}
		if (source == button2) {
			bildPanel.filter(new InvertFilter());
		}
		if (source == button3) {
			bildPanel.filter(new BlueFilter());
		}
		if (source == button4) {
			bildPanel.filter(new SunFilter());
		}
		if (source == button5) {
			bildPanel.filter(new GreenFilter());
		}
		if (source == button6) {
			bildPanel.filter(new FantasyFilter());
		}
		if (source == button7) {
			bildPanel.clean();
		}
	}


//En innre klass som innehåller hjälpmetoder för bildomvandling
class BildPanel extends JPanel{

  	private Image bild;
	private RGBImageFilter filter;
	private MediaTracker mt;


  	public BildPanel(Image bild){
    	super();
    	this.bild = bild;
	    mt = new MediaTracker(this);
	    mt.addImage(bild, 1);
	     try{
	         mt.waitForAll();
	     }catch(Exception e){
	         System.out.println("BILDPROBLEM: " + e);
	         System.exit(1);
     	}
    	this.setBackground(new Color(051, 000, 102));
  	}

	//Bilden ritas ut
  	public void paintComponent(Graphics g){
    	super.paintComponent(g);
    	g.drawImage(bild, 25, 10,this);
  	}

	//Ny bild skapas efter applicering av filter
   	public void filter(RGBImageFilter newFilter) {
      	filter = newFilter;
      	ImageProducer ip = image.getSource();
      	FilteredImageSource fiSource = new FilteredImageSource(ip, filter);
      	bild = createImage(fiSource);
      	mt.addImage(bild, 1);
      	repaint();
   }

	//Den ursprungliga bilden återskapas
   	public void clean(){
	   	bild = image;
	   	mt.addImage(bild, 1);
      	repaint();
   }
}


//Filter som producerar en grå bild
private class GrayFilter extends RGBImageFilter {

  	public GrayFilter () {
    	canFilterIndexColorModel = true;
    }

	//Här sköts själva filtreringen av färger
  	public int filterRGB (int x, int y, int rgb) {
		int alpha = (rgb & 0xff000000) >> 24;
    	int red   = (rgb & 0x00ff0000) >> 16;
    	int green = (rgb & 0x0000ff00) >>  8;
    	int blue  = (rgb & 0x000000ff);
    	int gray  = (red + green + blue) / 3;

    	return ((alpha << 24) | (gray << 16) | (gray <<  8) |  gray);
    }
}


//Filter som producerar en inverterad bild
private class InvertFilter extends RGBImageFilter {

	public InvertFilter () {
		canFilterIndexColorModel=true;
		}

	//Samtliga färger retuneras som motsatser
	//Kan skrivas i en enda sats med: return ~(rgb & 0x00ffffff);
	public int filterRGB (int x,int y,int rgb) {
		int alpha = (rgb & 0xff000000) >> 24;
		int red   = (rgb & 0x00ff0000) >> 16;
		int green = (rgb & 0x0000ff00) >>  8;
    	int blue  = (rgb & 0x000000ff);

    	red = -red & 0xFF;
    	green = - green & 0xFF;
    	blue = -blue & 0xFF;

    	return ((alpha << 24) | (red << 16) | (green <<  8) |  blue);
	}
}


//Filter som producerar en blå-röd bild
private class BlueFilter extends RGBImageFilter {

	 public BlueFilter() {
		 canFilterIndexColorModel = true;
	 }

	//Här sköts filtreringen direkt i returen
	 public int filterRGB(int x, int y, int rgb) {
		return ((rgb & 0xff00ff00) | ((rgb & 0xff0000) >> 16) | ((rgb & 0xff) << 16));
	 }
}


//Filter som producerar en solig bild
private class SunFilter extends RGBImageFilter {

	public SunFilter () {
		canFilterIndexColorModel=true;
		}

	//Här sköts själva filtreringen av färger
	public int filterRGB (int x,int y,int rgb) {
		int alpha = (rgb & 0xff000000) >> 24;
		int red   = (rgb & 0x00ff0000) >> 16;
		int green = (rgb & 0x0000ff00) >>  8;
    	int blue  = (rgb & 0x00000000);

    	return ((alpha << 20) | (red << 20) | (green << 8) |  blue);
	}
}


//Filter som producerar en gröntonad bild
private class GreenFilter extends RGBImageFilter {

	public GreenFilter () {
		canFilterIndexColorModel=true;
		}

	//Här sköts själva filtreringen av färger
	public int filterRGB (int x,int y,int rgb) {
		int alpha = (rgb & 0xff000000) >> 24;
		int red   = (rgb & 0x00ff0000) >> 16;
		int green = (rgb & 0x0000ff00) >>  8;
    	int blue  = (rgb & 0x00000000);

 		//röd och grön byter plats
		int temp = red; red = green; green = temp;

		//grön nyans tonas ned något
		green /= 1.2;

    	return ((alpha << 24) | (red << 16) | (green << 8) |  blue);
	}
}


//Filter som gör om foto till målning i glada färger
private class FantasyFilter extends RGBImageFilter {

	public FantasyFilter () {
		canFilterIndexColorModel=true;
		}

	//Här sköts själva filtreringen av färger
	public int filterRGB (int x, int y, int rgb) {
   		int alpha = (rgb & 0xff000000);
   		int red   = ((rgb & 0x00ffffff) + 0xffff0000)/2;
   		int green = ((rgb & 0x00ffffff) + 0xff00ff00);
   		int blue  = ((rgb & 0x00ffffff) + 0xff0000ff)/2;

		return ((alpha << 24) | red | (green << 16) |  blue);
	}
}



}