libjava/javax/swing/tree/AbstractLayoutCache.java

   1 /* AbstractLayoutCache.java --
   2    Copyright (C) 2002, 2004  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., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 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 implements RowMapper
  52 {
  53         /**
  54          * class NodeDimensions
  55          */
  56         public abstract static class NodeDimensions
  57         {
  58                 /**
  59                  * Creates <code>NodeDimensions</code> object.
  60                  */
  61                 public NodeDimensions()
  62                 {
  63                         // Do nothing here.
  64                 }
  65
  66                 /**
  67                  * getNodeDimensions
  68                  *
  69                  * @param value0 TODO
  70                  * @param value1 TODO
  71                  * @param value2 TODO
  72                  * @param value3 TODO
  73                  * @param value4 TODO
  74                  * @return Rectangle
  75                  */
  76                 public abstract Rectangle getNodeDimensions(Object value0, int value1,
  77                                                             int value2, boolean value3,
  78                                                             Rectangle value4);
  79         }
  80
  81         /**
  82          * nodeDimensions
  83          */
  84         protected NodeDimensions nodeDimensions;
  85
  86         /**
  87          * treeModel
  88          */
  89         protected TreeModel treeModel;
  90
  91         /**
  92          * treeSelectionModel
  93          */
  94         protected TreeSelectionModel treeSelectionModel;
  95
  96         /**
  97          * rootVisible
  98          */
  99         protected boolean rootVisible;
 100
 101         /**
 102          * rowHeight
 103          */
 104         protected int rowHeight;
 105
 106         /**
 107          * Constructor AbstractLayoutCache
 108          */
 109         public AbstractLayoutCache()
 110         {
 111           // Do nothing here.
 112         }
 113
 114         /**
 115          * setNodeDimensions
 116          *
 117          * @param dimensions TODO
 118          */
 119         public void setNodeDimensions(NodeDimensions dimensions)
 120         {
 121                 nodeDimensions = dimensions;
 122         }
 123
 124         /**
 125          * getNodeDimensions
 126          *
 127          * @return NodeDimensions
 128          */
 129         public NodeDimensions getNodeDimensions()
 130         {
 131                 return nodeDimensions;
 132         }
 133
 134         /**
 135          * getNodeDimensions
 136          *
 137          * @param value0 TODO
 138          * @param value1 TODO
 139          * @param value2 TODO
 140          * @param value3 TODO
 141          * @param value4 TODO
 142          *
 143          * @return Rectangle
 144          */
 145         protected Rectangle getNodeDimensions(Object value0, int value1, int value2, boolean value3, Rectangle value4)
 146         {
 147                 return null; // TODO
 148         }
 149
 150         /**
 151          * Sets the model that provides the tree data.
 152          *
 153          * @param the model
 154          */
 155         public void setModel(TreeModel model)
 156         {
 157           treeModel = model;
 158         }
 159
 160         /**
 161          * Returns the model that provides the tree data.
 162          *
 163          * @return the model
 164          */
 165         public TreeModel getModel()
 166         {
 167                 return treeModel;
 168         }
 169
 170         /**
 171          * setRootVisible
 172          *
 173          * @param visible <code>true</code> if root should be visible,
 174          * <code>false</code> otherwise
 175          */
 176         public void setRootVisible(boolean visible)
 177         {
 178                 rootVisible = visible;
 179         }
 180
 181         /**
 182          * isRootVisible
 183          *
 184          * @return <code>true</code> if root is visible,
 185          * <code>false</code> otherwise
 186          */
 187         public boolean isRootVisible()
 188         {
 189                 return rootVisible;
 190         }
 191
 192         /**
 193          * setRowHeight
 194          *
 195          * @param height the row height
 196          */
 197         public void setRowHeight(int height)
 198         {
 199                 rowHeight = height;
 200         }
 201
 202         /**
 203          * getRowHeight
 204          *
 205          * @return the row height
 206          */
 207         public int getRowHeight()
 208         {
 209                 return rowHeight;
 210         }
 211
 212         /**
 213          * setSelectionModel
 214          *
 215          * @param model the model
 216          */
 217         public void setSelectionModel(TreeSelectionModel model)
 218         {
 219                 treeSelectionModel = model;
 220         }
 221
 222         /**
 223          * getSelectionModel
 224          *
 225          * @return the model
 226          */
 227         public TreeSelectionModel getSelectionModel()
 228         {
 229                 return treeSelectionModel;
 230         }
 231
 232         /**
 233          * getPreferredHeight
 234          *
 235          * @return int
 236          */
 237         public int getPreferredHeight()
 238         {
 239                 return 0; // TODO
 240         }
 241
 242         /**
 243          * getPreferredWidth
 244          *
 245          * @param value0 TODO
 246          *
 247          * @return int
 248          */
 249         public int getPreferredWidth(Rectangle value0)
 250         {
 251                 return 0; // TODO
 252         }
 253
 254         /**
 255          * isExpanded
 256          *
 257          * @param value0 TODO
 258          *
 259          * @return boolean
 260          */
 261         public abstract boolean isExpanded(TreePath value0);
 262
 263         /**
 264          * getBounds
 265          *
 266          * @param value0 TODO
 267          * @param value1 TODO
 268          *
 269          * @return Rectangle
 270          */
 271         public abstract Rectangle getBounds(TreePath value0, Rectangle value1);
 272
 273         /**
 274          * getPathForRow
 275          *
 276          * @param row the row
 277          *
 278          * @return the tree path
 279          */
 280         public abstract TreePath getPathForRow(int row);
 281
 282         /**
 283          * getRowForPath
 284          *
 285          * @param path the tree path
 286          *
 287          * @return the row
 288          */
 289         public abstract int getRowForPath(TreePath path);
 290
 291         /**
 292          * getPathClosestTo
 293          *
 294          * @param value0 TODO
 295          * @param value1 TODO
 296          *
 297          * @return the tree path
 298          */
 299         public abstract TreePath getPathClosestTo(int value0, int value1);
 300
 301         /**
 302          * getVisiblePathsFrom
 303          *
 304          * @param path the tree path
 305          *
 306          * @return Enumeration
 307          */
 308         public abstract Enumeration getVisiblePathsFrom(TreePath path);
 309
 310         /**
 311          * getVisibleChildCount
 312          *
 313          * @param path the tree path
 314          *
 315          * @return int
 316          */
 317         public abstract int getVisibleChildCount(TreePath value0);
 318
 319         /**
 320          * setExpandedState
 321          *
 322          * @param value0 TODO
 323          *
 324          * @param value1 TODO
 325          */
 326         public abstract void setExpandedState(TreePath value0, boolean value1);
 327
 328         /**
 329          * getExpandedState
 330          *
 331          * @param path the tree path
 332          *
 333          * @return boolean
 334          */
 335         public abstract boolean getExpandedState(TreePath path);
 336
 337         /**
 338          * getRowCount
 339          *
 340          * @return the number of rows
 341          */
 342         public abstract int getRowCount();
 343
 344         /**
 345          * invalidateSizes
 346          */
 347         public abstract void invalidateSizes();
 348
 349         /**
 350          * invalidatePathBounds
 351          *
 352          * @param path the tree path
 353          */
 354         public abstract void invalidatePathBounds(TreePath path);
 355
 356         /**
 357          * treeNodesChanged
 358          *
 359          * @param event the event to send
 360          */
 361         public abstract void treeNodesChanged(TreeModelEvent event);
 362
 363         /**
 364          * treeNodesInserted
 365          *
 366          * @param event the event to send
 367          */
 368         public abstract void treeNodesInserted(TreeModelEvent event);
 369
 370         /**
 371          * treeNodesRemoved
 372          *
 373          * @param event the event to send
 374          */
 375         public abstract void treeNodesRemoved(TreeModelEvent event);
 376
 377         /**
 378          * treeStructureChanged
 379          *
 380          * @param event the event to send
 381          */
 382         public abstract void treeStructureChanged(TreeModelEvent event);
 383
 384         /**
 385          * getRowsForPaths
 386          *
 387          * @param paths the tree paths
 388          *
 389          * @return an array of rows
 390          */
 391         public int[] getRowsForPaths(TreePath[] paths)
 392         {
 393                 return null; // TODO
 394         }
 395
 396         /**
 397          * isFixedRowHeight
 398          *
 399          * @return boolean
 400          */
 401         protected boolean isFixedRowHeight()
 402         {
 403                 return false; // TODO
 404         }
 405 }