home *** CD-ROM | disk | FTP | other *** search
/ PC World 2001 August / PCWorld_2001-08_cd.bin / Komunikace / phptriad / phptriadsetup2-11.exe / php / pear / Experimental / HTML / Menu.php
Encoding:
PHP Script  |  2001-03-13  |  21.9 KB  |  653 lines
  1. <?php
  2. // +----------------------------------------------------------------------+
  3. // | PHP version 4.0                                                      |
  4. // +----------------------------------------------------------------------+
  5. // | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group             |
  6. // +----------------------------------------------------------------------+
  7. // | This source file is subject to version 2.0 of the PHP license,       |
  8. // | that is bundled with this package in the file LICENSE, and is        |
  9. // | available at through the world-wide-web at                           |
  10. // | http://www.php.net/license/2_02.txt.                                 |
  11. // | If you did not receive a copy of the PHP license and are unable to   |
  12. // | obtain it through the world-wide-web, please send a note to          |
  13. // | license@php.net so we can mail you a copy immediately.               |
  14. // +----------------------------------------------------------------------+
  15. // | Authors: Ulf Wendel <ulf.wendel@phpdoc.de>                           |
  16. // +----------------------------------------------------------------------+
  17. //
  18. // $Id: Menu.php,v 1.6 2001/03/13 00:18:38 uw Exp $
  19.  
  20. /**
  21. * Generates a HTML menu from a multidimensional hash.
  22. * 
  23. * Special thanks to the original author: Alex Vorobiev  <sasha@mathforum.com>
  24. *
  25. * @version  $id: $
  26. * @author   Ulf Wendel <ulf.wendel@phpdoc.de>
  27. * @access   public
  28. * @package  HTML
  29. */
  30. class menu {
  31.  
  32.  
  33.     /**
  34.     * Menu structure as a multidimensional hash.
  35.     * 
  36.     * @var  array
  37.     * @see  setMenu(), Menu()
  38.     */    
  39.     var $menu = array();
  40.     
  41.     
  42.     /**
  43.     * Mapping from URL to menu path.
  44.     *
  45.     * @var  array
  46.     * @see  getPath()
  47.     */
  48.     var $urlmap = array();
  49.     
  50.     
  51.     /**
  52.     * Menu type: tree, rows, you-are-here.
  53.     * 
  54.     * @var  array
  55.     * @see  setMenuType()
  56.     */
  57.     var $menu_type = "tree";
  58.     
  59.     
  60.     /**
  61.     * Path to a certain menu item.
  62.     * 
  63.     * Internal class variable introduced to save some recursion overhead. 
  64.     *
  65.     * @var  array
  66.     * @see  get(), getPath()
  67.     */
  68.     var $path = array();
  69.     
  70.     
  71.     /**
  72.     * Generated HTML menu.
  73.     * 
  74.     * @var  string
  75.     * @see  get()
  76.     */
  77.     var $html = "";
  78.     
  79.     
  80.     /**
  81.     * URL of the current page.
  82.     *
  83.     * This can be the URL of the current page but it must not be exactly the 
  84.     * return value of getCurrentURL(). If there's no entry for the return value
  85.     * in the menu hash getPath() tries to find the menu item that fits best
  86.     * by shortening the URL sign by sign until it find an entry that fits.
  87.     * 
  88.     * @see  getCurrentURL(), getPath()
  89.     */
  90.     var $current_url = "";
  91.  
  92.     
  93.     /**
  94.     * Initializes the menu, sets the type and menu structure.
  95.     * 
  96.     * @param    array
  97.     * @param    string
  98.     * @see      setMenuType(), setMenu()
  99.     */
  100.     function menu($menu = "", $type = "tree") { 
  101.         
  102.         if (is_array($menu))
  103.             $this->setMenu($menu);
  104.  
  105.         $this->setMenuType($type);
  106.         
  107.     } // end constructor   
  108.     
  109.     
  110.     /**
  111.     * Sets the menu structure.
  112.     *
  113.     * The menu structure is defined by a multidimensional hash. This is 
  114.     * quite "dirty" but simple and easy to traverse. An example 
  115.     * show the structure. To get the following menu:
  116.     * 
  117.     * 1  - Projects
  118.     * 11 - Projects => PHPDoc
  119.     * 12 - Projects => Forms
  120.     * 2  - Stuff
  121.     *
  122.     * you need the array:
  123.     * 
  124.     * $menu = array( 
  125.     *           1 => array( 
  126.     *                  "title" => "Projects", 
  127.     *                  "url" => "/projects/index.php",
  128.     *                  "sub" => array(
  129.     *                           11 => array(
  130.     *                                       "title" => "PHPDoc",
  131.     *                                       ...
  132.     *                                     ),
  133.     *                           12 => array( ... ),
  134.     *                 )
  135.     *             ),
  136.     *           2 => array( "title" => "Stuff", "url" => "/stuff/index.php" )
  137.     *        )
  138.     *
  139.     * Note the index "sub" and the nesting. Note also that 1, 11, 12, 2 
  140.     * must be unique. The class uses them as ID's. 
  141.     * 
  142.     * @param    array
  143.     * @access   public
  144.     * @see      append(), update(), delete()
  145.     */
  146.     function setMenu($menu) {
  147.         
  148.         $this->menu = $menu;
  149.         $this->urlmap = array();
  150.         
  151.     } // end func setMenu
  152.     
  153.     
  154.     /**
  155.     * Sets the type / format of the menu: tree, rows or urhere.
  156.     *
  157.     * @param    string  "tree", "rows", "urhere", "prevnext"
  158.     * @access   public
  159.     */
  160.     function setMenuType($menu_type) {
  161.     
  162.         $this->menu_type = strtolower($menu_type);
  163.         
  164.     } // end func setMenuType
  165.  
  166.  
  167.     /**
  168.     * Returns the HTML menu.
  169.     * 
  170.     * @param    string  Menu type: tree, urhere, rows, prevnext
  171.     * @return   string  HTML of the menu
  172.     * @access   public
  173.     */
  174.     function get($menu_type = "") {
  175.         if ("" != $menu_type)
  176.             $this->setMenuType($menu_type);
  177.  
  178.         $this->html = ""; 
  179.                    
  180.         // buildMenu for rows cares on this itself            
  181.         if ("rows" != $this->menu_type)             
  182.             $this->html  .= $this->getStart();
  183.         
  184.         // storing to a class variable saves some recursion overhead
  185.         $this->path = $this->getPath();
  186.         $this->buildMenu($this->menu);
  187.     
  188.         if ("rows" != $this->menu_typ)
  189.             $this->html .= $this->getEnd();
  190.         
  191.         return $this->html;
  192.     } // end func get
  193.     
  194.     
  195.     /**
  196.     * Prints the HTML menu.
  197.     * 
  198.     * @brother  get()
  199.     * @return   void
  200.     */
  201.     function show($menu_type = "") {
  202.         print $this->get($menu_type);
  203.     } // end func show
  204.     
  205.     /**
  206.     * Returns a sitemap.
  207.     * 
  208.     * @return string  HTML code
  209.     * @access public
  210.     */
  211.     function getSitemap() {
  212.       
  213.       $oldtype = $this->menu_type;
  214.       $this->setMenuType("tree");
  215.       
  216.       $this->html = $this->getStart();
  217.     
  218.       $this->path = $this->getPath();
  219.       $this->buildSitemap($this->menu);
  220.  
  221.       $this->setMenuType($oldtype);
  222.       
  223.       return $this->html . $this->getEnd();
  224.     } // end func getSitemap
  225.  
  226.     
  227.     /**
  228.     * Returns the prefix of the HTML menu items.
  229.     * 
  230.     * @return   string  HTML menu prefix
  231.     * @see      getEnd(), get()
  232.     */
  233.     function getStart() {
  234.     
  235.         $html = "";
  236.         switch ($this->menu_type) {
  237.             case "rows":
  238.             case "prevnext":
  239.                 $html .= "<table border><tr>";
  240.                 break;
  241.                 
  242.             case "tree":
  243.             case "urhere":
  244.                 $html .= "<table border>";
  245.                 break;
  246.         }
  247.         
  248.         return $html;
  249.     } // end func getStart
  250.  
  251.     
  252.     /**
  253.     * Returns the postfix of the HTML menu items.
  254.     *
  255.     * @return   string  HTML menu postfix
  256.     * @see      getStart(), get()
  257.     */
  258.     function getEnd() {
  259.  
  260.         $html = "";
  261.         switch ($this->menu_type) {
  262.             case "rows":
  263.             case "prevnext":
  264.                 $html .="</tr></table>";
  265.                 break;
  266.             
  267.             case "tree":
  268.             case "urhere":
  269.                 $html = "</table>";
  270.                 break;
  271.         }
  272.         
  273.         return $html;
  274.     } // end func getEnd
  275.     
  276.     
  277.     /**
  278.     * Build the menu recursively.
  279.     *
  280.     * @param    array   first call: $this->menu, recursion: submenu
  281.     * @param    integer level of recursion, current depth in the tree structure
  282.     * @param    integer prevnext flag
  283.     */
  284.     function buildMenu($menu, $level = 0, $flag_stop_level = -1) {
  285.         static $last_node = array(), $up_node = array();
  286.         
  287.         // the recursion goes slightly different for every menu type
  288.         switch ($this->menu_type) {
  289.             
  290.             case "tree":
  291.             
  292.                 // loop through the (sub)menu
  293.                 foreach ($menu as $node_id => $node) {
  294.  
  295.                     if ($this->current_url == $node["url"]) {
  296.                         // menu item that fits to this url - "active" menu item
  297.                         $type = 1;
  298.                     } else if (isset($this->path[$level]) && $this->path[$level] == $node_id) {
  299.                         // processed menu item is part of the path to the active menu item
  300.                         $type = 2;
  301.                     } else {
  302.                         // not selected, not a part of the path to the active menu item
  303.                         $type = 0;
  304.                     }
  305.         
  306.                     $this->html .= $this->getEntry($node, $level, $type);
  307.                     
  308.                     // follow the subtree if the active menu item is in it
  309.                     if ($type && isset($node["sub"]))
  310.                         $this->buildMenu($node["sub"], $level + 1);
  311.                 }
  312.                 break;
  313.                 
  314.             case "rows":
  315.                 
  316.                 // every (sub)menu has it's own table
  317.                 $this->html .= $this->getStart();
  318.                 $submenu = false;
  319.                 
  320.                 // loop through the (sub)menu
  321.                 foreach ($menu as $node_id => $node) {
  322.                 
  323.                     if ($this->current_url == $node["url"]) {
  324.                         // menu item that fits to this url - "active" menu item
  325.                         $type = 1;
  326.                     } else if (isset($this->path[$level]) && $this->path[$level] == $node_id) {
  327.                         // processed menu item is part of the path to the active menu item
  328.                         $type = 2;
  329.                     } else {
  330.                         // not selected, not a part of the path to the active menu item
  331.                         $type = 0;
  332.                     }
  333.  
  334.                     $this->html .= $this->getEntry($node, $level, $type);
  335.                     
  336.                     // remember the subtree
  337.                     if ($type && isset($node["sub"]))
  338.                         $submenu = $node["sub"];
  339.                         
  340.                 }
  341.                 
  342.                 // close the table for this level
  343.                 $this->html .= $this->getEnd();
  344.                 
  345.                 // go deeper if neccessary
  346.                 if ($submenu)
  347.                     $this->buildMenu($submenu, $level + 1);
  348.  
  349.                 break;
  350.  
  351.             case "urhere":
  352.  
  353.                 // loop through the (sub)menu
  354.                 foreach ($menu as $node_id => $node) {
  355.                         
  356.                     if ($this->current_url == $node["url"]) {
  357.                         // menu item that fits to this url - "active" menu item
  358.                         $type = 1;
  359.                     } else if (isset($this->path[$level]) && $this->path[$level] == $node_id) {
  360.                         // processed menu item is part of the path to the active menu item
  361.                         $type = 2;
  362.                     } else {
  363.                         // not selected, not a part of the path to the active menu item
  364.                         $type = 0;
  365.                     }
  366.         
  367.                     // follow the subtree if the active menu item is in it
  368.                     if ($type) {
  369.                         $this->html .= $this->getEntry($node, $level, $type);
  370.                         if (isset($node["sub"])) {
  371.                             $this->buildMenu($node["sub"], $level + 1);
  372.                             continue;
  373.                         }
  374.                     }
  375.                     
  376.                 }
  377.                 break;
  378.                 
  379.           case "prevnext":
  380.                 
  381.                 // loop through the (sub)menu
  382.                 foreach ($menu as $node_id => $node) {
  383.                     
  384.                     if (-1 != $flag_stop_level) {
  385.                     
  386.                         // add this item to the menu and stop recursion - (next >>) node
  387.                         if ($flag_stop_level == $level) {
  388.                             $this->html .= $this->getEntry($node, $level, 4);
  389.                             $flag_stop_level = -1;
  390.                         }
  391.  
  392.                         break;
  393.                         
  394.                     
  395.                     } else if ($this->current_url == $node["url"]) {
  396.                         // menu item that fits to this url - "active" menu item
  397.                         $type = 1;
  398.                         $flag_stop_level = $level;
  399.                         
  400.                         if (0 != count($last_node)) {
  401.                         
  402.                             $this->html .= $this->getEntry($last_node, $level, 3);
  403.                           
  404.                         } else {
  405.                         
  406.                             // WARNING: if there's no previous take the first menu entry - you might not like this rule!
  407.                             reset($this->menu);
  408.                             list($node_id, $first_node) = each($this->menu);
  409.                             $this->html .= $this->getEntry($first_node, $level, 3);
  410.                             
  411.                         
  412.                         }
  413.                         
  414.                         if (0 != count($up_node)) {
  415.                           
  416.                           $this->html .= $this->getEntry($up_node, $level, 5);
  417.                           
  418.                         } else {
  419.                         
  420.                             // WARNING: if there's no up take the first menu entry - you might not like this rule!
  421.                             reset($this->menu);
  422.                             list($node_id, $first_node) = each($this->menu);
  423.                             $this->html .= $this->getEntry($first_node, $level, 5);
  424.                           
  425.                         }
  426.                         
  427.                     } else if (isset($this->path[$level]) && $this->path[$level] == $node_id) {
  428.                         // processed menu item is part of the path to the active menu item
  429.                         $type = 2;
  430.                      
  431.                     } else {
  432.                     
  433.                         $type = 0;
  434.                     
  435.                     }
  436.                     
  437.                     // remember the last (<< prev) node
  438.                     $last_node = $node;
  439.                     
  440.                     // follow the subtree if the active menu item is in it
  441.                     if ($type && isset($node["sub"])) {
  442.                         $up_node = $node;
  443.                         $flag_stop_level = $this->buildMenu($node["sub"], $level + 1, (-1 != $flag_stop_level) ? $flag_stop_level + 1 : -1); 
  444.                     }
  445.                 }
  446.                 break;
  447.                 
  448.             
  449.         } // end switch menu_type
  450.         
  451.         return ($flag_stop_level) ? $flag_stop_level - 1 : -1;
  452.     } // end func buildMenu
  453.     
  454.     
  455.     /**
  456.     * Build the menu recursively.
  457.     *
  458.     * @param    array   first call: $this->menu, recursion: submenu
  459.     * @param    int     level of recursion, current depth in the tree structure
  460.     */
  461.     function buildSitemap($menu, $level = 0) {
  462.  
  463.         // loop through the (sub)menu
  464.         foreach ($menu as $node_id => $node) {
  465.         
  466.             if ($this->current_url == $node["url"]) {
  467.                 // menu item that fits to this url - "active" menu item
  468.                 $type = 1;
  469.             } else if (isset($this->path[$level]) && $this->path[$level] == $node_id) {
  470.                 // processed menu item is part of the path to the active menu item
  471.                 $type = 2;
  472.             } else {
  473.                 // not selected, not a part of the path to the active menu item
  474.                 $type = 0;
  475.             }
  476.  
  477.             $this->html .= $this->getEntry($node, $level, $type);
  478.             
  479.             // follow the subtree if the active menu item is in it
  480.             if (isset($node["sub"]))
  481.                 $this->buildSitemap($node["sub"], $level + 1);
  482.         }
  483.  
  484.     } // end func buildSitemap
  485.     
  486.     
  487.     /**
  488.     * Returns the HTML of one menu item.
  489.     * 
  490.     * @param    array   menu item data (node data)
  491.     * @param    integer level in the menu tree
  492.     * @param    string  menu item type: 0, 1, 2. 0 => plain menu item,
  493.     *                   1 => selected (active) menu item, 2 => item 
  494.     *                   is a member of the path to the selected (active) menu item
  495.     *                   3 => previous entry, 4 => next entry
  496.     * @return   string  HTML
  497.     * @see      buildMenu()
  498.     */
  499.     function getEntry(&$node, $level, $item_type) {
  500.  
  501.         $html = "";
  502.         
  503.         if ("tree" == $this->menu_type) {
  504.             // tree menu
  505.             $html .= "<tr>";
  506.             $indent = "";
  507.             if ($level) 
  508.                 for ($i = 0; $i < $level; $i++)
  509.                     $indent .= "   ";
  510.         }
  511.         
  512.         // draw the <td></td> cell depending on the type of the menu item
  513.         switch ($item_type) {
  514.             case 0:
  515.                 // plain menu item
  516.                 $html .= sprintf('<td>%s<a href="%s">%s</a></td>',
  517.                                     $indent,
  518.                                     $node["url"],
  519.                                     $node["title"]
  520.                                  );
  521.                 break;
  522.                 
  523.             case 1:
  524.                 // selected (active) menu item
  525.                 $html .= sprintf('<td>%s<b>%s</b></td>', 
  526.                                    $indent,
  527.                                    $node["title"]
  528.                                 );
  529.                 break;
  530.                 
  531.             case 2:
  532.                 // part of the path to the selected (active) menu item
  533.                 $html .= sprintf('<td>%s<b><a href="%s">%s</a></b>%s</td>',
  534.                                     $indent,
  535.                                     $node["url"],
  536.                                     $node["title"],
  537.                                     ("urhere" == $this->menu_type) ? " >> " : ""
  538.                                 );
  539.                 break;
  540.                 
  541.             case 3: 
  542.                 // << previous url
  543.                 $html .= sprintf('<td>%s<a href="%s"><< %s</a></td>',
  544.                                     $indent,
  545.                                     $node["url"],
  546.                                     $node["title"]
  547.                                 );
  548.                 break;
  549.  
  550.             case 4:
  551.                 // next url >>
  552.                 $html .= sprintf('<td>%s<a href="%s">%s >></a></td>',
  553.                                     $indent,
  554.                                     $node["url"],
  555.                                     $node["title"]
  556.                                 );
  557.                 break;
  558.  
  559.             case 5:
  560.                 // up url ^^
  561.                 $html .= sprintf('<td>%s<a href="%s">^ %s ^</a></td>',
  562.                                     $indent,
  563.                                     $node["url"],
  564.                                     $node["title"]
  565.                           );
  566.                 break;                          
  567.                 
  568.         }
  569.             
  570.         if ("tree" == $this->menu_type)
  571.             $html .= "</tr>\n";
  572.  
  573.         return $html;
  574.     } // end func getEnty
  575.  
  576.  
  577.     /*
  578.     * Returns the path of the current page in the menu "tree".
  579.     *
  580.     * @return   array    path to the selected menu item
  581.     * @see      buildPath(), $urlmap
  582.     */
  583.     function getPath() {
  584.  
  585.         $this->current_url = $this->getCurrentURL();        
  586.         $this->buildPath($this->menu, array());  
  587.  
  588.         while ($this->current_url && !isset($this->urlmap[$this->current_url]))
  589.           $this->current_url = substr($this->current_url, 0, -1);
  590.         
  591.         return $this->urlmap[$this->current_url];          
  592.     } // end func getPath
  593.     
  594.     
  595.     /**
  596.     * Computes the path of the current page in the menu "tree".
  597.     * 
  598.     * @param    array       first call: menu hash / recursion: submenu hash
  599.     * @param    array       first call: array() / recursion: path
  600.     * @return   boolean     true if the path to the current page was found, 
  601.     *                       otherwise false. Only meaningful for the recursion.
  602.     * @global   $PHP_SELF   
  603.     * @see      getPath(), $urlmap
  604.     */
  605.     function buildPath($menu, $path) {
  606.  
  607.         // loop through the (sub)menu
  608.         foreach ($menu as $node_id => $node) {
  609.         
  610.             // save the path of the current node in the urlmap
  611.             $this->urlmap[$node["url"]] = $path;
  612.             
  613.             // we got'em - stop the search by returning true
  614.             // KLUDGE: getPath() works with the best alternative for a URL if there's
  615.             // no entry for a URL in the menu hash, buildPath() does not perform this test
  616.             // and might do some unneccessary recursive runs.
  617.             if ($node["url"] == $this->current_url)
  618.                return true;
  619.                
  620.             // current node has a submenu               
  621.             if ($node["sub"]) {
  622.                 
  623.                 // submenu path = current path + current node
  624.                 $subpath = $path;
  625.                 $subpath[] = $node_id;
  626.                 
  627.                 // continue search recursivly - return is the inner loop finds the 
  628.                 // node that belongs to the current url
  629.                 if ($this->buildPath($node["sub"], $subpath))
  630.                     return true;
  631.             }
  632.  
  633.         } 
  634.  
  635.         // not found
  636.         return false;        
  637.     } // end func buildPath
  638.     
  639.     
  640.     /**
  641.     * Returns the URL of the currently selected page.
  642.     *
  643.     * The returned string is used for all test against the URL's
  644.     * in the menu structure hash.
  645.     *
  646.     * @return string
  647.     */
  648.     function getCurrentURL() {
  649.       return $GLOBALS["PHP_SELF"];
  650.     } // end func getCurrentURL
  651.     
  652. } // end class menu
  653. ?>