Flex tree 节点遍历的方法

JScript code

   
   

    
    
    
    



    
    /*

    
    *

 * This method will traverse a Tree's model independent of it's

 * type.

 * 

 * <p>Note :: This method may look long and arduous but, rest assured

 * it has all the checks to perform like a champ. Also, you 'could'

 * refactor part of this method but, for the sake of explanation, I

 * kept it all in one place.</p>

 * 

 * <p>Remember, I had coupled the model to this method by tracing

 * @label, obviously you do not need to do this. The intention of

 * this example is to show you that the dataDescriptor seperates

 * the models type and is awesome. It enables you to create a tight 

 * method like this without type checks on the model.</p>

 *

 * @param tree The Tree instance that will be examined by the method.

 * @param item An item found in the dataProvider of the Tree passed in.

 * @param startAtParent A boolean that determines if the method upon

 * initialization will back up one leve3l to the item passed in and

 * start it's recursion at the item's parent node. 

 

    
    */

    
     

public 

    
    function

    
     walkTree(tree:Tree, item:Object, startAtParent:Boolean 

    
    =

    
     

    
    false

    
    ):

    
    void

    
    

{

    

    
    //

    
     get the Tree's data descriptor

    
    



    
        

    
    var

    
     descriptor:ITreeDataDescriptor 

    
    =

    
     tree.dataDescriptor;

    

    
    var

    
     cursor:IViewCursor;

    

    

    
    var

    
     parentItem:Object;

    

    
    var

    
     childItem:Object;

    

    
    var

    
     childItems:Object;

    

    

    
    //

    
     if the item is null, stop

    
    



    
        

    
    if

    
    (item 

    
    ==

    
     

    
    null

    
    )

        

    
    return

    
    ;

        

    

    
    //

    
     do we back up one level to the item's parent

    
    



    
        

    
    if

    
    (startAtParent)

    {

        

    
    //

    
     get the parent

    
    



    
            parentItem 

    
    =

    
     tree.getParentItem(item);

        

    
    //

    
     is the parent real

    
    



    
            

    
    if

    
    (parentItem)

        {

            trace(

    
    "

    
    |-- Parent Node 

    
    "

    
    , parentItem[tree.labelField]);

            

    
    //

    
     if the parent is a branch

    
    



    
                

    
    if

    
    (descriptor.isBranch(parentItem))

            {

                

    
    //

    
     if the branch has children to run through

    
    



    
                    

    
    if

    
    (descriptor.hasChildren(parentItem))

                {

                    

    
    //

    
     get the children of the branch

    
    



    
                        

    
    //

    
     this part of the algorithm contains the item

    
    



    
                        

    
    //

    
     passed

    
    



    
                        childItems 

    
    =

    
     descriptor.getChildren(parentItem);

                }

            }

            

    
    //

    
     if the branch has valid child items

    
    



    
                

    
    if

    
    (childItems)

            {

                

    
    //

    
     create our back step cursor

    
    



    
                    cursor 

    
    =

    
     childItems.createCursor();

                

    
    //

    
     loop through the items parent's children (item)

    
    



    
                    

    
    while

    
    (

    
    !

    
    cursor.afterLast)

                {

                    

    
    //

    
     get the current child item

    
    



    
                        childItem 

    
    =

    
     cursor.current; 

                    

    
    var

    
     label:String 

    
    =

    
     childItem[tree.labelField];

                    

    
    var

    
     branch:Boolean 

    
    =

    
     descriptor.isBranch(childItem);

                    

                    

    
    //

    
     good place for a custom method()

    
    



    
                        trace(

    
    "

    
    Sibling Nodes :: 

    
    "

    
    , label, 

    
    "

    
    Is Branch :: 

    
    "

    
    , branch); 

                    

                    

    
    //

    
     if the child item is a branch

    
    



    
                        

    
    if

    
    (descriptor.isBranch(childItem))

                        

    
    //

    
     traverse the childs branch all the way down 

    
    



    
                            

    
    //

    
     before returning

    
    



    
                            walkTree(tree, childItem);

                    

    
    //

    
     do it again!

    
    



    
                        cursor.moveNext();

                }

            }

        }

    }

    

    
    else

    
    //

    
     we don't want the parent OR this is the second iteration

    
    



    
        {

        

    
    //

    
     if we are a branch

    
    



    
            

    
    if

    
    (descriptor.isBranch(item))

        {

            

    
    //

    
     if the branch has children to run through

    
    



    
                

    
    if

    
    (descriptor.hasChildren(item))

            {

                

    
    //

    
     get the children of the branch

    
    



    
                    childItems 

    
    =

    
     descriptor.getChildren(item);

            }

            

            

    
    //

    
     if the child items exist

    
    



    
                

    
    if

    
    (childItems)

            {

                

    
    //

    
     create our cursor pointer

    
    



    
                    cursor 

    
    =

    
     childItems.createCursor();

                

    
    //

    
     loop through all of the children

    
    



    
                    

    
    //

    
     if one of these children are a branch we will recurse

    
    



    
                    

    
    while

    
    (

    
    !

    
    cursor.afterLast)

                {

                    

    
    //

    
     get the current child item

    
    



    
                        childItem 

    
    =

    
     cursor.current;



                    

    
    var

    
     label:String 

    
    =

    
      childItem[tree.labelField];

                    

    
    var

    
     branch:Boolean 

    
    =

    
     descriptor.isBranch(childItem);

                    

                    

    
    //

    
     good place for a custom method()

    
    



    
                        trace(

    
    "

    
    -- Sub Node :: 

    
    "

    
    , label, 

    
    "

    
    Is Branch :: 

    
    "

    
    , branch); 



                    

    
    //

    
     if the child item is a branch

    
    



    
                        

    
    if

    
    (descriptor.isBranch(childItem))

                        

    
    //

    
     traverse the childs branch all the way down 

    
    



    
                            

    
    //

    
     before returning

    
    



    
                            walkTree(tree, childItem);

                    

    
    //

    
     check the next child

    
    



    
                        cursor.moveNext();

                }

            }

        }

    }

}