treecontrol.java

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

            nIndexCurrentNew = vectorTreeElList.size () - 1;
        else if ( nKeyCode == KeyEvent.VK_HOME )
            nIndexCurrentNew = 0;

        if ( nIndexCurrentNew > vectorTreeElList.size () - 1 )
            nIndexCurrentNew = vectorTreeElList.size () - 1;
        if ( nIndexCurrentNew < 0 )
            nIndexCurrentNew = 0;

        if ( nIndexCurrentNew != nIndexCurrent ) {
            nodeCurrent = (TreeNode) vectorTreeElList.elementAt ( nIndexCurrentNew );
            nodeCurrent.setCurrent ( true );
        }
    }

    public void keyReleased ( KeyEvent event ) {
    }

    public void keyTyped ( KeyEvent event ) {
    }

    public void focusGained ( FocusEvent event ) {
        repaint ();
    }

    public void focusLost ( FocusEvent event ) {
        repaint ();
    }

    public void adjustmentValueChanged ( AdjustmentEvent event ) {
        Adjustable      adjustable;
        int             nType;
        int             nValue;
        int             nIndexTop;

        adjustable = event.getAdjustable ();
        if ( adjustable == null  ||  !(adjustable instanceof Scrollbar) )
            return;

        nType = event.getAdjustmentType ();
        nValue = event.getValue ();
        if ( nValue != adjustable.getValue() )
            adjustable.setValue ( nValue );

        if ( ((Scrollbar)adjustable).getOrientation() == Scrollbar.VERTICAL ) {
            nIndexTop = vectorTreeElList.indexOf ( nodeTop );
            if ( nIndexTop != nValue ) {
                nIndexTop = nValue;
                nodeTop = (TreeNode) vectorTreeElList.elementAt ( nIndexTop );
                recomputeScrollbars ();
                repaint ();
            }
        }
        else { // if ( ((Scrollbar)adjustable).getOrientation() == Scrollbar.HORIZONTAL )
            if ( nScrollHorzLeft != nValue ) {
                nScrollHorzLeft = nValue;
                repaint ();
            }
        }
    }

    public void actionPerformed ( ActionEvent event ) {
        Object  objSource;
        String  strAction;

        objSource = event.getSource ();
        if ( objSource == null  ||  !(objSource instanceof TreeNode) )
            return;

        strAction = event.getActionCommand ();
        if ( strAction.equals(TreeNode.ACTION_NODE_ADDED) ) {
            recomputeTreeElList ();
            if ( vectorTreeElList.contains (objSource) == true ) {
                recomputeLayout ();
                recomputeScrollbars ();
            }
            repaint ();
        }
        else if ( strAction.equals(TreeNode.ACTION_NODE_REMOVED) ) {
            if ( vectorTreeElList.contains (objSource) == true ) {
                recomputeTreeElList ();
                recomputeLayout ();
                recomputeScrollbars ();
            }
            repaint ();
        }
        else if ( strAction.equals(TreeNode.ACTION_NODE_EXPANDED) ) {
            recomputeTreeElList ();
            recomputeLayout ();
            recomputeScrollbars ();
            repaint ();
        }
        else if ( strAction.equals(TreeNode.ACTION_NODE_COLLAPSED) ) {
            recomputeTreeElList ();
            recomputeLayout ();
            recomputeScrollbars ();
            repaint ();
        }
        else if ( strAction.equals(TreeNode.ACTION_NODE_SETCURRENT) ) {
            nodeCurrent = (TreeNode)objSource;
            scrollCurrentIntoView ();
            repaint ();
        }
        else if ( strAction.equals(TreeNode.ACTION_NODE_RESETCURRENT) ) {
        }
    }

    private void recomputeTreeElList () {
        boolean     boolResult;
        TreeNode    nodeCurrentOld;


        if ( nodeRoot == null )
            return;
			
        vectorTreeElList.removeAllElements ();
        nodeRoot.addToTreeElList ( vectorTreeElList );

        while ( nodeTop != null ) {
            boolResult = vectorTreeElList.contains ( nodeTop );
            if ( boolResult == true )
                break;
            nodeTop = (TreeNode) nodeTop.getOwner ();
        }
        if ( nodeTop == null  &&  vectorTreeElList.size() > 0 )
            nodeTop = (TreeNode) vectorTreeElList.elementAt ( 0 );
        if ( nodeTop == null )
            nodeTop = nodeRoot;

        nodeCurrentOld = nodeCurrent;
        while ( nodeCurrent != null ) {
            boolResult = vectorTreeElList.contains ( nodeCurrent );
            if ( boolResult == true )
                break;
            nodeCurrent = (TreeNode) nodeCurrent.getOwner ();
        }
        if ( nodeCurrent == null  &&  vectorTreeElList.size() > 0 )
            nodeCurrent = (TreeNode) vectorTreeElList.elementAt ( 0 );
        if ( nodeCurrent == null )
            nodeCurrent = nodeRoot;

        if ( nodeCurrentOld != nodeCurrent ) {
            if ( nodeCurrentOld != null )
                nodeCurrentOld.setCurrent ( false );
            if ( nodeCurrent != null )
                nodeCurrent.setCurrent ( true );
        }
    }

    private void recomputeLayout () {
        Graphics    graphics;

        graphics = getGraphics ();
        if ( graphics != null )
            recomputeLayout ( graphics );
    }

    private void recomputeLayout ( Graphics graphics ) {
        int             nIndexTop;
        Rectangle       rect;
        Rectangle       rectTop;
        Rectangle       rectClientArea;
        Font            font;
        FontMetrics     fontMetrics;


        font = this.getFont ();
        fontMetrics = graphics.getFontMetrics ( font );
        rect = new Rectangle ( 0, 0, 0, 0 );
        rect = nodeRoot.recomputeLayout ( rect, fontMetrics );

        rectClientArea = this.getClientArea ();
        nIndexTop = vectorTreeElList.indexOf ( nodeTop );
        rectTop = nodeTop.getNodeBounds ();
        while ( nIndexTop > 0   &&  rectClientArea.height > rect.height - (rectTop.y - rect.y) ) {
            nIndexTop--;
            nodeTop = (TreeNode) vectorTreeElList.elementAt ( nIndexTop );
            rectTop = nodeTop.getNodeBounds ();
        }
        boolLayoutDone = true;
    }

    public void addScrollbarVert () {
        scrollBarVert = new Scrollbar ( Scrollbar.VERTICAL );
        scrollBarVert.addAdjustmentListener ( this );
        scrollBarVert.setUnitIncrement ( 1 );
        add ( scrollBarVert );
    }

    public void addScrollbarHorz () {
        scrollBarHorz = new Scrollbar ( Scrollbar.HORIZONTAL );
        scrollBarHorz.addAdjustmentListener ( this );
        scrollBarHorz.setUnitIncrement ( 1 );
        add ( scrollBarHorz );
    }

    public void removeScrollbarVert () {
        scrollBarVert.removeAdjustmentListener ( this );
        remove ( scrollBarVert );
        scrollBarVert = null;
    }

    public void removeScrollbarHorz () {
        scrollBarHorz.removeAdjustmentListener ( this );
        remove ( scrollBarHorz );
        scrollBarHorz = null;
    }

    private void recomputeScrollbars () {
        int         i;
        int         nIndexTop;
        int         nSize;
        Rectangle   rect;
        Rectangle   rectTop;
        Rectangle   rectClientArea;
        TreeNode    node;

        if ( boolLayoutDone == false )
            return;

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

        rectClientArea = getClientArea ();
        for ( i = nIndexTop;  i < nSize;  i++ ) {
            node = (TreeNode) vectorTreeElList.elementAt ( i );
            rect = node.getNodeBounds ();
            if ( rect.y + rect.height - rectTop.y > rectClientArea.height )
                break;
        }
        nScrollVertVisible = i - nIndexTop;
        setScrollbarVertValues ( nIndexTop, nScrollVertVisible, 0, nSize );

        rect = nodeRoot.getNodeBoundsFull ();
        nScrollHorzMax = (rect.width + nScrollHorzCell - 1) / nScrollHorzCell;
        nScrollHorzVisible = rectClientArea.width / nScrollHorzCell;
        setScrollbarHorzValues ( nScrollHorzLeft, nScrollHorzVisible, 0, nScrollHorzMax );

        rect = getClientArea ();
        if ( !(rectClientArea.equals(rect)) ) {
            recomputeScrollbars ();
        }
    }

    private void scrollCurrentIntoView () {
        int         nSize;
        int         nIndexCurrent;
        int         nIndexTop;
        int         nIndexTopNew;
        Rectangle   rectCurrent;
        Rectangle   rectTop;
        Rectangle   rectClientArea;


        if ( boolLayoutDone == false )
            return;

        nSize = vectorTreeElList.size ();
        nIndexCurrent = vectorTreeElList.indexOf ( nodeCurrent );
        if ( nIndexCurrent < 0 )
            return;
			
        nIndexTop = vectorTreeElList.indexOf ( nodeTop );
        nIndexTopNew = nIndexTop;

        if ( nIndexCurrent >= nIndexTopNew + nScrollVertVisible ) {
            rectClientArea = getClientArea ();
            rectCurrent = nodeCurrent.getNodeBounds ();
            while ( nIndexTopNew < nSize - 1 ) {
                nIndexTopNew++;
                nodeTop = (TreeNode) vectorTreeElList.elementAt ( nIndexTopNew );
                rectTop = nodeTop.getNodeBounds ();
                if ( rectCurrent.y + rectCurrent.height - rectTop.y > rectClientArea.height );
                    break;
            }
        }
        if ( nIndexCurrent < nIndexTopNew ) {
            nIndexTopNew = nIndexCurrent;
            nodeTop = (TreeNode) vectorTreeElList.elementAt ( nIndexTopNew );
        }

        if ( nIndexTopNew != nIndexTop )
            recomputeScrollbars ();
	}

    public boolean setScrollbarVertValues ( int nValue, int nVisibleCount, int nMinValue, int nMaxValue ) {
        boolean     boolResult;
        boolean     boolVisible;

		
        if ( scrollBarVert == null )
            return ( false );

        boolResult = scrollBarVert.isVisible ();
        scrollBarVert.setValues ( nValue, nVisibleCount, nMinValue, nMaxValue );
        if ( nVisibleCount - 1 < 1 )
            scrollBarVert.setBlockIncrement ( 1 );
        else
            scrollBarVert.setBlockIncrement ( nVisibleCount - 1 );

        if ( nMaxValue - nMinValue > nVisibleCount )
            boolVisible = true;
        else
            boolVisible = false;

        scrollBarVert.setVisible ( boolVisible );
        positionScrollbars ();

        scrollBarVert.setValues ( nValue, nVisibleCount, nMinValue, nMaxValue );
        if ( nVisibleCount - 1 < 1 )
            scrollBarVert.setBlockIncrement ( 1 );
        else
            scrollBarVert.setBlockIncrement ( nVisibleCount - 1 );

        return ( boolResult != boolVisible );
    }

    public boolean setScrollbarHorzValues ( int nValue, int nVisibleCount, int nMinValue, int nMaxValue ) {
        boolean     boolResult;
        boolean     boolVisible;


        if ( scrollBarHorz == null )
            return ( false );

        boolResult = scrollBarHorz.isVisible ();
        scrollBarHorz.setValues ( nValue, nVisibleCount, nMinValue, nMaxValue );
        if ( nVisibleCount - 1 < 1 )
            scrollBarHorz.setBlockIncrement ( 1 );
        else
            scrollBarHorz.setBlockIncrement ( nVisibleCount - 1 );

        if ( nMaxValue - nMinValue > nVisibleCount )
            boolVisible = true;
        else
            boolVisible = false;

        scrollBarHorz.setVisible ( boolVisible );
        positionScrollbars ();

        scrollBarHorz.setValues ( nValue, nVisibleCount, nMinValue, nMaxValue );
        if ( nVisibleCount - 1 < 1 )
            scrollBarHorz.setBlockIncrement ( 1 );
        else
            scrollBarHorz.setBlockIncrement ( nVisibleCount - 1 );

        return ( boolResult != boolVisible );
    }

    private void positionScrollbars () {
        Dimension   dimVert;
        Dimension   dimHorz;
        Rectangle   rect;
        Insets      insets;

        rect = getBounds ();
        insets = this.getInsets ();
        rect.x = insets.left;
        rect.y = insets.top;
        rect.width = rect.width - insets.left - insets.right;
        rect.height = rect.height - insets.top - insets.bottom;

        if ( scrollBarVert != null  &&  scrollBarVert.isVisible() ) {
            dimVert = scrollBarVert.getPreferredSize ();
            dimVert.width += 2;
        }
        else {
            dimVert = new Dimension ( 0, 0 );
        }

        if ( scrollBarHorz != null  &&  scrollBarHorz.isVisible() ) {
            dimHorz = scrollBarHorz.getPreferredSize ();
            dimHorz.height += 2;
        }
        else {
            dimHorz = new Dimension ( 0, 0 );
        }

        if ( scrollBarVert != null )
            scrollBarVert.setBounds ( rect.x + rect.width - dimVert.width, rect.y, dimVert.width, rect.height - dimHorz.height );
        if ( scrollBarHorz != null )
            scrollBarHorz.setBounds ( rect.x, rect.y + rect.height - dimHorz.height, rect.width - dimVert.width, dimHorz.height );
    }

}