home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 November / Chip_1998-11_cd.bin / tema / Cafe / jfc.bin / MetalTreeUI.java < prev    next >
Text File  |  1998-02-26  |  7KB  |  215 lines
  1. /*
  2.  * @(#)MetalTreeUI.java    1.7 98/02/06
  3.  * 
  4.  * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not
  8.  * disclose such Confidential Information and shall use it only in
  9.  * accordance with the terms of the license agreement you entered into
  10.  * with Sun.
  11.  * 
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  15.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  16.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  17.  * THIS SOFTWARE OR ITS DERIVATIVES.
  18.  * 
  19.  */
  20.  
  21. package com.sun.java.swing.plaf.metal;
  22.  
  23. import com.sun.java.swing.*;
  24. import com.sun.java.swing.event.*;
  25. import com.sun.java.swing.text.DefaultTextUI;
  26. import java.awt.*;
  27. import java.awt.event.*;
  28. import java.beans.*;
  29. import java.io.*;
  30. import java.util.*;
  31. import com.sun.java.swing.plaf.*;
  32. import com.sun.java.swing.tree.*;
  33.  
  34. import com.sun.java.swing.plaf.basic.*;
  35.  
  36. /**
  37.  * MetalTreeUI supports the client property "value-add" system of customization
  38.  * It uses it to determine what style of line to draw.  There are three choices.
  39.  * The default choice is a set of horiontal lines next to each root node.
  40.  * Also available is a more variant with angled legs running from parent to child.
  41.  * Lastly you can choose no lines at all.  Here is some code to turn on angled legs.
  42.  * 
  43.  *     tree.putClientProperty("JTree.lineStyle", "Angled");
  44.  * 
  45.  * Here is some code to turn off lines all together.
  46.  * 
  47.  *     tree.putClientProperty("JTree.lineStyle", "None");
  48.  *
  49.  * Also if you've used one of these options, and want to return to the default
  50.  * horizontal line style you can use the following.
  51.  *
  52.  *     tree.putClientProperty("JTree.lineStyle", "Horizontal");
  53.  *
  54.  * <p>
  55.  * Warning: serialized objects of this class will not be compatible with
  56.  * future swing releases.  The current serialization support is appropriate
  57.  * for short term storage or RMI between Swing1.0 applications.  It will
  58.  * not be possible to load serialized Swing1.0 objects with future releases
  59.  * of Swing.  The JDK1.2 release of Swing will be the compatibility
  60.  * baseline for the serialized form of Swing objects.
  61.  *
  62.  * @version 1.7 02/06/98
  63.  * @author Tom Santos
  64.  * @author Steve Wilson (value add stuff)
  65.  */
  66. public class MetalTreeUI extends BasicTreeUI {
  67.  
  68.     private static Color lineColor;
  69.   
  70.     private static final String LINE_STYLE = "JTree.lineStyle";
  71.  
  72.     private static final String LEG_LINE_STYLE_STRING = "Angled";
  73.     private static final String HORIZ_STYLE_STRING = "Horizontal";
  74.     private static final String NO_STYLE_STRING = "None";
  75.  
  76.     private static final int LEG_LINE_STYLE = 2; 
  77.     private static final int HORIZ_LINE_STYLE = 1;
  78.     private static final int NO_LINE_STYLE = 0;
  79.  
  80.     private int lineStyle = HORIZ_LINE_STYLE;
  81.     private PropertyChangeListener lineStyleListener = new LineListener();
  82.  
  83.     // Boilerplate
  84.     public static ComponentUI createUI(JComponent x) {
  85.     return new MetalTreeUI();
  86.     }
  87.  
  88.     public MetalTreeUI()
  89.     {
  90.     super();
  91.     }
  92.  
  93.     protected int getHorizontalLegBuffer()
  94.       {
  95.     return 4;
  96.       } 
  97.  
  98.     public void installUI( JComponent c ) {
  99.         super.installUI( c );
  100.     if ( !tree.isLargeModel() ) {
  101.         setRowHeight( 0 );
  102.     }
  103.     lineColor = UIManager.getColor( "Tree.line" );
  104.  
  105.     Object lineStyleFlag = c.getClientProperty( LINE_STYLE );
  106.     decodeLineStyle(lineStyleFlag);
  107.     c.addPropertyChangeListener(lineStyleListener);
  108.  
  109.     }
  110.  
  111.     public void uninstallUI( JComponent c) {
  112.          c.removePropertyChangeListener(lineStyleListener);
  113.      super.uninstallUI(c);
  114.     }
  115.  
  116.     /** this function converts between the string passed into the client property
  117.       * and the internal representation (currently and int)
  118.       *
  119.       */
  120.     protected void decodeLineStyle(Object lineStyleFlag) {
  121.       if ( lineStyleFlag == null || lineStyleFlag.equals(HORIZ_STYLE_STRING) ){
  122.     lineStyle = HORIZ_LINE_STYLE; // default case
  123.       } else {
  124.       if ( lineStyleFlag.equals(LEG_LINE_STYLE_STRING) ) {
  125.           lineStyle = LEG_LINE_STYLE;
  126.       } else if ( lineStyleFlag.equals(NO_STYLE_STRING) ) {
  127.           lineStyle = NO_LINE_STYLE;
  128.       }
  129.       }
  130.  
  131.     }
  132.     protected boolean clickedInExpandControl( VisibleTreeNode node, LargeTreeModelNode eNode,
  133.                           int row, int rowLevel, int mouseX, int mouseY )
  134.       {
  135.     if ( node != null && node.isLeaf() )
  136.       {
  137.         return false;
  138.       }
  139.  
  140.     int                     boxWidth;
  141.  
  142.     if(getExpandedIcon() != null)
  143.         boxWidth = getExpandedIcon().getIconWidth() + 6;
  144.     else
  145.         boxWidth = 8;
  146.     int    boxLeftX;
  147.     if(this.getShowsRootHandles())
  148.         boxLeftX = ((rowLevel * totalChildIndent) +
  149.             getLeftChildIndent()) - boxWidth/2;
  150.     else
  151.         boxLeftX = (((rowLevel - 1) * totalChildIndent) +
  152.             getLeftChildIndent()) - boxWidth/2;
  153.     int boxRightX = boxLeftX + boxWidth;
  154.     
  155.     return mouseX >= boxLeftX && mouseX <= boxRightX;
  156.       }
  157.  
  158.  
  159.     public void paint(Graphics g, JComponent c) {
  160.         super.paint( g, c );
  161.  
  162.  
  163.     // Paint the lines
  164.     if (lineStyle == HORIZ_LINE_STYLE) {
  165.         paintHorizontalSeparators(g,c);
  166.     }
  167.     }
  168.  
  169.     protected void paintHorizontalSeparators(Graphics g, JComponent c) {
  170.         g.setColor( lineColor );
  171.  
  172.     Rectangle clipBounds = g.getClipBounds();
  173.     int beginRow = getRowContainingYLocation( clipBounds.y );
  174.     int endRow = getRowContainingYLocation( clipBounds.y + (clipBounds.height - 1) );
  175.  
  176.     if ( beginRow <= -1 || endRow <= -1 ) {
  177.         return;
  178.     }
  179.  
  180.     for ( int i = beginRow; i <= endRow; ++i ) {
  181.         VisibleTreeNode node = getNode( i );
  182.         if ( node.getParent() == node.getRoot() ) {
  183.             // Draw a line at the top
  184.             g.drawLine( clipBounds.x, getNodeY( node ),
  185.                 clipBounds.x + clipBounds.width, getNodeY( node ) );
  186.         }
  187.     }
  188.  
  189.     }
  190.  
  191.     public void drawVerticalPartOfLeg( Graphics g, JComponent c, int depth, int parentY, int childY,
  192.                        int parentRowHeight, int childRowHeight ) {
  193.     if (lineStyle == LEG_LINE_STYLE) {
  194.         super.drawVerticalPartOfLeg( g, c, depth, parentY, childY, parentRowHeight, childRowHeight);
  195.     }
  196.     }
  197.  
  198.     public void drawHorizontalPartOfLeg( Graphics g, JComponent c, int lineY, int leftX, int rightX  ) {
  199.     if (lineStyle == LEG_LINE_STYLE) {
  200.         super.drawHorizontalPartOfLeg( g, c, lineY, leftX, rightX);
  201.     }
  202.     }
  203.  
  204.     /** This class listens for changes in line style */
  205.     class LineListener implements PropertyChangeListener, java.io.Serializable {
  206.         public void propertyChange(PropertyChangeEvent e) {
  207.         String name = e.getPropertyName();
  208.         if ( name.equals( LINE_STYLE ) ) {
  209.             decodeLineStyle(e.getNewValue());
  210.         }
  211.     }
  212.     } // end class PaletteListener
  213.  
  214. }
  215.