Java AbstractLayoutCache类代码示例

import javax.swing.tree.AbstractLayoutCache; //导入依赖的package包/类
/** 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);
    }
}
 

import javax.swing.tree.AbstractLayoutCache; //导入依赖的package包/类
@Override
protected AbstractLayoutCache.NodeDimensions createNodeDimensions() {
    return new NodeDimensionsHandler() {
        @Override
        public Rectangle getNodeDimensions(
                Object value, int row, int depth, boolean expanded, Rectangle size) {

            Rectangle dimensions = super.getNodeDimensions(value, row, depth, expanded, size);
            int containerWidth = tree.getParent() instanceof JViewport
                    ? tree.getParent().getWidth() : tree.getWidth();

            dimensions.width = containerWidth - getRowX(row, depth);

            return dimensions;
        }
    };
}
 

import javax.swing.tree.AbstractLayoutCache; //导入依赖的package包/类
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 new ImageIcon(image);
}
 

import javax.swing.tree.AbstractLayoutCache; //导入依赖的package包/类
/** 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;
    }
}
 

import javax.swing.tree.AbstractLayoutCache; //导入依赖的package包/类
/** 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);
}
 

import javax.swing.tree.AbstractLayoutCache; //导入依赖的package包/类
/**
    * Sets <CODE>aligner</CODE> as the
    * <CODE>AbstractLayoutCache</CODE> to be used
    * to align nodes, or null to disable
    * node alignment
    *
    * @param aligner <CODE>AbstractLayoutCache</CODE> to be
    * used to align nodes, or null to disable node alignment
    */
   public synchronized void setAligner(AbstractLayoutCache aligner)
   {
if(this.aligner == aligner)
    return;

this.aligner = aligner;
if(aligner != null && mapper == null) {
    TreeModel model = aligner.getModel();
    if(model instanceof NodeMapper)
	setMapper((NodeMapper)model);
}
   }
 

import javax.swing.tree.AbstractLayoutCache; //导入依赖的package包/类
protected AbstractLayoutCache createLayoutCache()
   {
if(isLargeModel() && getRowHeight() > 0)
    return new AlignableFixedHeightLayoutCache(this);

return new AlignableVariableHeightLayoutCache(this);
   }
 

import javax.swing.tree.AbstractLayoutCache; //导入依赖的package包/类
protected AbstractLayoutCache createLayoutCache()
   {
if(isLargeModel() && getRowHeight() > 0) {
    return new AlignableFixedHeightLayoutCache(this);
}

return new AlignableVariableHeightLayoutCache(this);
   }
 

import javax.swing.tree.AbstractLayoutCache; //导入依赖的package包/类
@Override
protected AbstractLayoutCache.NodeDimensions createNodeDimensions() {
  return new NodeDimensionsHandler() {
    @Override
    public Rectangle getNodeDimensions(Object value, int row, int depth, boolean expanded, Rectangle size) {
      Rectangle dimensions = super.getNodeDimensions(value, row, depth, expanded, size);
      dimensions.width = tree.getWidth() - getRowX(row, depth);
      return dimensions;
    }
  };
}
 

import javax.swing.tree.AbstractLayoutCache; //导入依赖的package包/类
@Override
protected AbstractLayoutCache.NodeDimensions createNodeDimensions() {
	return new NodeDimensionsHandler() {
		@Override
		public Rectangle getNodeDimensions(Object value, int row, int depth, boolean expanded, Rectangle size) {
			Rectangle dimensions = super.getNodeDimensions(value, row, depth, expanded, size);
			dimensions.width = parent.getWidth() - getRowX(row, depth);
			return dimensions;
		}
	};
}
 

import javax.swing.tree.AbstractLayoutCache; //导入依赖的package包/类
@Override
/**
 * Creates an instance of NodeDimensions that is able to determine
 * the size of a given node in the tree.
 */
protected AbstractLayoutCache.NodeDimensions createNodeDimensions() {
	return new PNNodeDimensionsHandler();
}
 

import javax.swing.tree.AbstractLayoutCache; //导入依赖的package包/类
@Override
protected AbstractLayoutCache.NodeDimensions createNodeDimensions() {
  return new NodeDimensionsHandler() {
    @Override
    public Rectangle getNodeDimensions(Object value, int row, int depth, boolean expanded, Rectangle size) {
      Rectangle dimensions = super.getNodeDimensions(value, row, depth, expanded, size);
      Insets insets = tree.getInsets();
      dimensions.width = tree.getWidth() - getRowX(row, depth) - insets.left - insets.right;
      return dimensions;
    }
  };
}
 

import javax.swing.tree.AbstractLayoutCache; //导入依赖的package包/类
@Override
public final AbstractLayoutCache getLayout() {
    return layout;
}
 

import javax.swing.tree.AbstractLayoutCache; //导入依赖的package包/类
/** Convenience getter for the proxied model's layout cache */
private AbstractLayoutCache getLayout() {
    return getModel().getLayout();
}
 

import javax.swing.tree.AbstractLayoutCache; //导入依赖的package包/类
/** Creates a new instance of TreePathSupport */
public TreePathSupport(OutlineModel mdl, AbstractLayoutCache layout) {
    this.layout = layout;
}