| Frames | No Frames |
1: /* AbstractLayoutCache.java -- 2: Copyright (C) 2002, 2004, 2006, Free Software Foundation, Inc. 3: 4: This file is part of GNU Classpath. 5: 6: GNU Classpath is free software; you can redistribute it and/or modify 7: it under the terms of the GNU General Public License as published by 8: the Free Software Foundation; either version 2, or (at your option) 9: any later version. 10: 11: GNU Classpath is distributed in the hope that it will be useful, but 12: WITHOUT ANY WARRANTY; without even the implied warranty of 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14: General Public License for more details. 15: 16: You should have received a copy of the GNU General Public License 17: along with GNU Classpath; see the file COPYING. If not, write to the 18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 19: 02110-1301 USA. 20: 21: Linking this library statically or dynamically with other modules is 22: making a combined work based on this library. Thus, the terms and 23: conditions of the GNU General Public License cover the whole 24: combination. 25: 26: As a special exception, the copyright holders of this library give you 27: permission to link this library with independent modules to produce an 28: executable, regardless of the license terms of these independent 29: modules, and to copy and distribute the resulting executable under 30: terms of your choice, provided that you also meet, for each linked 31: independent module, the terms and conditions of the license of that 32: module. An independent module is a module which is not derived from 33: or based on this library. If you modify this library, you may extend 34: this exception to your version of the library, but you are not 35: obligated to do so. If you do not wish to do so, delete this 36: exception statement from your version. */ 37: 38: 39: package javax.swing.tree; 40: 41: import java.awt.Rectangle; 42: import java.util.Enumeration; 43: 44: import javax.swing.event.TreeModelEvent; 45: 46: /** 47: * class AbstractLayoutCache 48: * 49: * @author Andrew Selkirk 50: */ 51: public abstract class AbstractLayoutCache 52: implements RowMapper 53: { 54: /** 55: * class NodeDimensions 56: */ 57: public abstract static class NodeDimensions 58: { 59: /** 60: * Creates <code>NodeDimensions</code> object. 61: */ 62: public NodeDimensions() 63: { 64: // Do nothing here. 65: } 66: 67: /** 68: * Get the node dimensions. The NodeDimensions property must be set (unless 69: * the method is overridden, like if {@link FixedHeightLayoutCache}. If the 70: * method is not overridden and the property is not set, the InternalError is 71: * thrown. 72: * 73: * @param value the last node in the path 74: * @param row the node row 75: * @param depth the indentation depth 76: * @param expanded true if this node is expanded, false otherwise 77: * @param bounds the area where the tree is displayed 78: */ 79: public abstract Rectangle getNodeDimensions(Object value, int row, 80: int depth, boolean expanded, 81: Rectangle bounds); 82: } 83: 84: /** 85: * nodeDimensions 86: */ 87: protected NodeDimensions nodeDimensions; 88: 89: /** 90: * treeModel 91: */ 92: protected TreeModel treeModel; 93: 94: /** 95: * treeSelectionModel 96: */ 97: protected TreeSelectionModel treeSelectionModel; 98: 99: /** 100: * rootVisible 101: */ 102: protected boolean rootVisible; 103: 104: /** 105: * rowHeight 106: */ 107: protected int rowHeight; 108: 109: /** 110: * Constructor AbstractLayoutCache 111: */ 112: public AbstractLayoutCache() 113: { 114: // Do nothing here. 115: } 116: 117: /** 118: * setNodeDimensions 119: * 120: * @param dimensions TODO 121: */ 122: public void setNodeDimensions(NodeDimensions dimensions) 123: { 124: nodeDimensions = dimensions; 125: } 126: 127: /** 128: * getNodeDimensions 129: * 130: * @return NodeDimensions 131: */ 132: public NodeDimensions getNodeDimensions() 133: { 134: return nodeDimensions; 135: } 136: 137: /** 138: * Get the node dimensions. The NodeDimensions property must be set 139: * (unless the method is overridden, like if 140: * {@link FixedHeightLayoutCache}. If the method is not overridden and 141: * the property is not set, the InternalError is thrown. 142: * 143: * @param value the last node in the path 144: * @param row the node row 145: * @param depth the indentation depth 146: * @param expanded true if this node is expanded, false otherwise 147: * @param bounds the area where the tree is displayed 148: */ 149: protected Rectangle getNodeDimensions(Object value, int row, int depth, 150: boolean expanded, Rectangle bounds) 151: { 152: Rectangle d = null; 153: if (nodeDimensions != null) 154: d = nodeDimensions.getNodeDimensions(value, row, depth, expanded, 155: bounds); 156: return d; 157: } 158: 159: /** 160: * Sets the model that provides the tree data. 161: * 162: * @param model the model 163: */ 164: public void setModel(TreeModel model) 165: { 166: treeModel = model; 167: } 168: 169: /** 170: * Returns the model that provides the tree data. 171: * 172: * @return the model 173: */ 174: public TreeModel getModel() 175: { 176: return treeModel; 177: } 178: 179: /** 180: * setRootVisible 181: * 182: * @param visible <code>true</code> if root should be visible, 183: * <code>false</code> otherwise 184: */ 185: public void setRootVisible(boolean visible) 186: { 187: rootVisible = visible; 188: } 189: 190: /** 191: * isRootVisible 192: * 193: * @return <code>true</code> if root is visible, 194: * <code>false</code> otherwise 195: */ 196: public boolean isRootVisible() 197: { 198: return rootVisible; 199: } 200: 201: /** 202: * setRowHeight 203: * 204: * @param height the row height 205: */ 206: public void setRowHeight(int height) 207: { 208: rowHeight = height; 209: invalidateSizes(); 210: } 211: 212: /** 213: * getRowHeight 214: * 215: * @return the row height 216: */ 217: public int getRowHeight() 218: { 219: return rowHeight; 220: } 221: 222: /** 223: * setSelectionModel 224: * 225: * @param model the model 226: */ 227: public void setSelectionModel(TreeSelectionModel model) 228: { 229: if (treeSelectionModel != null) 230: treeSelectionModel.setRowMapper(null); 231: treeSelectionModel = model; 232: if (treeSelectionModel != null) 233: treeSelectionModel.setRowMapper(this); 234: 235: } 236: 237: /** 238: * getSelectionModel 239: * 240: * @return the model 241: */ 242: public TreeSelectionModel getSelectionModel() 243: { 244: return treeSelectionModel; 245: } 246: 247: /** 248: * Get the sum of heights for all rows. This class provides a general not 249: * optimized implementation that is overridded in derived classes 250: * ({@link VariableHeightLayoutCache}, {@link FixedHeightLayoutCache}) for 251: * the better performance. 252: */ 253: public int getPreferredHeight() 254: { 255: int height = 0; 256: int n = getRowCount(); 257: Rectangle r = new Rectangle(); 258: for (int i = 0; i < n; i++) 259: { 260: TreePath path = getPathForRow(i); 261: height += getBounds(path, r).height; 262: } 263: return height; 264: } 265: 266: /** 267: * Get the maximal width. This class provides a general not 268: * optimized implementation that is overridded in derived classes 269: * ({@link VariableHeightLayoutCache}, {@link FixedHeightLayoutCache}) for 270: * the better performance. 271: * 272: * @param rect the rectangle that is used during the method work 273: */ 274: public int getPreferredWidth(Rectangle rect) 275: { 276: int maximalWidth = 0; 277: Rectangle r = new Rectangle(); 278: int n = getRowCount(); 279: for (int i = 0; i < n; i++) 280: { 281: TreePath path = getPathForRow(i); 282: r.setBounds(0, 0, 0, 0); 283: r = getBounds(path, r); 284: if (r.x + r.width > maximalWidth) 285: maximalWidth = r.x + r.width; 286: // Invalidate the cached value as this may be the very early call 287: // before the heigth is properly set (the vertical coordinate may 288: // not be correct). 289: invalidatePathBounds(path); 290: } 291: return maximalWidth; 292: } 293: /** 294: * isExpanded 295: * 296: * @param value0 TODO 297: * 298: * @return boolean 299: */ 300: public abstract boolean isExpanded(TreePath value0); 301: 302: /** 303: * getBounds 304: * 305: * @param value0 TODO 306: * @param value1 TODO 307: * 308: * @return Rectangle 309: */ 310: public abstract Rectangle getBounds(TreePath value0, Rectangle value1); 311: 312: /** 313: * getPathForRow 314: * 315: * @param row the row 316: * 317: * @return the tree path 318: */ 319: public abstract TreePath getPathForRow(int row); 320: 321: /** 322: * getRowForPath 323: * 324: * @param path the tree path 325: * 326: * @return the row 327: */ 328: public abstract int getRowForPath(TreePath path); 329: 330: /** 331: * getPathClosestTo 332: * 333: * @param value0 TODO 334: * @param value1 TODO 335: * 336: * @return the tree path 337: */ 338: public abstract TreePath getPathClosestTo(int value0, int value1); 339: 340: /** 341: * getVisiblePathsFrom 342: * 343: * @param path the tree path 344: * 345: * @return Enumeration 346: */ 347: public abstract Enumeration<TreePath> getVisiblePathsFrom(TreePath path); 348: 349: /** 350: * getVisibleChildCount 351: * 352: * @param path the tree path 353: * 354: * @return int 355: */ 356: public abstract int getVisibleChildCount(TreePath path); 357: 358: /** 359: * setExpandedState 360: * 361: * @param value0 TODO 362: * 363: * @param value1 TODO 364: */ 365: public abstract void setExpandedState(TreePath value0, boolean value1); 366: 367: /** 368: * getExpandedState 369: * 370: * @param path the tree path 371: * 372: * @return boolean 373: */ 374: public abstract boolean getExpandedState(TreePath path); 375: 376: /** 377: * getRowCount 378: * 379: * @return the number of rows 380: */ 381: public abstract int getRowCount(); 382: 383: /** 384: * invalidateSizes 385: */ 386: public abstract void invalidateSizes(); 387: 388: /** 389: * invalidatePathBounds 390: * 391: * @param path the tree path 392: */ 393: public abstract void invalidatePathBounds(TreePath path); 394: 395: /** 396: * treeNodesChanged 397: * 398: * @param event the event to send 399: */ 400: public abstract void treeNodesChanged(TreeModelEvent event); 401: 402: /** 403: * treeNodesInserted 404: * 405: * @param event the event to send 406: */ 407: public abstract void treeNodesInserted(TreeModelEvent event); 408: 409: /** 410: * treeNodesRemoved 411: * 412: * @param event the event to send 413: */ 414: public abstract void treeNodesRemoved(TreeModelEvent event); 415: 416: /** 417: * treeStructureChanged 418: * 419: * @param event the event to send 420: */ 421: public abstract void treeStructureChanged(TreeModelEvent event); 422: 423: /** 424: * Get the tree row numbers for the given pathes. This method performs 425: * the "bulk" conversion that may be faster than mapping pathes one by 426: * one. To have the benefit from the bulk conversion, the method must be 427: * overridden in the derived classes. The default method delegates work 428: * to the {@link #getRowForPath(TreePath)}. 429: * 430: * @param paths the tree paths the array of the tree pathes. 431: * @return the array of the matching tree rows. 432: */ 433: public int[] getRowsForPaths(TreePath[] paths) 434: { 435: int[] rows = null; 436: if (paths != null) 437: { 438: rows = new int[paths.length]; 439: for (int i = 0; i < rows.length; i++) 440: rows[i] = getRowForPath(paths[i]); 441: } 442: return rows; 443: } 444: 445: /** 446: * Returns true if this layout supposes that all rows have the fixed 447: * height. 448: * 449: * @return boolean true if all rows in the tree must have the fixed 450: * height (false by default). 451: */ 452: protected boolean isFixedRowHeight() 453: { 454: return rowHeight > 0; 455: } 456: }