javax.swing.tree.AbstractLayoutCache Java Examples

/** Creates a new instance of DefaultOutlineModel.  <strong><b>Note</b> 
 * Do not fire table structure changes from the wrapped TableModel (value
 * changes are okay).  Changes that affect the number of rows must come
 * from the TreeModel.
 * @param treeModel The tree model
 * @param tableModel The table model
 * @param largeModel <code>true</code> if it's a large model tree, <code>false</code> otherwise.
 * @param nodesColumnLabel Label of the node's column
 */
protected DefaultOutlineModel(TreeModel treeModel, TableModel tableModel, boolean largeModel, String nodesColumnLabel) {
    this.treeModel = treeModel;
    this.tableModel = tableModel;
    if (nodesColumnLabel != null) {
        this.nodesColumnLabel = nodesColumnLabel;
    }
    
    layout = largeModel ? (AbstractLayoutCache) new FixedHeightLayoutCache() 
        : (AbstractLayoutCache) new VariableHeightLayoutCache();
        
    broadcaster = new EventBroadcaster (this);
    
    layout.setRootVisible(true);
    layout.setModel(this);
    treePathSupport = new TreePathSupport(this, layout);
    treePathSupport.addTreeExpansionListener(broadcaster);
    treePathSupport.addTreeWillExpandListener(broadcaster);
    treeModel.addTreeModelListener(broadcaster);
    tableModel.addTableModelListener(broadcaster);
    if (tableModel instanceof ProxyTableModel) {
        ((ProxyTableModel) tableModel).setOutlineModel(this);
    }
}
 

@Override
protected AbstractLayoutCache.NodeDimensions createNodeDimensions() {
  return new NodeDimensionsHandler() {
    @Override
    public Rectangle getNodeDimensions(final Object value, final int row, final int depth, final boolean expanded, final Rectangle size) {
      final JViewport port = (JViewport) treeTable.getParent();
      final Rectangle dimensions = super.getNodeDimensions(value, row, depth, expanded, size);
      if (port != null) dimensions.width = port.getWidth();
      return dimensions;
    }
  };
}
 

public javax.swing.Icon getIcon(Object o) {
    if (!showIcons) {
        return emptyIcon;
    }
    Node n = Visualizer.findNode(o);
    if (n == null) {
        throw new IllegalStateException("TreeNode must be VisualizerNode but was: " + o + " of class " + o.getClass().getName());
    }
    boolean expanded = false;
    if (o instanceof TreeNode) {
        TreeNode tn = (TreeNode)o;
        ArrayList<TreeNode> al = new ArrayList<TreeNode> ();
        while (tn != null) {
            al.add(tn);
            tn = tn.getParent();
        }
        Collections.reverse(al);
        TreePath tp = new TreePath(al.toArray());
        AbstractLayoutCache layout = table.getLayoutCache();
        expanded = layout.isExpanded(tp);
    }
    java.awt.Image image = null;
    if (expanded) {
        image = n.getOpenedIcon(java.beans.BeanInfo.ICON_COLOR_16x16);
    } else {
        image = n.getIcon(java.beans.BeanInfo.ICON_COLOR_16x16);
    }
    return ImageUtilities.image2Icon(image);
}
 

/** Get the layout cache which manages layout data for the Outline.
 * <strong>Under no circumstances directly call the methods on the
 * layout cache which change the expanded state - such changes will not
 * be propagated into the table model, and will leave the model and
 * its layout in inconsistent states.  Any calls that affect expanded
 * state must go through <code>getTreePathSupport()</code>.</strong> */
public final AbstractLayoutCache getLayoutCache () {
    OutlineModel mdl = getOutlineModel();
    if (mdl != null) {
        return mdl.getLayout();
    } else {
        return null;
    }
}
 

/** Overridden to throw an exception if the passed model is not an instance
 * of <code>OutlineModel</code> (with the exception of calls from the 
 * superclass constructor) */
@Override
public void setModel (TableModel mdl) {
    if (initialized && (!(mdl instanceof OutlineModel))) {
        throw new IllegalArgumentException (
            "Table model for an Outline must be an instance of " +
            "OutlineModel"); //NOI18N
    }
    if (mdl instanceof OutlineModel) {
        AbstractLayoutCache layout = ((OutlineModel) mdl).getLayout();
        if (cachedRootVisible != null) {
            
            layout.setRootVisible(
                cachedRootVisible.booleanValue());
            
        }
        
        layout.setRowHeight(getRowHeight());
        
        if (((OutlineModel) mdl).isLargeModel()) {
            addComponentListener (getComponentListener());
            layout.setNodeDimensions(new ND());
        } else {
            if (componentListener != null) {
                removeComponentListener (componentListener);
                componentListener = null;
            }
        }
    }
    
    super.setModel(mdl);
}
 

@Override
public final AbstractLayoutCache getLayout() {
    return layout;
}
 

/** Convenience getter for the proxied model's layout cache */
private AbstractLayoutCache getLayout() {
    return getModel().getLayout();
}
 

/** Creates a new instance of TreePathSupport */
public TreePathSupport(OutlineModel mdl, AbstractLayoutCache layout) {
    this.layout = layout;
}
 

/** Get the layout cache which is used to track the visual state of nodes.
 * This is typically one of the standard JDK layout cache classes, such
 * as <code>VariableHeightLayoutCache</code> or <code>
 * FixedHeightLayoutCache</code>.  */
public AbstractLayoutCache getLayout ();
 

/**
 * Returns tree layout cache.
 *
 * @return tree layout cache
 */
@Nullable
public abstract AbstractLayoutCache getTreeLayoutCache ();