Free ai menu software for linux

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.

Cabextract menu is just a little service menu that I put together for extracting MS .cab files.

It creates a directory with the same base name in the same directory as the .cab file and extracts to it. To use it, you have to have cabextract installed (and can be found here http://www.kyz.uklinux.net/cabextract.php.

encFS service menu one little KDE service menu for encFS directory.

Installation:

ungzip and copy in ~/.kde/share/apps/konqueror/servicemenus

Usage:

Click on encFS directory and click on mount.

For unmounting, click on origin directory and click on umount, this unmount and remove destination directory.

READ THIS PLEASE:

This script create a directory in your home with name encFS_$DIR. For to mount correctly, this directory must not exist.

Personal Menu allows your menus to look more compact and personal.
Feel tired of the conservative menus, and have tried many extensions to make them look more compact and personal?
With the Personal Menu, you can hide the menus in Menus Toolbar (even the Menus Toolbar), and design your own menu with just few settings.
It also offers a History Button and a Bookmarks Button. You can set how many hitory items show in the menu, and what will happen when you middle/right click the buttons.
Version restrictions:
- The current version 2.3 has a known bug, which makes the option panel hangs when using Firefox 1.5.
- Itll be fixed in the new version 2.5.1, or you can use the previous version 2.1.3 temporarily.

Deluxe Menus are DHTML Javascript Menu generators.
Compatibility:
- Full cross-browser compatibility including IE, Netscape, Mozilla, Opera, Firefox, Konqueror and Safari on Windows, Mac OS and Linux
- Search engine friendly
- Fits for secure HTTPS sites
- Section 508 compliant
- Support for any doctypes
- Menu can be populated from a database using ASP, PHP, etc
Seamless Integration:
- Cross-frame support - menus work on frameset-based pages
- Visible over select boxes, iframes, flash, Java applets
- Multiple menus on the same page
- Friendly to other scripts and css styles
- Any HTML code can be used within menu items
High Performance:
- AJAX-like technology - loads menu data from the server "on-the-fly".
- Generally loads faster than other page elements
- Performs perfectly with unlimited number of submenus and items
Enhancements:
- Deluxe Tuner was added for Deluxe Menu and Deluxe Tree and Deluxe Tabs.
- The output was made more friendly to search engines.
- New parameters were added for Deluxe Tree.
- Scrolling was added for top-level menus.
- Loading speed was increased.
- Fixes were made for AJAX, dynamic menus, popup menus, and cross-frame mode.

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.

Ktxt2tags Service Menu is a KDE service menu for KTxt2tags software.

sv-ktxt2tags is a ServiceMenu for [KTxt2tags http://www.kde-apps.org/content/show.php?content=48474]

KTxt2tags is a GPL front-end for [txt2tags http://txt2tags.sf.net]

Installation:

Make a simbolic link to the ktxt2tags script in /usr/bin/.

Copy the file sv-ktxt2tags.desktop in /.kde/share/apps/konqueror/servicemenus.

Copy the icon txt2tags.png in /usr/share/pixmaps.

Fedora Package Menu is a service menu for easy installation of downloaded RPMs.

Requires sudo and good configuration of sudo.