Free menu 2.02 software for linux

Javascript::Menu is a NumberedTree that generates HTML and Javascript code for
a menu.

SYNOPSIS

use Javascript::Menu;

# Give it something to do (example changes the menus caption):

my $action = sub {
my $self = shift;
my ($level, $unique) = @_;

my $value = $self->getValue;
return "getElementById(caption_$unique).innerHTML=$value";
};


# Build the tree:

my $menu = Javascript::Menu->convert(tree => $otherTree, action => $action);

my $menu = Javascript::Menu->readDB(source_name => $table, source => $dbh,
action => $action);

my $menu = Javascript::Menu->new(value => Please select a parrot,
action => $action);

my $blue = $menu->append(value => Norwegian Blue);
$blue->append(value => Pushing up the daisies);
$menu->append(value => A Snail);

# Or maybe you just want a navigational menu?

my $menu = Javascript::Menu->new(value => Please select a prime minister);
$menu->append(value => Ariel Sharon,
URL => www.corruption.org/ariel_sharon.htm);

$menu->append(value => Benjamin Netanyahu,
URL => www.corruption.org/bibi.htm);

$menu->append(value => Shaul Mofaz, URL => www.martial_law.org);


# Print it out as a right-to-left menu:

my $css = $menu->buildCSS($menu->reasonableCSS);
print $cgi->start_html(-script => $menu->baseJS(rtl),
-style => $css); #CSS plays an important role.
print $tree->getHTML;

Javascript::Menu is an object that helps in creating the HTML, Javascript, and some of the CSS required for a table-based menu. There are a few other modules that deal with menus, But as I browsed through them, I found that none of them exactly fitted my needs. So I designed this module, with the following goals in mind:

Flexibility

The main feature of this module is the ability to supply all nodes or any specific node with a subroutine that is activated in time of the code generation to help decide what the item will do when it is clicked. This allows customisation far beyond associating a link with every item. Multy-level selection menus become very easy to do (and this is, in fact, what I needed when I started writing this).

I18n

Working with i18n (internationalization) can be a big headache. Working with Hebrew (or Arabic) forces you not only to change your charachters, but also to change your direction of writing. I incorporated into this module the ability to produce right-to-left menus and tested it using a legacy ASCII-based encoding (iso-8859-8).

Object Hierarchy

I designed the module to work with two other modules of mine, Tree::Numbered and Tree::Numbered::DB, which simplify the task of building the menu and allow for construction of a menu from database information.

The current version adds support for highlighting the item thats hovered over. Youll find that having made some preliminary steps, like tweaking the CSS to look the way you like it to, the rest is fairly easy.

Menu Buddy plugin currently comprises a couple of Python scripts for creating GNOME panel menus from a directory hierarchy of music files.
These menus can be used to play or enqueue songs in XMMS, as well as pause or skip XMMS.
These scripts are not terribly powerful yet, but there is potential for a signficantly more flexible system of menu-creation that allows automatic construction of many different kinds of menus based on directory hierarchies.
menu_buddy is a small script for scanning a hierarchy of music files and creating a set of Gnome menus that can direct xmms to play those files. Instead of going through the command line or whatever, menu_buddy lets you play/enqueue files in xmms straight from your menu. I find this pretty convenient.
The command line for menu_buddy is as follows:
menu_buddy < source dir > < dest dir >
where:
< source dir >: The top of a hierarchy of directories containing the files
< dest dir >: The top of a directory to write the menu files into
menu_buddy works with the assumption that you have your music stored under one main music directory, using some meaningful hierarchy, and that theres only music stored down there. menu_buddy doesnt do any sort of file-type checking and assumes that everything under is fair game for playing in xmms.
What menu_buddy does it this: it constructs a menu hierarchy that directly matches the hierarchy under such that any directory or tree thereof can be played or enqueued in xmms. Likewise, at the top of the menu structure, it creates menu option which allow you to pause, start, or skip forward/backward in xmms. The interaction with xmms is purely in terms of command line options that you can pass to xmms...there is no special linking or whatever.
So, for example, lets assume you have all of your music in under the directory "/music", with top-level folders for different genres (i.e. /music/rock, /music/polka, etc.). Inside each genre, you have your files sorted first by artist, then by album (i.e. /music/rock/faith_no_more/the_real_thing, /music/polka/the_polka_kings/greatest_hits). The organization you have is really unimportant, but bear with me here.
Further, lets assume that your system lets you create new gnome menus by putting menu files in ~/.gnome/apps (this is how things work on my system, but honestly Ive done next to zero research into this topic...it may vary (wildly) on your system, so I suggest you figure it out for yourself). Then, the following command will create a new menu hierarchy in your "favorites" menu called "Muzik" which allows you play/enqueue your music:
menu_buddy /music ~/.gnome/apps/Muzik
Thats it. It may take a few seconds to churn through your music files, depending on other system load and how much music you have. You need to be able, of course, to write to the output directory you specify, but since it will typically be in your home directory this should not be a problem.
Enhancements:
- added GPL stuff to source files

AI::Menu is a Perl object that generates Tree::Nary objects from directed graphs or a description of the function set.

The algorithm is not very efficient (approximately O(F^6), F being the number of functions). It is also not quite as intelligent as it should be. You should cache the results instead of repeatedly calculating them.

As the algorithm is optimized or more efficient algorithms are found, they will be incorporated. The interface for generating the trees should not change too much. The resulting object might become a Tree::Nary object encased in an AI::Menu object.

SYNOPSIS

use AI::Menu;

my $factory = new AI::Menu::Factory;

my $menu = $factory->generate($hash_of_functions);
my $menu = $factory->generate($hash_of_functions, $hash_of_categories);
my $menu = $factory->generate($graph);

METHODS

All of the following methods (except generate) are available in the new function when creating the AI::Menu::Factory object.

generate

This function does some housekeeping before calling a configurable module to generate the tree.

If called with a single hash reference, the hash is assumed to be a list of functions mapping to array references containing a list of categories. It is further assumed that the sets of function names and category names are disjoint. A closure is created for the leaf_q function which returns true if its argument is a key in the hash reference. The complete graph is created from this single hash reference: if a category can reach another category through a function, then an edge is inserted between the two categories. This edge is bidirectional.

If called with two hash references, the first hash is treated as before, but the second hash reference is considered a mapping of categories to categories. This second hash is used instead of automatically generating the information from the first hash.

If called with a single object that is not a hash reference, then the argument is considered a graph object (usually of Graph::Directed). The leaf_q function will need to be defined.

leaf_q

This function returns true if the argument represents a function (leaf in the graph). It returns false if the argument represents a category. This may be set either when the AI::Menu::Factory object is created or through a method call. The method call with no argument returns the current function.

maker

This is the package used to create the menu from the graph. The following call is made:

my $menu = $self -> {maker} -> new(
width => $self->{width},
weight_f => $self -> {weight_f},
leaf_q => $leafq,
);

return $menu -> generate_tree($g, $optscore);

The $optscore value is the score for the optimum tree. Once a tree is found with this score, searching should stop.

new

Creates an AI::Menu::Factory object. Optional arguments are key/value pairs taken from this list of methods except for generate and new.

weight_f

This function is used to calculate the edge weights in the graph. It is called with four arguments: the object generating the tree, the graph object, the originating vertex, the destination vertex. The function should return undef for an infinite weight.

width

This is the desired number of children per node. The optimal number (and default) is three.

k-menu is a SuperKaramba theme that emulates KDE kicker.

Spamfilter project is meant to be used via the .qmail files that the qmail mail system uses to control what to do with incoming emails. This program will give you the opportunity to control which mails you want to receive and which are to be thrown away.

It does this by checking if the mail is directly addressed or not, and then checking various configuration files to see what to do. The two most important files are .allow and .deny that should reside in your home directory.

.allow will let the addresses defined in it through even if they are not directly addressed. .deny will deny the addresses defined in it even if they have mailed you directly.

Sten Donslund has made a very interesting patch that will be made into a new version later.

XDG-Menu project is a ROX panel applet that displays an applications menu button. The menus it builds fit the XDG Menu Specification published by freedesktop.org.
Main features:
- Applications menu based on XDG standards with capabilities to launch applications by mouse click and dragging items to pinboard, panel and file manager window.
- Configurable ROX applications submenu with capabilities to launch applications by mouse click, dragging items to pinboard, panel and file manager window, and context menu capabilities for each ROX-application.
- Logout menu item.

CGI::Expand is a Perl module that can convert flat hash to nested data using TT2s dot convention.

SYNOPSIS

use CGI::Expand;
use CGI; # or Apache::Request, etc.

$args = expand_cgi( CGI->new(a.0=3&a.2=4&b.c.0=x) );
# $args = { a => [3,undef,4], b => { c => [x] }, }

# Or to catch exceptions:
eval {
$args = expand_cgi( CGI->new(a.0=3&a.2=4&b.c.0=x) );
} or log_and_exit( $@ );

#-----
use CGI::Expand qw(expand_hash);

$args = expand_hash({a.0=>77}); # $args = { a => [ 77 ] }

Converts a CGI query into structured data using a dotted name convention similar to TT2.

expand_cgi works with CGI.pm, Apache::Request or anything with an appropriate "param" method. Or you can use expand_hash directly.

If you prefer to use a different flattening convention then CGI::Expand can be subclassed.