1 /*

     2  * CDDL HEADER START

     3  *

     4  * The contents of this file are subject to the terms of the

     5  * Common Development and Distribution License (the "License").

     6  * You may not use this file except in compliance with the License.

     7  *

     8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

     9  * or http://www.opensolaris.org/os/licensing.

    10  * See the License for the specific language governing permissions

    11  * and limitations under the License.

    12  *

    13  * When distributing Covered Code, include this CDDL HEADER in each

    14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

    15  * If applicable, add the following below this CDDL HEADER, with the

    16  * fields enclosed by brackets "[]" replaced with your own identifying

    17  * information: Portions Copyright [yyyy] [name of copyright owner]

    18  *

    19  * CDDL HEADER END

    20  */

    21 

    22 /*

    23  * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.

    24  */

    25 

    26 package com.oracle.solaris.vp.util.swing.tree;

    27 

    28 import java.util.Comparator;

    29 import javax.swing.event.*;

    30 import javax.swing.table.*;

    31 import javax.swing.tree.*;

    32 import com.oracle.solaris.vp.util.common.propinfo.PropInfo;

    33 import com.oracle.solaris.vp.util.swing.propinfo.SwingPropInfo;

    34 

    35 @SuppressWarnings({"serial"})

    36 public abstract class AbstractTreeTableModel extends DefaultTreeModel

    37     implements TreeTableModel, TreeModelListener {

    38 

    39     //

    40     // Instance data

    41     //

    42 

    43     private PropInfo<?, ?>[] props;

    44 

    45     //

    46     // Constructors

    47     //

    48 

    49     public AbstractTreeTableModel(TreeNode root, PropInfo<?, ?>[] props) {

    50 	super(root);

    51 	this.props = props;

    52     }

    53 

    54     public AbstractTreeTableModel(TreeNode root, boolean asksAllowsChildren,

    55 	PropInfo<?, ?>[] props) {

    56 

    57 	super(root, asksAllowsChildren);

    58 	this.props = props;

    59     }

    60 

    61     //

    62     // TreeModel methods

    63     //

    64 

    65     @Override

    66     public TreeNode getRoot() {

    67 	return (TreeNode)super.getRoot();

    68     }

    69 

    70     //

    71     // TreeTableModel methods

    72     //

    73 

    74     @Override

    75     public Class<?> getColumnClass(int column) {

    76 	TreeNode root = getRoot();

    77 	try {

    78 	    return getValueAt(root, column).getClass();

    79 	}

    80 

    81 	// Most likely NullPointerException

    82 	catch (Throwable e) {

    83 	    return Object.class;

    84 	}

    85     }

    86 

    87     @Override

    88     public int getColumnCount() {

    89 	return props == null ? 0 : props.length;

    90     }

    91 

    92     @Override

    93     public String getColumnName(int column) {

    94 	return props[column].getLabel();

    95     }

    96 

    97     @Override

    98     @SuppressWarnings({"unchecked"})

    99     public Object getValueAt(TreeNode node, int column) {

   100 	Object o = getUserObject(node);

   101 	PropInfo prop = props[column];

   102 	return prop.getValue(o);

   103     }

   104 

   105     @Override

   106     @SuppressWarnings({"unchecked"})

   107     public boolean isCellEditable(TreeNode node, int column) {

   108 	Object o = getUserObject(node);

   109 	PropInfo prop = props[column];

   110 	return prop.isEditable(o);

   111     }

   112 

   113     @Override

   114     public boolean isTreeColumn(int column) {

   115 	return column == 0;

   116     }

   117 

   118     @Override

   119     @SuppressWarnings({"unchecked"})

   120     public void setValueAt(Object value, TreeNode node, int column) {

   121 	Object o = getUserObject(node);

   122 	PropInfo prop = props[column];

   123 	prop.setValue(o, value);

   124     }

   125 

   126     //

   127     // AbstractTreeTableModel methods

   128     //

   129 

   130     public Comparator<?> getComparator(int column) {

   131 	return props[column].getComparator();

   132     }

   133 

   134     public PropInfo<?, ?>[] getPropInfos() {

   135 	return props;

   136     }

   137 

   138     public TableCellEditor getTableCellEditor(int column) {

   139 	TableCellEditor editor = null;

   140 

   141 	PropInfo prop = props[column];

   142 	if (prop instanceof SwingPropInfo) {

   143 	    editor = ((SwingPropInfo)prop).getTableCellEditor();

   144 	}

   145 

   146 	return editor;

   147     }

   148 

   149     public TableCellRenderer getTableCellRenderer(int column) {

   150 	TableCellRenderer renderer = null;

   151 

   152 	PropInfo prop = props[column];

   153 	if (prop instanceof SwingPropInfo) {

   154 	    renderer = ((SwingPropInfo)prop).getTableCellRenderer();

   155 	}

   156 

   157 	return renderer;

   158     }

   159 

   160     protected abstract Object getUserObject(TreeNode node);

   161 

   162     //

   163     // TreeModelListener methods

   164     //

   165 

   166     /**

   167      * Propagates the given event to registered listeners.

   168      */

   169     @Override

   170     public void treeNodesChanged(TreeModelEvent e) {

   171 	TreeModelListener[] listeners = getTreeModelListeners();

   172 	for (int i = 0; i < listeners.length; i++) {

   173 	    listeners[i].treeNodesChanged(e);

   174 	}

   175     }

   176 

   177     /**

   178      * Propagates the given event to registered listeners.

   179      */

   180     @Override

   181     public void treeNodesInserted(TreeModelEvent e) {

   182 	TreeModelListener[] listeners = getTreeModelListeners();

   183 	for (int i = 0; i < listeners.length; i++) {

   184 	    listeners[i].treeNodesInserted(e);

   185 	}

   186     }

   187 

   188     /**

   189      * Propagates the given event to registered listeners.

   190      */

   191     @Override

   192     public void treeNodesRemoved(TreeModelEvent e) {

   193 	TreeModelListener[] listeners = getTreeModelListeners();

   194 	for (int i = 0; i < listeners.length; i++) {

   195 	    listeners[i].treeNodesRemoved(e);

   196 	}

   197     }

   198 

   199     /**

   200      * Propagates the given event to registered listeners.

   201      */

   202     @Override

   203     public void treeStructureChanged(TreeModelEvent e) {

   204 	TreeModelListener[] listeners = getTreeModelListeners();

   205 	for (int i = 0; i < listeners.length; i++) {

   206 	    listeners[i].treeStructureChanged(e);

   207 	}

   208     }

   209 }