mirror of
https://github.com/php/web-pecl.git
synced 2026-03-24 07:12:15 +01:00
598 lines
20 KiB
PHP
Executable File
598 lines
20 KiB
PHP
Executable File
<?php
|
|
//
|
|
// +----------------------------------------------------------------------+
|
|
// | PHP version 4.0 |
|
|
// +----------------------------------------------------------------------+
|
|
// | Copyright (c) 1997-2001 The PHP Group |
|
|
// +----------------------------------------------------------------------+
|
|
// | This source file is subject to version 2.0 of the PHP license, |
|
|
// | that is bundled with this package in the file LICENSE, and is |
|
|
// | available at through the world-wide-web at |
|
|
// | http://www.php.net/license/2_02.txt. |
|
|
// | If you did not receive a copy of the PHP license and are unable to |
|
|
// | obtain it through the world-wide-web, please send a note to |
|
|
// | license@php.net so we can mail you a copy immediately. |
|
|
// +----------------------------------------------------------------------+
|
|
// | Authors: Ulf Wendel <ulf.wendel@phpdoc.de> |
|
|
// | Sebastian Bergmann <sb@sebastian-bergmann.de> |
|
|
// +----------------------------------------------------------------------+
|
|
//
|
|
// $Id: Menu.php 58643 2001-09-28 02:09:17Z ssb $
|
|
//
|
|
|
|
/**
|
|
* Generates a HTML menu from a multidimensional hash.
|
|
*
|
|
* Special thanks to the original author: Alex Vorobiev <sasha@mathforum.com>.
|
|
*
|
|
* @version $Id: Menu.php 58643 2001-09-28 02:09:17Z ssb $
|
|
* @author Ulf Wendel <ulf.wendel@phpdoc.de>
|
|
* @access public
|
|
* @package HTML
|
|
*/
|
|
|
|
class HTML_Menu {
|
|
/**
|
|
* URL Environment Variable
|
|
*
|
|
* @var array
|
|
*/
|
|
var $url_env_var = 'PHP_SELF';
|
|
|
|
/**
|
|
* Menu structure as a multidimensional hash.
|
|
*
|
|
* @var array
|
|
* @see setMenu(), Menu()
|
|
*/
|
|
var $menu = array();
|
|
|
|
/**
|
|
* Mapping from URL to menu path.
|
|
*
|
|
* @var array
|
|
* @see getPath()
|
|
*/
|
|
var $urlmap = array();
|
|
|
|
/**
|
|
* Menu type: tree, rows, you-are-here.
|
|
*
|
|
* @var array
|
|
* @see setMenuType()
|
|
*/
|
|
var $menu_type = 'tree';
|
|
|
|
/**
|
|
* Path to a certain menu item.
|
|
*
|
|
* Internal class variable introduced to save some recursion overhead.
|
|
*
|
|
* @var array
|
|
* @see get(), getPath()
|
|
*/
|
|
var $path = array();
|
|
|
|
/**
|
|
* Generated HTML menu.
|
|
*
|
|
* @var string
|
|
* @see get()
|
|
*/
|
|
var $html = '';
|
|
|
|
/**
|
|
* URL of the current page.
|
|
*
|
|
* This can be the URL of the current page but it must not be exactly the
|
|
* return value of getCurrentURL(). If there's no entry for the return value
|
|
* in the menu hash getPath() tries to find the menu item that fits best
|
|
* by shortening the URL sign by sign until it finds an entry that fits.
|
|
*
|
|
* @see getCurrentURL(), getPath()
|
|
*/
|
|
var $current_url = '';
|
|
|
|
/**
|
|
* Initializes the menu, sets the type and menu structure.
|
|
*
|
|
* @param array
|
|
* @param string
|
|
* @see setMenuType(), setMenu()
|
|
*/
|
|
function HTML_Menu($menu = '', $type = 'tree', $url_env_var = 'PHP_SELF') {
|
|
if (is_array($menu))
|
|
$this->setMenu($menu);
|
|
|
|
$this->setMenuType($type);
|
|
$this->setURLEnvVar($url_env_var);
|
|
}
|
|
|
|
/**
|
|
* Sets the menu structure.
|
|
*
|
|
* The menu structure is defined by a multidimensional hash. This is
|
|
* quite "dirty" but simple and easy to traverse. An example
|
|
* show the structure. To get the following menu:
|
|
*
|
|
* 1 - Projects
|
|
* 11 - Projects => PHPDoc
|
|
* 12 - Projects => Forms
|
|
* 2 - Stuff
|
|
*
|
|
* you need the array:
|
|
*
|
|
* $menu = array(
|
|
* 1 => array(
|
|
* 'title' => 'Projects',
|
|
* 'url' => '/projects/index.php',
|
|
* 'sub' => array(
|
|
* 11 => array(
|
|
* 'title' => 'PHPDoc',
|
|
* ...
|
|
* ),
|
|
* 12 => array( ... ),
|
|
* )
|
|
* ),
|
|
* 2 => array( 'title' => 'Stuff', 'url' => '/stuff/index.php' )
|
|
* )
|
|
*
|
|
* Note the index 'sub' and the nesting. Note also that 1, 11, 12, 2
|
|
* must be unique. The class uses them as ID's.
|
|
*
|
|
* @param array
|
|
* @access public
|
|
* @see append(), update()
|
|
*/
|
|
function setMenu($menu) {
|
|
$this->menu = $menu;
|
|
$this->urlmap = array();
|
|
}
|
|
|
|
/**
|
|
* Sets the type / format of the menu: tree, rows or urhere.
|
|
*
|
|
* @param string "tree", "rows", "urhere", "prevnext"
|
|
* @access public
|
|
*/
|
|
function setMenuType($menu_type) {
|
|
$this->menu_type = strtolower($menu_type);
|
|
}
|
|
|
|
/**
|
|
* Sets the environment variable to use to get the current URL.
|
|
*
|
|
* @param string environment variable for current URL
|
|
* @access public
|
|
*/
|
|
function setURLEnvVar($url_env_var) {
|
|
$this->url_env_var = $url_env_var;
|
|
}
|
|
|
|
/**
|
|
* Returns the HTML menu.
|
|
*
|
|
* @param string Menu type: tree, urhere, rows, prevnext, sitemap
|
|
* @return string HTML of the menu
|
|
* @access public
|
|
*/
|
|
function get($menu_type = '') {
|
|
if ('' != $menu_type)
|
|
$this->setMenuType($menu_type);
|
|
|
|
$this->html = '';
|
|
|
|
// buildMenu for rows cares on this itself
|
|
if ('rows' != $this->menu_type)
|
|
$this->html .= $this->getStart();
|
|
|
|
// storing to a class variable saves some recursion overhead
|
|
$this->path = $this->getPath();
|
|
|
|
if ('sitemap' == $this->menu_type) {
|
|
|
|
$this->setMenuType('tree');
|
|
$this->buildSitemap($this->menu);
|
|
$this->setMenuType('sitemap');
|
|
|
|
} else {
|
|
$this->buildMenu($this->menu);
|
|
}
|
|
|
|
if ('rows' != $this->menu_type)
|
|
$this->html .= $this->getEnd();
|
|
|
|
return $this->html;
|
|
}
|
|
|
|
/**
|
|
* Prints the HTML menu.
|
|
*
|
|
* @brother get()
|
|
* @return void
|
|
*/
|
|
function show($menu_type = '') {
|
|
print $this->get($menu_type);
|
|
}
|
|
|
|
/**
|
|
* Returns the prefix of the HTML menu items.
|
|
*
|
|
* @return string HTML menu prefix
|
|
* @see getEnd(), get()
|
|
*/
|
|
function getStart() {
|
|
$html = '';
|
|
switch ($this->menu_type) {
|
|
case 'rows':
|
|
case 'prevnext':
|
|
$html .= '<table border><tr>';
|
|
break;
|
|
|
|
case 'tree':
|
|
case 'urhere':
|
|
case 'sitemap':
|
|
$html .= '<table border>';
|
|
break;
|
|
}
|
|
|
|
return $html;
|
|
}
|
|
|
|
/**
|
|
* Returns the postfix of the HTML menu items.
|
|
*
|
|
* @return string HTML menu postfix
|
|
* @see getStart(), get()
|
|
*/
|
|
function getEnd() {
|
|
$html = '';
|
|
switch ($this->menu_type) {
|
|
case 'rows':
|
|
case 'prevnext':
|
|
$html .= '</tr></table>';
|
|
break;
|
|
|
|
case 'tree':
|
|
case 'urhere':
|
|
case 'sitemap':
|
|
$html .= '</table>';
|
|
break;
|
|
}
|
|
|
|
return $html;
|
|
}
|
|
|
|
/**
|
|
* Build the menu recursively.
|
|
*
|
|
* @param array first call: $this->menu, recursion: submenu
|
|
* @param integer level of recursion, current depth in the tree structure
|
|
* @param integer prevnext flag
|
|
*/
|
|
function buildMenu($menu, $level = 0, $flag_stop_level = -1) {
|
|
static $last_node = array(), $up_node = array();
|
|
|
|
// the recursion goes slightly different for every menu type
|
|
switch ($this->menu_type) {
|
|
case 'tree':
|
|
// loop through the (sub)menu
|
|
foreach ($menu as $node_id => $node) {
|
|
if ($this->current_url == $node['url']) {
|
|
// menu item that fits to this url - 'active' menu item
|
|
$type = 1;
|
|
} else if (isset($this->path[$level]) && $this->path[$level] == $node_id) {
|
|
// processed menu item is part of the path to the active menu item
|
|
$type = 2;
|
|
} else {
|
|
// not selected, not a part of the path to the active menu item
|
|
$type = 0;
|
|
}
|
|
|
|
$this->html .= $this->getEntry($node, $level, $type);
|
|
|
|
// follow the subtree if the active menu item is in it
|
|
if ($type && isset($node['sub']))
|
|
$this->buildMenu($node['sub'], $level + 1);
|
|
}
|
|
break;
|
|
|
|
case 'rows':
|
|
// every (sub)menu has it's own table
|
|
$this->html .= $this->getStart();
|
|
|
|
$submenu = false;
|
|
|
|
// loop through the (sub)menu
|
|
foreach ($menu as $node_id => $node) {
|
|
if ($this->current_url == $node['url']) {
|
|
// menu item that fits to this url - 'active' menu item
|
|
$type = 1;
|
|
} else if (isset($this->path[$level]) && $this->path[$level] == $node_id) {
|
|
// processed menu item is part of the path to the active menu item
|
|
$type = 2;
|
|
} else {
|
|
// not selected, not a part of the path to the active menu item
|
|
$type = 0;
|
|
}
|
|
|
|
$this->html .= $this->getEntry($node, $level, $type);
|
|
|
|
// remember the subtree
|
|
if ($type && isset($node['sub']))
|
|
$submenu = $node['sub'];
|
|
}
|
|
|
|
// close the table for this level
|
|
$this->html .= $this->getEnd();
|
|
|
|
// go deeper if neccessary
|
|
if ($submenu)
|
|
$this->buildMenu($submenu, $level + 1);
|
|
|
|
break;
|
|
|
|
case 'urhere':
|
|
// loop through the (sub)menu
|
|
foreach ($menu as $node_id => $node) {
|
|
if ($this->current_url == $node['url']) {
|
|
// menu item that fits to this url - 'active' menu item
|
|
$type = 1;
|
|
} else if (isset($this->path[$level]) && $this->path[$level] == $node_id) {
|
|
// processed menu item is part of the path to the active menu item
|
|
$type = 2;
|
|
} else {
|
|
// not selected, not a part of the path to the active menu item
|
|
$type = 0;
|
|
}
|
|
|
|
// follow the subtree if the active menu item is in it
|
|
if ($type) {
|
|
$this->html .= $this->getEntry($node, $level, $type);
|
|
if (isset($node['sub'])) {
|
|
$this->buildMenu($node['sub'], $level + 1);
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 'prevnext':
|
|
// loop through the (sub)menu
|
|
foreach ($menu as $node_id => $node) {
|
|
if (-1 != $flag_stop_level) {
|
|
// add this item to the menu and stop recursion - (next >>) node
|
|
if ($flag_stop_level == $level) {
|
|
$this->html .= $this->getEntry($node, $level, 4);
|
|
$flag_stop_level = -1;
|
|
}
|
|
|
|
break;
|
|
} else if ($this->current_url == $node['url']) {
|
|
// menu item that fits to this url - 'active' menu item
|
|
$type = 1;
|
|
$flag_stop_level = $level;
|
|
|
|
if (0 != count($last_node)) {
|
|
$this->html .= $this->getEntry($last_node, $level, 3);
|
|
} else {
|
|
// WARNING: if there's no previous take the first menu entry - you might not like this rule!
|
|
reset($this->menu);
|
|
list($node_id, $first_node) = each($this->menu);
|
|
$this->html .= $this->getEntry($first_node, $level, 3);
|
|
}
|
|
|
|
if (0 != count($up_node)) {
|
|
$this->html .= $this->getEntry($up_node, $level, 5);
|
|
} else {
|
|
// WARNING: if there's no up take the first menu entry - you might not like this rule!
|
|
reset($this->menu);
|
|
list($node_id, $first_node) = each($this->menu);
|
|
$this->html .= $this->getEntry($first_node, $level, 5);
|
|
}
|
|
} else if (isset($this->path[$level]) && $this->path[$level] == $node_id) {
|
|
// processed menu item is part of the path to the active menu item
|
|
$type = 2;
|
|
} else {
|
|
$type = 0;
|
|
}
|
|
|
|
// remember the last (<< prev) node
|
|
$last_node = $node;
|
|
|
|
// follow the subtree if the active menu item is in it
|
|
if ($type && isset($node['sub'])) {
|
|
$up_node = $node;
|
|
$flag_stop_level = $this->buildMenu($node['sub'], $level + 1, (-1 != $flag_stop_level) ? $flag_stop_level + 1 : -1);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
return ($flag_stop_level) ? $flag_stop_level - 1 : -1;
|
|
}
|
|
|
|
/**
|
|
* Build the menu recursively.
|
|
*
|
|
* @param array first call: $this->menu, recursion: submenu
|
|
* @param int level of recursion, current depth in the tree structure
|
|
*/
|
|
function buildSitemap($menu, $level = 0) {
|
|
// loop through the (sub)menu
|
|
foreach ($menu as $node_id => $node) {
|
|
if ($this->current_url == $node['url']) {
|
|
// menu item that fits to this url - 'active' menu item
|
|
$type = 1;
|
|
} else if (isset($this->path[$level]) && $this->path[$level] == $node_id) {
|
|
// processed menu item is part of the path to the active menu item
|
|
$type = 2;
|
|
} else {
|
|
// not selected, not a part of the path to the active menu item
|
|
$type = 0;
|
|
}
|
|
|
|
$this->html .= $this->getEntry($node, $level, $type);
|
|
|
|
// follow the subtree if the active menu item is in it
|
|
if (isset($node['sub']))
|
|
$this->buildSitemap($node['sub'], $level + 1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the HTML of one menu item.
|
|
*
|
|
* @param array menu item data (node data)
|
|
* @param integer level in the menu tree
|
|
* @param integer menu item type: 0, 1, 2. 0 => plain menu item,
|
|
* 1 => selected (active) menu item, 2 => item
|
|
* is a member of the path to the selected (active) menu item
|
|
* 3 => previous entry, 4 => next entry
|
|
* @return string HTML
|
|
* @see buildMenu()
|
|
*/
|
|
function getEntry(&$node, $level, $item_type) {
|
|
$html = '';
|
|
$indent = '';
|
|
if ('tree' == $this->menu_type) {
|
|
// tree menu
|
|
$html .= '<tr>';
|
|
if ($level)
|
|
for ($i = 0; $i < $level; $i++)
|
|
$indent .= ' ';
|
|
}
|
|
|
|
// draw the <td></td> cell depending on the type of the menu item
|
|
switch ($item_type) {
|
|
case 0:
|
|
// plain menu item
|
|
$html .= sprintf('<td>%s<a href="%s">%s</a></td>',
|
|
$indent,
|
|
$node['url'],
|
|
$node['title']
|
|
);
|
|
break;
|
|
|
|
case 1:
|
|
// selected (active) menu item
|
|
$html .= sprintf('<td>%s<b>%s</b></td>',
|
|
$indent,
|
|
$node['title']
|
|
);
|
|
break;
|
|
|
|
case 2:
|
|
// part of the path to the selected (active) menu item
|
|
$html .= sprintf('<td>%s<b><a href="%s">%s</a></b>%s</td>',
|
|
$indent,
|
|
$node['url'],
|
|
$node['title'],
|
|
('urhere' == $this->menu_type) ? ' >> ' : ''
|
|
);
|
|
break;
|
|
|
|
case 3:
|
|
// << previous url
|
|
$html .= sprintf('<td>%s<a href="%s"><< %s</a></td>',
|
|
$indent,
|
|
$node['url'],
|
|
$node['title']
|
|
);
|
|
break;
|
|
|
|
case 4:
|
|
// next url >>
|
|
$html .= sprintf('<td>%s<a href="%s">%s >></a></td>',
|
|
$indent,
|
|
$node['url'],
|
|
$node['title']
|
|
);
|
|
break;
|
|
|
|
case 5:
|
|
// up url ^^
|
|
$html .= sprintf('<td>%s<a href="%s">^ %s ^</a></td>',
|
|
$indent,
|
|
$node['url'],
|
|
$node['title']
|
|
);
|
|
break;
|
|
}
|
|
|
|
if ('tree' == $this->menu_type)
|
|
$html .= '</tr>';
|
|
|
|
return $html;
|
|
}
|
|
|
|
/*
|
|
* Returns the path of the current page in the menu 'tree'.
|
|
*
|
|
* @return array path to the selected menu item
|
|
* @see buildPath(), $urlmap
|
|
*/
|
|
function getPath() {
|
|
$this->current_url = $this->getCurrentURL();
|
|
$this->buildPath($this->menu, array());
|
|
|
|
while ($this->current_url && !isset($this->urlmap[$this->current_url]))
|
|
$this->current_url = substr($this->current_url, 0, -1);
|
|
|
|
return $this->urlmap[$this->current_url];
|
|
}
|
|
|
|
/**
|
|
* Computes the path of the current page in the menu 'tree'.
|
|
*
|
|
* @param array first call: menu hash / recursion: submenu hash
|
|
* @param array first call: array() / recursion: path
|
|
* @return boolean true if the path to the current page was found,
|
|
* otherwise false. Only meaningful for the recursion.
|
|
* @global $PHP_SELF
|
|
* @see getPath(), $urlmap
|
|
*/
|
|
function buildPath($menu, $path) {
|
|
// loop through the (sub)menu
|
|
foreach ($menu as $node_id => $node) {
|
|
// save the path of the current node in the urlmap
|
|
$this->urlmap[$node['url']] = $path;
|
|
|
|
// we got'em - stop the search by returning true
|
|
// KLUDGE: getPath() works with the best alternative for a URL if there's
|
|
// no entry for a URL in the menu hash, buildPath() does not perform this test
|
|
// and might do some unneccessary recursive runs.
|
|
if ($node['url'] == $this->current_url)
|
|
return true;
|
|
|
|
// current node has a submenu
|
|
if (isset($node['sub'])) {
|
|
|
|
// submenu path = current path + current node
|
|
$subpath = $path;
|
|
$subpath[] = $node_id;
|
|
|
|
// continue search recursivly - return is the inner loop finds the
|
|
// node that belongs to the current url
|
|
if ($this->buildPath($node['sub'], $subpath))
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// not found
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns the URL of the currently selected page.
|
|
*
|
|
* The returned string is used for all test against the URL's
|
|
* in the menu structure hash.
|
|
*
|
|
* @return string
|
|
*/
|
|
function getCurrentURL() {
|
|
return $GLOBALS[$this->url_env_var];
|
|
}
|
|
}
|
|
?>
|