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

/**
 * 僥乕僽儖偺僌儕僢僪晹梡僋儔僗
 */

import java.awt.*;
import java.awt.event.*;
import java.util.*;

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeEvent;

import jp.co.ntl.Util;
import jp.co.ntl.awt.event.TableModelListener;
import jp.co.ntl.awt.event.TableModelEvent;
import jp.co.ntl.awt.event.TableEvent;
import jp.co.ntl.awt.event.TableEventListener;
import jp.co.ntl.awt.Scrollable;

public class TableBody extends Component 
            implements TableModelListener, PropertyChangeListener, Scrollable {   
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
    private static int SIZE_DUMMY = 20;

    /** 楍偺暆忣曬偼<code>TableHeader</code>偐傜庢摼偡傞丅*/
    private TableHeader header;
    private int rowHeight;
 
    private TableModel model = null;
    private TableCellRenderer renderer = new DefaultTableCellRenderer();
    private SelectedRowBuffer selectedRows = new SelectedRowBuffer(); 
    
    private boolean multiSelection = true;
	private boolean drawRuledLine = true;
    
    private Vector listeners = new Vector();
    
    public TableBody(TableModel model, TableHeader header, int rowHeight) {
        this.model = model;
        this.header = header;
        this.rowHeight = rowHeight;

        if (model != null) {
            setSize(SIZE_DUMMY, rowHeight * model.getRowCount());
        } else {
            setSize(SIZE_DUMMY, 0);
        }
        
        enableEvents(AWTEvent.KEY_EVENT_MASK | AWTEvent.MOUSE_EVENT_MASK);
    }        

    public void setEnabled(boolean enabled) {
        super.setEnabled(enabled);
        //selectedRows.removeAll();
    
        getParent().repaint();
    }

	public void setMultiSelection(boolean multiSelection) {
		this.multiSelection = multiSelection;
		selectedRows.removeAll();
		repaint();
	}
	
	public boolean isMultiSelection() {
		return multiSelection;
	} 
    
	public void setDrawRuledLine(boolean drawRuledLine) {
		this.drawRuledLine = drawRuledLine;
		repaint();
	}
	
	public boolean isDrawRuledLine() {
		return drawRuledLine;
	} 
	
	public void selectRow(int row) {
		selectedRows.set(row);
		repaint();

        fireTableEvent(new TableEvent(this));
	}
    
    protected SelectedRowBuffer getSelectionRowBuffer() {
    	return selectedRows;
    }
    
    public void setTableCellRenderer(TableCellRenderer renderer) {
        this.renderer = renderer;
        repaint();
    }
    
    public int getScrollableHeight() {
        return model.getRowCount() * rowHeight;
    }
    
    public int getScrollableBlockIncrement(int visibleTop) {
        return rowHeight * 5;
    }
    
    public int getScrollableUnitIncrement(int visibleTop) {
        return rowHeight;
    }
   
    public void update(Graphics g) {
        paint(g);
    }
    
    private void invalidateBackImage() {
    	backImage = null;
	   	gImage = null;
    }
    
    private Image backImage = null;
    private Graphics gImage = null;
    public void paint(Graphics g) {
        Dimension d = getSize();
		if (d.width == 0 || d.height == 0) {
			return;
		}

        if (backImage == null) {
			backImage = createImage(d.width, d.height);
			gImage = backImage.getGraphics();
		}
       
        gImage.setClip(g.getClip());
        paintComponent(gImage);
     	g.drawImage(backImage, 0, 0, this);
    }        

    public void paintComponent(Graphics g) {
        if (model == null) {
            return;
        }
        
        int[] widths = header.getWidths();
        Rectangle drawHere = g.getClipBounds();
        int startRow = drawHere.y / rowHeight;
        int endRow = ((drawHere.y + drawHere.height) / rowHeight);
        FontMetrics fm = g.getFontMetrics();
        int bx, by;
        Color selectedBgColor, selectedTxtColor;
        Color notSelectedBgColor, notSelectedTxtColor;
        selectedBgColor = renderer.getBackground(true, false, isEnabled());//hasFocus());
        selectedTxtColor = renderer.getForeground(true, false, isEnabled());//hasFocus());
        notSelectedBgColor = renderer.getBackground(false, false, isEnabled());//hasFocus());
        notSelectedTxtColor = renderer.getForeground(false, false, isEnabled());//hasFocus());
        Color bgColor, txtColor;
        for (int i = startRow; i <= endRow && i < model.getRowCount(); i++) {
            int x = 0;
            if (selectedRows.include(i)) {
                bgColor = selectedBgColor;
                txtColor = selectedTxtColor;
            } else {
                bgColor = notSelectedBgColor;
                txtColor = notSelectedTxtColor;
            }
            for (int j = 0; j < widths.length; j++) {
                g.setColor(bgColor);
                if (drawRuledLine) {
	                g.fill3DRect(x, i * rowHeight, widths[j], rowHeight, true);
                } else {
                	g.fillRect(x, i * rowHeight, widths[j], rowHeight);
                }
                String value = model.getValueAt(i, j).toString();
                switch (renderer.getAlignment(j)) {
                case TableCellRenderer.CENTER:
                    bx = Util.basePointX(fm, value, widths[j]);
                    by = Util.basePointY(fm, value, rowHeight);
                    if (bx < 3) {
                        bx = 3;
                    }
                    break;
                case TableCellRenderer.RIGHT:
                    if (fm.stringWidth(value) > widths[j] - 3) {
                        bx = 3;
                    } else {
                        bx = widths[j] - fm.stringWidth(value) - 3;
                    }
                    by = Util.basePointY(fm, value, rowHeight);
                    break;
                case TableCellRenderer.LEFT:
                default:
                    bx = 3;
                    by = Util.basePointY(fm, value, rowHeight);
                    break;
                }
                g.setColor(txtColor);
                g.drawString(value, x + bx, i * rowHeight + by);
                x += widths[j]; 
            }
        }
    }
    
    public void tableChanged(TableModelEvent tme) {
        model = tme.getTableModel();
        Rectangle rOld = getBounds();
        Dimension d = getParent().getSize();
        
        if (model != null) {
	        int widthNew, heightNew, widthParent, heightParent;
	        widthParent = d.width;
	        heightParent = d.height;
	        widthNew = widthParent;
	        heightNew = rowHeight * model.getRowCount();
            if (heightNew < heightParent) {
                setBounds(rOld.x, 0, widthNew, heightNew);
            } else {
            	if (rOld.y + heightNew < heightParent) {
	                setBounds(rOld.x, -(heightNew - heightParent), widthNew, heightNew);
            	} else {
	                setBounds(rOld.x, rOld.y, widthNew, heightNew);
            	}
            }