NAME

HTML::Menu::Hierarchical - HTML Hierarchical Menu Generator

SYNOPSIS

    my $menu_obj = HTML::Menu::Hierarchical->new($conf, \&callback);
    my $html = $menu_obj->generateMenu($menu_item);

    or

    my $menu_obj = HTML::Menu::Hierarchical->new($conf, [ $obj, $method ]);
    my $html = $menu_obj->generateMenu($menu_item);

    In the first case, the callback is a function.  In the second, the
    callback is a method called on the given object.

    The $conf parameter is a navigation configuration data structure
    (described below).

DESCRIPTION

    HTML::Menu::Hierarchical provides a way to easily
    generate a hierarchical HTML menu without forcing a specific
    layout.  All output is provided by your own callbacks (subroutine
    refs) and your own navigation configuration.

configuration data structure

    A navigation configuration is a reference to an array whose
    elements are hashrefs.  Each hash contains configuration
    information for one menu item and its children, if any.  Consider
    the following example:

    my $conf = [
                { name => 'top_button_1',
                  info => { text => 'Top Level Button 1',
                            url => '/'
                          },
                  children => [
                               { name => 'button_1_level_2',
                                 info => { text => "Child 1 of Button 1",
                                           url => '/child1.cgi'
                                         },
                               },

                              ]
                },

                { name => 'top_button_2',
                  info => { text => 'Top Level Button 2',
                            url => '/top2.cgi'
                          },
                  callback => [ $obj, 'my_callback' ]
                },
                
               ];

    In each hash, the 'name' parameter should correspond to the
    $menu_item parameter passed to the generateMenu() method.
    This is how the module computes which menu item is selected.
    This is generally passed via a CGI parameter, which can be
    tacked onto the end of the url in your callback function.
    Note that this parameter must be unique among all the array
    entries.  Otherwise, the module will not be able to decide
    which menu item is selected.

    The value of the 'info' parameter is available to your
    callback function via the getInfo() method called on the
    HTML::Menu::Hierarchical::ItemInfo object passed to the
    callback function.  In the above example, the 'info'
    parameter contains text to be displayed as the menu item, and
    a url the user is sent to when clicking on the menu item.

    The 'children' parameter is a reference to another array
    containing configuration information for child menu items.
    This is where the Hierarchical part comes in.  There is no
    limit to depth of the hierarchy (until you run out of RAM,
    anyway).

    If a 'callback' parameter is specified that callback will be
    used for that menu item instead of the global callback passed
    to new().

callback functions/methods

    Callback functions are passed a single parameter: an
    HTML::Menu::Hierarchical::ItemInfo object.  See the
    documentation on this object for available methods.  The
    callback function should return the HTML necessary for the
    corresponding menu item.

METHODS

new()

    my $menu_obj = HTML::Menu::Hierarchical->new($conf, \&callback);

generateMenu()

    my $html = $menu_obj->generateMenu($menu_item);

    $menu_item is the 'name' parameter of the selected item,
    typically passed as a CGI parameter.

addChildConf()

    $menu_obj->addChildConf($conf, $menu_item_name);

    Adds another configuration tree into the current
    configuration at the specified node (name of the menu item).

There are also underscore_separated versions of these methods.

    E.g., unescapeHtml($html) becomes unescape_html($html)

EXAMPLES

    See the scripts in the examples subdirectory for example usages.

    See the documentation for HTML::Menu::Hierarchical::ItemInfo for
    methods available via the $info_obj parameter passed to the
    menu_callback function below.

sub menu_callback { my ($info_obj) = @_; my $info_hash = $info_obj->getInfo; my $level = $info_obj->getLevel;

    my $text = $$info_hash{text};
    $text = ' ' if $text eq '';
    my $item_arg = $info_obj->getName;

    # Add a cgi parameter m_i to url so we know which menu
    # item was chosen
    my $url = $info_obj->addArgsToUrl($$info_hash{url},
                                      { m_i => $item_arg });

    my $dpy_text = $info_obj->isSelected ? "<$text&gt" : $text;
    my $spacer = '  ' x $level;
    my $str = qq{<tr>\n};
    $str .= qq{<td bgcolor="#cccc88"><a href="$url">};
    $str .= $spacer . $dpy_text;
    $str .= qq{</a></td>};
    $str .= qq{</tr>\n};
    return $str;
}

TODO

Drop down to first url

Provide a way to skip being selected, e.g., if a menu item is selected that contains no url to go to, default to the first of its children that contains to a url.

Force open

Provide a way to specify that all menu items are open.

Last sibling

Provide a way to tell if the current menu item is the last of its siblings to be displayed.

BUGS

    Please send bug reports/feature requests to don@owensnet.com.

    There are currently no checks for loops in the configuration data
    structure passed to the module.

AUTHOR

    Don Owens <don@owensnet.com>

COPYRIGHT

    Copyright (c) 2003 Don Owens

    All rights reserved. This program is free software; you can
    redistribute it and/or modify it under the same terms as Perl
    itself.

VERSION

    0.05

cpanm HTML::Menu::Hierarchical

perl -MCPAN -e shell
install HTML::Menu::Hierarchical