/*
    $Author: $
    $Date: $
    $Revision: $
    $NoKeywords: $
*/
package jp.co.ntl.swing;

import java.awt.AWTEvent;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
//import java.awt.Image;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.event.*;

import javax.swing.JComponent;

import jp.co.ntl.awt.event.ChangeEvent;
import jp.co.ntl.awt.event.ChangeListener;
import jp.co.ntl.awt.event.ChangeSupport;

public class Positioner extends JComponent {
    /**
	 * 
	 */
	private static final long serialVersionUID = 5136093974034886700L;
	private static final int ROW_COUNT      = 3;
    private static final int COLUMN_COUNT   = 3;
    
    private Color backColor = Color.white;//Color.lightGray;
    private Color laticeColor = Color.lightGray;//Color.white;
    private Color boxColor = Color.black;
    private Color boxShadowColor = Color.gray;
    
    private ChangeSupport support;
    
    private int currentPos = 4; // 0 乣 ROW_COUNT * COLUMN_COUNT - 1
    private int[] laticeX;
    private int[] laticeY;
    private Rectangle[] boxes;
    
    private int offsetX = 0;
    private int offsetY = 0;
    private int dispOffsetX = 0;
    private int dispOffsetY = 0;
  
    private float scale = 1.0f;
    
    public Positioner(int width, int height, float scale) {
        this.scale = scale;
        
        laticeX = new int[COLUMN_COUNT + 1];
        laticeY = new int[ROW_COUNT + 1];
        for (int i = 0; i < laticeX.length - 1; i++) {
            laticeX[i] = width * i / COLUMN_COUNT;
        }
        laticeX[laticeX.length - 1] = width - 1;
        for (int i = 0; i < laticeY.length - 1; i++) {
            laticeY[i] = height * i / ROW_COUNT;
        }
        laticeY[laticeY.length - 1] = height - 1;

        boxes = new Rectangle[ROW_COUNT * COLUMN_COUNT];
        int index = 0;
        for (int j = 0; j < ROW_COUNT; j++) {
            for (int i = 0; i < COLUMN_COUNT; i++) {
                boxes[index++] = new Rectangle(laticeX[i], 
                                               laticeY[j], 
                                               laticeX[i + 1] - laticeX[i], 
                                               laticeY[j + 1] - laticeY[j]);
            }
        }
        setSize(width, height);
        
        enableEvents(AWTEvent.MOUSE_EVENT_MASK);
        
        support = new ChangeSupport();
    }
    
    public void setOffset(int offsetX, int offsetY) {
        this.offsetX = offsetX;
        this.offsetY = offsetY;
        this.dispOffsetX = convert(offsetX);
        this.dispOffsetY = -convert(offsetY);
        
        repaint();
    }
    
    public int getOffsetX() {
        return offsetX;
    }
    
    public int getOffsetY() {
        return offsetY;
    }
    
    private int convert(int offset) {
        return (int)(offset * scale);
    }
    
    public void setPosition(int pos) {
        currentPos = pos;
    }
    
    public int getPosition() {
        return currentPos;
    }
    
    public void addChangeListener(ChangeListener cl) {
        support.addChangeListener(cl);
    }
    
    public void removeChangeListner(ChangeListener cl) {
        support.removeChangeListener(cl);
    }
    
    public void update(Graphics g) {
        paint(g);
    }
    
//    private Image backImage = null;
//    private Graphics gImage = null;
    /*
    public void paint(Graphics g) {
        if (backImage == null) {
            Dimension d = getSize();
			backImage = createImage(d.width, d.height);
			gImage = backImage.getGraphics();
		}
        
        paintComponent(gImage);
     	g.drawImage(backImage, 0, 0, this);
    }*/
    
    public void paintComponent(Graphics g) {
        Dimension d = getSize();
        g.setColor(backColor);
        g.fillRect(0, 0, d.width, d.height);
        g.setColor(laticeColor);
        for (int i = 1; i < laticeX.length - 1; i++) {            
            g.drawLine(laticeX[i], 0, laticeX[i], d.height);
        }
        for (int i = 1; i < laticeY.length - 1; i++) {
            g.drawLine(0, laticeY[i], d.width, laticeY[i]);
        }
        
        Rectangle r = boxes[currentPos];
        g.setColor(boxShadowColor);
        g.drawRect(r.x, r.y, r.width, r.height);
        g.drawLine(r.x, r.y, r.x + r.width, r.y + r.height);
        g.drawLine(r.x, r.y + r.height, r.x + r.width, r.y);
        g.setColor(boxColor);
        g.drawRect(r.x + dispOffsetX, r.y + dispOffsetY, r.width, r.height);
        g.drawLine(r.x + dispOffsetX, r.y + dispOffsetY, r.x + dispOffsetX + r.width, r.y + dispOffsetY + r.height);
        g.drawLine(r.x + dispOffsetX, r.y + dispOffsetY + r.height, r.x + dispOffsetX + r.width, r.y + dispOffsetY);
    }
    
    public void processMouseEvent(MouseEvent me) {
        if (me.getID() == MouseEvent.MOUSE_PRESSED) {
            Point pt = me.getPoint();
            for (int i = 0; i < boxes.length; i++) {
                if (boxes[i].contains(pt)) {
                    if (i != currentPos) {
                        currentPos = i;
                        offsetX = 0;
                        offsetY = 0;
                        dispOffsetX = convert(offsetX);
                        dispOffsetY = -convert(offsetY);
                        support.fireChangeEvent(new ChangeEvent(this)); 
                        repaint();
                    }
                    break;
                }
            }
        }
    }
}