Source for javax.swing.tree.AbstractLayoutCache

   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: }