treetable.java

world wind java sdk 源码

/*
Copyright (C) 2001, 2008 United States Government as represented by
the Administrator of the National Aeronautics and Space Administration.
All Rights Reserved.
*/
package gov.nasa.worldwind.applications.gio.catalogui.treetable;

import gov.nasa.worldwind.util.Logging;

import javax.swing.*;
import javax.swing.border.Border;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.table.TableCellRenderer;
import javax.swing.tree.*;
import java.awt.*;
import java.awt.event.InputEvent;
import java.awt.event.MouseEvent;
import java.util.EventObject;

/**
 * @author dcollins
 * @version $Id$
 */
public class TreeTable extends JTable
{
    private TreeTableModel treeTableModel;
    protected TreeTableCellRenderer tree;
    private boolean askIfTreeEditable;
    private boolean isTreeEditable;

    public TreeTable(TreeTableModel model)
    {
        if (model == null)
        {
            String message = "nullValue.ModelIsNull";
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        this.treeTableModel = model;
        this.tree = new TreeTableCellRenderer(new TreeModelAdapter(this.treeTableModel));
        super.setModel(new TableModelAdapter(this.treeTableModel, this.tree));
        ToolTipManager.sharedInstance().registerComponent(this.tree);

        ListToTreeSelectionModelWrapper selectionWrapper = new ListToTreeSelectionModelWrapper();
        this.tree.setSelectionModel(selectionWrapper);
        setSelectionModel(selectionWrapper.getListSelectionModel());

        setDefaultRenderer(TreeTableModel.class, this.tree);
        setDefaultEditor(TreeTableModel.class, new TreeTableCellEditor());

        setShowGrid(false);
        setIntercellSpacing(new Dimension(0, 0));

        if (this.tree.getRowHeight() < 1)
        {
            setRowHeight(20);
        }
    }

    public TreeTableModel getTreeTableModel()
    {
        return this.treeTableModel;
    }

    public JTree getTree()
    {
        return this.tree;
    }

    public TreeCellRenderer getTreeCellRenderer()
    {
        return this.tree.getCellRenderer();
    }

    public void setTreeCellRenderer(TreeCellRenderer x)
    {
        this.tree.setCellRenderer(x);
    }

    public boolean isAskIfTreeEditable()
    {
        return this.askIfTreeEditable;
    }

    public void setAskIfTreeEditable(boolean askIfTreeEditable)
    {
        this.askIfTreeEditable = askIfTreeEditable;
    }

    public boolean isTreeEditable()
    {
        return this.isTreeEditable;
    }

    public void setTreeEditable(boolean treeEditable)
    {
        this.isTreeEditable = treeEditable;
    }

    public int getEditingRow()
    {
        return getColumnClass(this.editingColumn) == TreeTableModel.class ? -1 : this.editingRow;
    }

    protected int realEditingRow()
    {
        return this.editingRow;
    }

    public boolean editCellAt(int row, int column, EventObject e)
    {
        boolean retValue = super.editCellAt(row, column, e);
        if (retValue && getColumnClass(column) == TreeTableModel.class)
        {
            repaint(getCellRect(row, column, false));
        }
        return retValue;
    }

    public void sizeColumnsToFit(int resizingColumn)
    {
        super.sizeColumnsToFit(resizingColumn);
        if (getEditingColumn() != -1 && getColumnClass(this.editingColumn) == TreeTableModel.class)
        {
            Rectangle cellRect = getCellRect(realEditingRow(), getEditingColumn(), false);
            Component component = getEditorComponent();
            component.setBounds(cellRect);
            component.validate();
        }
    }

    public void setRowHeight(int rowHeight)
    {
        super.setRowHeight(rowHeight);
        if (this.tree != null && this.tree.getRowHeight() != rowHeight)
        {
            this.tree.setRowHeight(getRowHeight());
        }
    }

    public void updateUI()
    {
        super.updateUI();
        if (this.tree != null)
        {
            this.tree.updateUI();
            //setDefaultEditor(TreeTableModel.class, new TreeTableCellEditor());
        }
        LookAndFeel.installColorsAndFont(this, "Tree.background", "Tree.foreground", "Tree.font");
    }

    class TreeTableCellRenderer extends JTree implements TableCellRenderer
    {
        protected int visibleRow;
        protected Object realCellValue;
        protected Border highlightBorder;

        public TreeTableCellRenderer(TreeModel model)
        {
            super(model);
        }

        public String convertValueToText(Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus)
        {
            String text = null;
            if (this.realCellValue != null)
                text = this.realCellValue.toString();
            if (text == null)
                text = super.convertValueToText(value, selected, expanded, leaf, row, hasFocus);
            return text;
        }

        public String getToolTipText(MouseEvent event)
        {
            event.translatePoint(0, this.visibleRow * getRowHeight());
            return super.getToolTipText(event);
        }

        public void setRowHeight(int rowHeight)
        {
            if (rowHeight > 0)
            {
                super.setRowHeight(rowHeight);
                if (TreeTable.this.getRowHeight() != rowHeight)
                {
                    TreeTable.this.setRowHeight(getRowHeight());
                }
            }
        }

        public void setBounds(int x, int y, int w, int h)
        {
            super.setBounds(x, 0, w, TreeTable.this.getHeight());
        }

        public void paint(Graphics g)
        {
            if (g == null)
            {
                String message = "nullValue.GraphicsIsNull";
                Logging.logger().severe(message);
                throw new IllegalArgumentException(message);
            }

            g.translate(0, -this.visibleRow * getRowHeight());
            super.paint(g);
            if (this.highlightBorder != null)
            {
                this.highlightBorder.paintBorder(this, g, 0, visibleRow * getRowHeight(), getWidth(), getRowHeight());
            }
        }

        public void updateUI()
        {
            super.updateUI();
            TreeCellRenderer tcr = getCellRenderer();
            if (tcr instanceof DefaultTreeCellRenderer)
            {
                DefaultTreeCellRenderer dtcr = ((DefaultTreeCellRenderer) tcr);
                dtcr.setTextSelectionColor(UIManager.getColor("Table.selectionForeground"));
                dtcr.setBackgroundSelectionColor(UIManager.getColor("Table.selectionBackground"));
            }
        }

        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,
                                                       int row, int column)
        {
            if (table == null)
            {
                String message = "nullValue.TableIsNull";
                Logging.logger().severe(message);
                throw new IllegalArgumentException(message);
            }

            this.realCellValue = value;

            Color background;
            Color foreground;
            if (isSelected)
            {
                background = table.getSelectionBackground();
                foreground = table.getSelectionForeground();
            }
            else
            {
                background = table.getBackground();
                foreground = table.getForeground();
            }

            this.highlightBorder = null;
            if (TreeTable.this.realEditingRow() == row && TreeTable.this.getEditingColumn() == column)
            {
                background = UIManager.getColor("Table.focusCellBackground");
                foreground = UIManager.getColor("Table.focusCellForeground");
            }
            else if (hasFocus)
            {
                this.highlightBorder = UIManager.getBorder("Table.focusCellHighlightBorder");
                if (TreeTable.this.isCellEditable(row, column))
                {
                    background = UIManager.getColor("Table.focusCellBackground");
                    foreground = UIManager.getColor("Table.focusCellForeground");
                }
            }

            this.visibleRow = row;