tableheader.java

打印管理程序,测试完全通过.windows开发环境.

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

import java.awt.*;
import java.awt.event.*;
import java.beans.PropertyChangeSupport;
import java.beans.PropertyChangeListener;

import jp.co.ntl.Util;
import jp.co.ntl.awt.event.TableModelListener;
import jp.co.ntl.awt.event.TableModelEvent;

public class TableHeader extends Component implements TableModelListener {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
    private float[] widthRatio = null;
    private int[] widths;
    
    /** 巊梡偡傞儌僨儖丅柧帵揑偵愝掕偝傟側偄応崌偼僨僼僅儖僩偺儌僨儖傪巊梡偡傞丅*/
    private TableModel model = null;    
    /** 巊梡偡傞儗儞僟儔乕丅柧帵揑偵愝掕偝傟側偄応崌偼僨僼僅儖僩偺儗儞僟儔乕傪巊梡偡傞丅*/
    private TableCellRenderer renderer = new DefaultHeaderRenderer();
    
    private PropertyChangeSupport support = new PropertyChangeSupport(this);
    
    public TableHeader(TableModel model) {
        this.model = model;
        
        MyMouseListener l = new MyMouseListener();
        addMouseListener(l);
        addMouseMotionListener(l);
    }

    public void setEnabled(boolean enabled) {
        super.setEnabled(enabled);
    
        repaint();
    }

    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();
		}
        
        gImage.setClip(g.getClip());
        paintComponent(gImage);
     	g.drawImage(backImage, 0, 0, this);
    }        

    public void paintComponent(Graphics g) {
        if (widths == null) {
            calcWidths();
            int[] oldWidths = widths;
            //this.widths = widths;
            support.firePropertyChange("widths", oldWidths, widths);
        }
        
        FontMetrics fm = g.getFontMetrics();
        int bx, by;
        for (int i = 0, x = 0; i < widths.length; i++) {
            String value = model.getColumnName(i);
            switch (renderer.getAlignment(i)) {
            case TableCellRenderer.CENTER:
                bx = Util.basePointX(fm, value, widths[i]);
                by = Util.basePointY(fm, value, getSize().height);
                if (bx < 3) {
                    bx = 3;
                }
                break;
            case TableCellRenderer.RIGHT:
                if (fm.stringWidth(value) > widths[i] - 3) {
                    bx = 3;
                } else {
                    bx = widths[i] - fm.stringWidth(value) - 3;
                }
                by = Util.basePointY(fm, value, getSize().height);
                break;
            case TableCellRenderer.LEFT:
            default:
                bx = 3;
                by = Util.basePointY(fm, value, getSize().height);
                break;
            }
            Color color = renderer.getBackground(false, true, isEnabled());
            if (color == null) {
                g.setColor(getBackground());
            } else {
                g.setColor(color);
            }
            g.fill3DRect(x, 0, widths[i], getSize().height, true);
            /*
            g.setColor(Color.white);
            g.drawString(model.getColumnName(i), x + pt.x + 1, 0 + pt.y + 1);
            */
            color = renderer.getForeground(false, true, isEnabled());
            if (color == null) {
                g.setColor(getForeground());
            } else {
                g.setColor(color);
            }
            g.drawString(value, x + bx, 0 + by);
            x += widths[i];
        }
    }
    
    public void setHeaderRenderer(TableCellRenderer renderer) {
        this.renderer = renderer;
    }
    
    public TableCellRenderer getHeaderRenderer() {
        return renderer;
    }
    
    public synchronized void setWidthRatio(float[] widthRatio) {
        this.widthRatio = widthRatio;
        if (isValid()) {
            calcWidths();
            int[] oldWidths = widths;
            //this.widths = widths;
            support.firePropertyChange("widths", oldWidths, widths);
        } else {
            //widths偺寛掕偼丄paint()偑屇偽傟傞傑偱墑婜丅
        }
    }
    
    public synchronized void setWidths(int[] widths) {
        int[] oldWidths = widths;
        this.widths = widths;
        support.firePropertyChange("widths", oldWidths, widths);
        repaint();
    }
        
    public int[] getWidths() {
        if (widths == null) {
            calcWidths();
        }        
        return widths;
    }
    
    private void calcWidths() {
        if (widthRatio == null) {
            widthRatio = new float[model.getColumnCount()];
            for (int i = 0; i < widthRatio.length; i++) {
                widthRatio[i] = 1.0f;
            }
        }
            
        widths = new int[widthRatio.length];
        float denominator = 0;
        float widthRatioTemp = 0;
        int widthTemp = 0;
        int widthPrevTemp = 0;
        for (int i = 0; i < widthRatio.length; i++) {
            denominator += widthRatio[i];
        }
        for (int i= 0; i < widthRatio.length - 1; i++) {
            widthRatioTemp += widthRatio[i];
            widthPrevTemp = widthTemp;
            widthTemp = (int)(getSize().width * widthRatioTemp / denominator);
            widths[i] = widthTemp - widthPrevTemp;
        }
        widths[widths.length - 1] = getSize().width - widthTemp;
    }
    
    public void addPropertyChangeListener(PropertyChangeListener l) {
        support.addPropertyChangeListener(l);
    }
               
    public void removePropertyChangeListener(PropertyChangeListener l) {
        support.removePropertyChangeListener(l);
    }

    public void tableChanged(TableModelEvent tme) {
        this.model = tme.getTableModel();
        repaint();
    }
    
    private boolean columnPressListen = false;
    /** 楍偺僿僢僟傪僋儕僢僋偟偨偲偒偵昞帵偑曄傢傞偐偳偆偐傪愝掕偡傞丅 */
    void setColumnPressListen(boolean columnPressListen) {
        this.columnPressListen = columnPressListen;
    }

    /** 
     * 儅僂僗僀儀儞僩張棟僋儔僗 
     */
    class MyMouseListener implements MouseListener, MouseMotionListener {
        /** 儅僂僗億僀儞僞偑巜偟偰偄傞楍偺嫬奅慄斣崋 */
        int pointedLine;
        /** 儅僂僗億僀儞僞偑嫬奅慄傪巜偟偰偄傞偐偳偆偐 */
        boolean linePointed = false;
        /** 嫬奅慄偑慖戰偝傟偰偄傞偐偳偆偐 */
        boolean lineSelected = false;
        /** 楍偑慖戰偝傟偰偄傞偐偳偆偐 */
        boolean columnPressed = false;
        /** 慖戰偝傟偰偄傞楍斣崋 */
        int pressedColumn;

        private int prevPosX;
        
        /** 埵抲偐傜楍斣崋傪庢摼偡傞丅*/
        private int columnAtPoint(Point pt) {
            int curWidth = 0;
            for (int i = 0; i < widths.length; i++) {
                if ((pt.x >= curWidth) && (pt.x < curWidth + widths[i])) {
                    return i;
                }
                curWidth += widths[i];
            }
            return (-1);
        }
    
        public void mouseMoved(MouseEvent me) {
            if (widths == null) {
                return;
            }
            int ptX = me.getX();
            int x = 0;
            boolean b = false;
            for (int i = 0; i < widths.length - 1; i++) {
                x += widths[i];
                if ((ptX > x - 3) && (ptX < x + 3)) {
                    b = true;
                    pointedLine = i;
                    break;
                }
            }
            if (b && !linePointed) {
                setCursor(new Cursor(Cursor.E_RESIZE_CURSOR));
                linePointed = true;
            } else if (!b && linePointed) {
                setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
                linePointed = false;
            }
        }

        public void mouseDragged(MouseEvent me) {
            int posX;
            //楍偺暆偼10傛傝彫偝偔側傜側偄
            if (lineSelected) {
                posX = me.getX();
                if (posX > getSize().width - 3) {
                    posX = getSize().width - 3;
                }
                //楍暆傪曄峏偡傞丅宺慄偺嵍偺楍傪怢弅偡傞僶乕僕儑儞
                widths[pointedLine] += posX - prevPosX;
                widths[widths.length - 1] -= posX - prevPosX;
                if (widths[pointedLine] < 10) {
                    widths[pointedLine] = 10;
                }
                int w = 0;
                for (int i = 0; i < widths.length; i++) {
                    w += widths[i];
                }
                widths[widths.length - 1] += getSize().width - w;
                
                prevPosX = posX;
                //僀儀儞僩偺敪惗
                support.firePropertyChange("widths", null, widths); 
//                repaint();
                int x = 0;
                for (int i = 0; i <= pointedLine; i++) {
                    x += widths[i];
                }
                if (posX < x - 2 || posX > x + 2) {
                    lineSelected = false;
                    setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
                    linePointed = false;
                }

                repaint();
            }
        }

        public void mousePressed(MouseEvent me) {
            if (linePointed) {
                lineSelected = true;
                prevPosX = me.getX();
            } else {
                if (columnPressListen && AwtUtilities.isLeftMouseButton(me)) {
                    columnPressed = true;
                    pressedColumn = columnAtPoint(me.getPoint());
                    repaint();
                }
            }
        }

        public void mouseReleased(MouseEvent me) {
            lineSelected = false;
            if (columnPressListen && columnPressed) {
                columnPressed = false;
                //fireColumnSelectionChanged(new TableColumnEvent(this, pressedColumn));
                repaint();
            }
        }

        public void mouseClicked(MouseEvent me) {
        }

        public void mouseEntered(MouseEvent me) {
        }

        public void mouseExited(MouseEvent me) {
            if (columnPressListen && columnPressed) {
                columnPressed = false;
                repaint();
            }
        }
    }    
}