Documentación GVHIDRA 3.1.5
Referencia de la Clase HTML_TreeMenu
Diagrama de herencias de HTML_TreeMenu
HTML_IgepArbol

Métodos públicos

 HTML_TreeMenu ()
addItem (&$node)
 createFromStructure ($params)
 createFromXML ($xml)

Campos de datos

 $items

Descripción detallada

Definición en la línea 64 del archivo TreeMenu.php.


Documentación de las funciones miembro

& addItem ( &$  node)

This function adds an item to the the tree.

public

Parámetros:
object$nodeThe node to add. This object should be a HTML_TreeNode object.
Devuelve:
object Returns a reference to the new node inside the tree.

Definición en la línea 91 del archivo TreeMenu.php.

    {
        $this->items[] = &$node;
        return $this->items[count($this->items) - 1];
    }
createFromStructure ( params)

Import method for creating HTML_TreeMenu objects/structures out of existing tree objects/structures. Currently supported are Wolfram Kriesings' PEAR Tree class, and Richard Heyes' (me!) Tree class (available here: http://www.phpguru.org/). This method is intended to be used statically, eg: $treeMenu = &HTML_TreeMenu::createFromStructure($myTreeStructureObj);

Parámetros:
array$paramsAn array of parameters that determine how the import happens. This can consist of: structure => The tree structure type => The type of the structure, currently can be either 'heyes' or 'kriesing' nodeOptions => Default options for each node
Devuelve:
object The resulting HTML_TreeMenu object

Wolfram Kriesings' PEAR Tree class

Richard Heyes' (me!) second (array based) Tree class

Richard Heyes' (me!) original OO based Tree class

Definición en la línea 114 del archivo TreeMenu.php.

    {
        if (!isset($params['nodeOptions'])) 
                                {
            $params['nodeOptions'] = array();
        }

        switch (@$params['type']) 
                                {

            case 'kriesing':
                $className = strtolower(get_class($params['structure']->dataSourceClass));
                $isXMLStruct = strpos($className,'_xml') !== false ? true : false;

                // Get the entire tree, the $nodes are sorted like in the tree view
                // from top to bottom, so we can easily put them in the nodes
                $nodes = $params['structure']->getNode();
 
                // Make a new menu and fill it with the values from the tree
                $treeMenu  = new HTML_TreeMenu();
                $curNode[0] = &$treeMenu;   // we need the current node as the reference to the

                foreach ( $nodes as $aNode ) {
                    $events = array();
                    $data = array();

                    // In an XML, all the attributes are saved in an array, but since they might be
                    // used as the parameters, we simply extract them here if we handle an XML-structure
                    if ( $isXMLStruct && sizeof($aNode['attributes']) ){
                        foreach ( $aNode['attributes'] as $key=>$val ) {
                            if ( !$aNode[$key] ) { // dont overwrite existing values
                                $aNode[$key] = $val;
                            }
                        }
                    }

                    // Process all the data that are saved in $aNode and put them in the data and/or events array
                    foreach ( $aNode as $key=>$val ) {
                        if ( !is_array($val) ) {
                            // Dont get the recursive data in here! they are always arrays
                            if ( substr($key,0,2) == 'on' ){  // get the events
                                $events[$key] = $val;
                            }

                            // I put it in data too, so in case an options starts with 'on' its also passed to the node ... not too cool i know
                            $data[$key] = $val;
                        }
                    }

                    // Normally the text is in 'name' in the Tree class, so we check both but 'text' is used if found
                    $data['text'] = $aNode['text'] ? $aNode['text'] : $aNode['name'];

                    // Add the item to the proper node
                    $thisNode = &$curNode[$aNode['level']]->addItem( new HTML_TreeNode( $data , $events ) );
                    $curNode[$aNode['level']+1] = &$thisNode;
                }
                break;

            case 'heyes_array':
                // Need to create a HTML_TreeMenu object ?
                if (!isset($params['treeMenu'])) {
                    $treeMenu = new HTML_TreeMenu();
                    $parentID = 0;
                } else {
                    $treeMenu = &$params['treeMenu'];
                    $parentID = $params['parentID'];
                }
                
                // Loop thru the trees nodes
                foreach ($params['structure']->getChildren($parentID) as $nodeID) {
                    $data = $params['structure']->getData($nodeID);
                    $parentNode = &$treeMenu->addItem(new HTML_TreeNode(array_merge($params['nodeOptions'], $data)));

                    // Recurse ?
                    if ($params['structure']->hasChildren($nodeID)) {
                        $recurseParams['type']        = 'heyes_array';
                        $recurseParams['parentID']    = $nodeID;
                        $recurseParams['nodeOptions'] = $params['nodeOptions'];
                        $recurseParams['structure']   = &$params['structure'];
                        $recurseParams['treeMenu']    = &$parentNode;
                        HTML_TreeMenu::createFromStructure($recurseParams);
                    }
                }
                
                break;

            case 'heyes':
            default:
                // Need to create a HTML_TreeMenu object ?
                if (!isset($params['treeMenu'])) {
                    $treeMenu = new HTML_TreeMenu();
                } else {
                    $treeMenu = &$params['treeMenu'];
                }
                
                // Loop thru the trees nodes
                foreach ($params['structure']->nodes->nodes as $node) {
                    $tag = $node->getTag();
                    $parentNode = &$treeMenu->addItem(new HTML_TreeNode(array_merge($params['nodeOptions'], $tag)));

                    // Recurse ?
                    if (!empty($node->nodes->nodes)) {
                        $recurseParams['structure']   = $node;
                        $recurseParams['nodeOptions'] = $params['nodeOptions'];
                        $recurseParams['treeMenu']    = &$parentNode;
                        HTML_TreeMenu::createFromStructure($recurseParams);
                    }
                }
                break;

        }

        return $treeMenu;
    }
createFromXML ( xml)

Creates a treeMenu from XML. The structure of your XML should be like so:

<treemenu> <node text="First node" icon="folder.gif" expandedicon="folder-expanded.gif"> <node text="Second node" icon="folder.gif" expandedicon="folder-expanded.gif"> <node text="Sub node" icon="folder.gif" expandedicon="folder-expanded.gif"> </node> <node text="Third node" icon="folder.gif" expandedicon="folder-expanded.gif"> </treemenu>

Any of the options you can supply to the HTML_TreeNode constructor can be supplied as attributes to the <node> tag. If there are no subnodes for a particular node, you can use the XML shortcut <node ... /> instead of <node ... ></node>. The $xml argument can be either the XML as a string, or an pre-created XML_Tree object. Also, this method REQUIRES my own Tree class to work (http://phpguru.org/tree.html). If this has not been include()ed or require()ed this method will die().

Parámetros:
mixed$xmlThis can be either a string containing the XML, or an XML_Tree object (the PEAR::XML_Tree package).
Devuelve:
object The HTML_TreeMenu object

Definición en la línea 261 del archivo TreeMenu.php.

    {
        if (!class_exists('Tree')) {
            die('Could not find Tree class');
        }

        // Supplied $xml is a string
        if (is_string($xml)) {
            require_once('./Tree.php');
            $xmlTree = new XML_Tree();
            $xmlTree->getTreeFromString($xml);

        // Supplied $xml is an XML_Tree object
        } else {
            $xmlTree = $xml;
        }

        // Now process the XML_Tree object, setting the XML attributes
        // to be the tag data (with out the XML tag name or contents).
        $treeStructure = Tree::createFromXMLTree($xmlTree, true);
        $treeStructure->nodes->traverse(create_function('&$node', '$tagData = $node->getTag(); $node->setTag($tagData["attributes"]);'));

        
        return HTML_TreeMenu::createFromStructure(array('structure' => $treeStructure));
    }

Constructor

public

Definición en la línea 77 del archivo TreeMenu.php.

    {
        // Not much to do here :(
    }

Documentación de los campos

$items

Definición en la línea 70 del archivo TreeMenu.php.


La documentación para esta clase fue generada a partir del siguiente fichero: