treecontrol.java

里面是关于jmf编程的例子,希望能给初学者带来一些帮助

/*
 * @(#)TreeControl.java	1.3 00/02/28
 *
 * Copyright (c) 1999 Sun Microsystems, Inc. All Rights Reserved.
 *
 * Sun grants you ("Licensee") a non-exclusive, royalty free, license to use,
 * modify and redistribute this software in source and binary code form,
 * provided that i) this copyright notice and license appear on all copies of
 * the software; and ii) Licensee does not utilize the software in a manner
 * which is disparaging to Sun.
 *
 * This software is provided "AS IS," without a warranty of any kind. ALL
 * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
 * IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
 * NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE
 * LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
 * OR DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS
 * LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT,
 * INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER
 * CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF
 * OR INABILITY TO USE SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGES.
 *
 * This software is not designed or intended for use in on-line control of
 * aircraft, air traffic, aircraft navigation or aircraft communications; or in
 * the design, construction, operation or maintenance of any nuclear
 * facility. Licensee represents and warrants that it will not use or
 * redistribute the Software for such purposes.
 */

package jmapps.ui;

import java.util.*;
import java.awt.*;
import java.awt.event.*;


public class TreeControl extends JMPanel implements ComponentListener,
                                    MouseListener, KeyListener, FocusListener,
                                    ActionListener, AdjustmentListener {

    private TreeNode    nodeRoot = null;
    private TreeNode    nodeTop = null;
    private TreeNode    nodeCurrent = null;
    private Vector      vectorTreeElList = new Vector ();
    private	boolean     boolLayoutDone = false;
    private boolean     boolRootVisible = true;

    private Scrollbar   scrollBarVert = null;
    private Scrollbar   scrollBarHorz = null;

    private int         nScrollVertVisible;
    private int         nScrollHorzMax;
    private int         nScrollHorzVisible;
    private int         nScrollHorzLeft = 0;
    private int         nScrollHorzCell = TreeNode.MARGIN_HORZ;

	private Image       imageDraw = null;
    

    public TreeControl () {
        this ( null );
    }

    public TreeControl ( String stringRootName ) {
		super ( (LayoutManager)null );

        setLoweredBorder ();
		setBackground ( TreeNode.colorBg );
        
        this.addComponentListener ( this );
        this.addMouseListener ( this );
        this.addKeyListener ( this );
        this.addFocusListener ( this );

		if ( stringRootName != null )
            createRootElement ( stringRootName );
    }

    public boolean isFocusTraversable () {
        return ( true );
    }

    public TreeNode createRootElement ( String stringRootName ) {
        nodeRoot = new TreeNode ( stringRootName, this );
        nodeRoot.addActionListener ( this );
        vectorTreeElList = new Vector ();
        nodeRoot.addToTreeElList ( vectorTreeElList );
        nodeTop = nodeRoot;
        nodeRoot.setCurrent ( true );
        return ( nodeRoot );
    }

    public TreeNode createSubElement ( TreeNode nodeParent, String stringNodeName ) {
        TreeNode	nodeChild;

        nodeChild = nodeParent.addSubElement ( stringNodeName );
        nodeChild.addActionListener ( this );
        if ( this.isShowing() ) {
            recomputeLayout ();
            recomputeScrollbars ();
            repaint ();
        }
        return ( nodeChild );
    }

    public void destroySubElement ( TreeNode nodeParent, TreeNode node ) {
        TreeNode    nodeCurrent;

        nodeCurrent = this.getCurrentElement ();
        if ( nodeCurrent != null  &&  node.isRecursiveSubElement(nodeCurrent) )
            nodeParent.setCurrent ( true );

        nodeParent.destroySubElement ( node );
        if ( this.isShowing() ) {
            recomputeLayout ();
            recomputeScrollbars ();
            repaint ();
        }
    }

    public boolean isRootVisible () {
        return ( boolRootVisible );
    }

    public void setRootVisible ( boolean boolVisible ) {
        if ( this.boolRootVisible == boolVisible )
            return;

        boolRootVisible = boolVisible;
        nodeRoot.setVisible ( boolRootVisible );
        recomputeLayout ();
        recomputeScrollbars ();
        repaint ();
    }

    public TreeNode getRootElement () {
        return ( nodeRoot );
    }

    public TreeNode findElement ( String stringFullPath ) {
        TreeNode    node;

        node = nodeRoot.findElement ( stringFullPath );
        return ( node );
    }

    public TreeNode getCurrentElement () {
        return ( nodeRoot.getCurrent() );
    }

    public void setCurrentElement ( TreeNode node ) {
        if ( node == null )
            return;
        if ( !(nodeRoot.isRecursiveSubElement (node)) )
            return;
        node.setCurrent ( true );
    }

    public boolean SetElementImage ( TreeNode node, Image image ) {
        boolean     boolResult;

        boolResult = nodeRoot.isRecursiveSubElement ( node );
        if ( boolResult == false )
            return ( false );
        node.setImage ( image );

        if ( vectorTreeElList.contains (node) == false )
            return ( true );

        recomputeLayout ();
        recomputeScrollbars ();
        repaint ();
        return ( true );
    }

    public boolean setElementImageCur ( TreeNode node, Image image ) {
        boolean     boolResult;

        boolResult = nodeRoot.isRecursiveSubElement ( node );
        if ( boolResult == false )
            return ( false );
        node.setImageCur ( image );

        if ( vectorTreeElList.contains (node) == false )
            return ( true );

        recomputeLayout ();
        recomputeScrollbars ();
        repaint ();
        return ( true );
    }

    public Dimension getPreferredSize () {
        Dimension   dim;
        Rectangle   rect;
        Insets      insets;

        rect = nodeRoot.getNodeBoundsFull ();
        insets = getInsets ();
        dim = new Dimension ( rect.width + insets.left + insets.right,
                                rect.height + insets.top + insets.bottom );
        return ( dim );
    }

    public Rectangle getClientArea () {
        Rectangle   rect;
        Rectangle   rectScrollbar;
        Insets      insets;

        rect = new Rectangle ( getSize() );
        insets = getInsets ();
        rect.x = insets.left;
        rect.y = insets.top;
        rect.width -= insets.left + insets.right;
        rect.height -= insets.top + insets.bottom;

        if ( scrollBarVert != null  &&  scrollBarVert.isVisible() ) {
            rectScrollbar = scrollBarVert.getBounds ();
            rect.width -= rectScrollbar.width;
        }
        if ( scrollBarHorz != null  &&  scrollBarHorz.isVisible() ) {
            rectScrollbar = scrollBarHorz.getBounds ();
            rect.height -= rectScrollbar.height;
        }

        if ( rect.width < 0 )
            rect.width = 0;
        if ( rect.height < 0 )
            rect.height = 0;
        return ( rect );
    }

    public void update (Graphics graphics) {
        if ( isShowing() )
            paint ( graphics );
    }


    public void paint ( Graphics graphics ) {
        int         i;
        int         nIndexTop;
        int         nSize;
        Rectangle   rect;
        Rectangle   rectTop;
        TreeNode    node;
        Rectangle   rectClientArea;
        Dimension   dim;
        Graphics    graphicsImage;


        dim = this.getSize ();
        if ( imageDraw == null  ||  imageDraw.getWidth(this) < dim.width
                                ||  imageDraw.getHeight(this) < dim.height )
		    imageDraw = createImage ( dim.width, dim.height );
        graphicsImage = imageDraw.getGraphics ();
        graphicsImage.setColor ( this.getBackground() );
        graphicsImage.fillRect ( 0, 0, dim.width, dim.height );

        if ( boolLayoutDone == false ) {
            recomputeLayout ( graphicsImage );
            recomputeScrollbars ();
        }
        rectClientArea = getClientArea ();

        graphicsImage.setFont ( getFont() );

        nSize = vectorTreeElList.size ();
        nIndexTop = vectorTreeElList.indexOf ( nodeTop );
        rectTop = nodeTop.getNodeBounds ();

        if ( boolRootVisible == false ) {
            rect = nodeRoot.getNodeBounds ();
            Rectangle   rectFirst = nodeRoot.getSubElement(0).getNodeBounds();
            Rectangle   rectLast = nodeRoot.getSubElement(nodeRoot.size()-1).getNodeBounds();
            int nX = rectFirst.x - nScrollHorzLeft * nScrollHorzCell + TreeNode.MARGIN_HORZ + TreeNode.BOXSIZE / 2;
            int nY = rectFirst.y + rectFirst.height / 2 - rectTop.y;
            int nY2 = rectLast.y + rectLast.height / 2 - rectTop.y;
            nodeRoot.drawDottedLine ( graphicsImage, nX, nY, nX, nY2 );
        }
        for ( i = 0;  i < nSize;  i++ )  {
            node = (TreeNode) vectorTreeElList.elementAt ( i );
            node.drawElement ( graphicsImage, nScrollHorzLeft * nScrollHorzCell, rectTop.y );
            rect = node.getNodeBounds ();
            if ( rect.y + rect.height >= rectTop.y + rectClientArea.height )
                break;
        }

        super.paint ( graphicsImage );
        graphics.drawImage ( imageDraw, 0, 0, this );
	}

	public void addNotify () {
		super.addNotify ();

		addScrollbarVert ();
		addScrollbarHorz ();
	}


    public void componentResized ( ComponentEvent event ) {
        recomputeLayout ();
        recomputeScrollbars ();
    }

    public void componentMoved ( ComponentEvent event ) {
    }

    public void componentShown ( ComponentEvent event ) {
    }

    public void componentHidden ( ComponentEvent event ) {
    }

    public void mouseClicked ( MouseEvent event ) {
        Rectangle   rect;
        Point       point;

        this.requestFocus ();
        if ( event.getClickCount() % 2 == 1 )
            return;

        rect = nodeTop.getNodeBounds ();
        point = new Point ( event.getPoint() );
        point.y += rect.y;
        point.x += nScrollHorzLeft * nScrollHorzCell;

        nodeRoot.onMouseDoubleclick ( point );
    }

    public void mousePressed ( MouseEvent event ) {
        Rectangle   rect;
        Point       point;
        int         nModifiers;

        rect = nodeTop.getNodeBounds ();
        point = new Point ( event.getPoint() );
        point.y += rect.y;
        point.x += nScrollHorzLeft * nScrollHorzCell;

        nModifiers = event.getModifiers ();
        if ( (nModifiers & InputEvent.BUTTON1_MASK) == InputEvent.BUTTON1_MASK )
            nodeRoot.onMousePressedLeft ( point, event.isShiftDown(),
                                    event.isControlDown(), event.isAltDown() );
        else if ( (nModifiers & InputEvent.BUTTON3_MASK) == InputEvent.BUTTON3_MASK )
            nodeRoot.onMousePressedRight ( point, event.isShiftDown(),
                                    event.isControlDown(), event.isAltDown() );
    }

    public void mouseReleased ( MouseEvent event ) {
    }

    public void mouseEntered ( MouseEvent event ) {
    }

    public void mouseExited ( MouseEvent event ) {
    }

    public void keyPressed ( KeyEvent event ) {
        char    cKeyChar;
        int     nKeyCode;
        int     nModifiers;
        int     nIndexCurrent;
        int     nIndexCurrentNew;

        cKeyChar = event.getKeyChar ();
        nKeyCode = event.getKeyCode ();
        nModifiers = event.getModifiers ();

        if ( nKeyCode == KeyEvent.VK_ADD ) {
            nodeCurrent.setExpanded ( true );
            return;
        }
        else if ( nKeyCode == KeyEvent.VK_SUBTRACT ) {
            nodeCurrent.setExpanded ( false );
            return;
        }

        nIndexCurrent = vectorTreeElList.indexOf ( nodeCurrent );
        nIndexCurrentNew = nIndexCurrent;

        if ( nKeyCode == KeyEvent.VK_DOWN )
            nIndexCurrentNew++;
        else if ( nKeyCode == KeyEvent.VK_PAGE_DOWN )
            nIndexCurrentNew += nScrollVertVisible;
        else if ( nKeyCode == KeyEvent.VK_UP )
            nIndexCurrentNew--;
        else if ( nKeyCode == KeyEvent.VK_PAGE_UP )
            nIndexCurrentNew -= nScrollVertVisible;
        else if ( nKeyCode == KeyEvent.VK_END )