Free cypress tree manor software for linux

Image Tree is a complete and versatile photo publishing system in less than 200 lines of code.

ImgTree is based only on three files:

index php : contains all the php and html code. Must be put, unmodified in every folder of the directory tree.
data.php : contains the specific settings of every folder
style.css : the css style sheet

Every folder of the folder tree must contain the three files. Clearly index.php and style.php should be simply linked:

imgtree/
|-- data.php
|-- index.php
|-- style.css
|-- Section-A
| |-- data.php
| |-- index.php -> ../index.php
| |-- style.css -> ../style.css
| |-- 01-thumb.jpg
| |-- 01.jpg
| |-- 02-thumb.jpg
| |-- 02.jpg
| `-- ...
`-- Section-B
|-- data.php
|-- index.php -> ../index.php
|-- style.css -> ../style.css
|-- 00.jpg
|-- Subsection-B1
| |-- data.php
| |-- index.php -> ../index.php
| `-- style.css -> ../style.css
| |-- cover.jpg
`-- Subsection-B2
|-- data.php
|-- index.php -> ../index.php
|-- style.css -> ../style.css
|-- 01-thumb.jpg
|-- 01.jpg
|-- 02-thumb.jpg
|-- 02.jpg
`-- ...

Every folder act as a section and the behaviour can be choose between:

index : Contains a list of links to every subfolder of the current folder. For every section an image and a description are shown.
thumb : Thumbnails page. Shows every image file of the folder. Thumbnail must be named "xxx-thumb.jpg" for the xxx.jpg file. Ex: 01-thumb.jpg -> 01.jpg ; tramonto-thumb.jpg -> tramonto.jpg ; ecc.
cover : Cover page. Shows an image, a text and an associated link

The file data.php contin the settings specific for every section:

$gallerystart : is the gallery start to generate the back-menu. The path must be relative to the starting folder of the site
$name : name used to link the current section in the menus
$title : page title
$description: description, used as subtitle and for brief description in index pages
$indeximage : image used in index pages to link this section
$type : type of the page (cover|thumb|index)
$imgtitle : associtive array of the images descriptions. Used only by "thumb" pages
$coverimage : image used by "cover" pages
$covertext : text used by "cover" pages
$coverlink= : link used by "cover" pages
$covertitle : title used by "cover" pages

NEEDS a web server (Apache or similar) with PHP support

Deluxe Tree is a powerful, JavaScript-based site navigation menu. Deluxe Tree is a versatile, ready-made solution that allows professional and amateur Web developers to create superior navigation systems for their Web sites and Web applications.
It supports a special JavaScript API to change your menu "on-the-fly", animation effects, floating, drag-n-drop, state saving, XP Style, relative and absolute positions, animated icons and arrows, normal state, mouseover state, expanded state, unlimited submenus, separators, lines, and more.
Main features:
Compatibility
- Full cross-browser compatibility including IE, Netscape, Mozilla, Opera, Firefox, Konqueror and Safari
- on Windows, Mac OS and Linux
- Section 508 compliant
- Support for any doctypes
- Menu can be populated from a database using ASP, PHP, etc.
Seamless Integration
- Multiple menus on the same page
- Friendly to other scripts and css styles
- Any HTML code can be used within menu items
High Performance
- Generally loads faster than other page elements
- Performs perfectly with unlimited number of submenus and items
Easy Setup
- Comprehensible menu parameters for manual editing
Professional Look-n-Feel
- Fully customizable appearance, individual styles for each element
- Animation effects for submenus in XP Style
Unique Features
- Dragable, floating, state-saving menus
- Special JavaScript API for changing menu "on-the-fly"
Cost Effective
- Starts at just $39.95. Buy Now!
- Free for non-profit websites. Order Now!
- Full-functional free trial version.
Enhancements:
- Several .js modules were added.
- A special JavaScript API was added to change your menu "on-the-fly".
- New animation effects were added.

Tree::BPTree is a Perl implementation of B+ trees.

SYNOPSIS

use Tree::BPTree;

# These arguments are actually the defaults
my $tree = new Tree::BPTree(
-n => 3,
-unique => 0,
-keycmp => sub { $_[0] cmp $_[1] },
-valuecmp => sub { $_[0] $_[1] },
);

# index the entries in this string:
my $string = "THERES MORE THAN ONE WAY TO DO IT"; # TMTOWTDI
my $i = 0;
$tree->insert($_, $i++) foreach (split //, $string);

# find the index of the first T
my $t = $tree->find(T);

# find the indexes of every T
my @t = $tree->find(T);

# We dont like the word WAY , so lets remove it
my $i = index $string, W;
$tree->delete($_, $i++) foreach (split //, substr($string, $i, 4));

# Reverse the sort order
$tree->reverse;

# Iterate through each key/value pair just like built-in each operator
while (my ($key, $value) = $tree->each) {
print "$key => $valuen";
}

# Reset the iterator when we quit from an "each-loop" early
$tree->reset;

# You might also be interested in using multiple each loops at once, which is
# possible through the cursor syntax. You can even delete individual pairs
# from the list during iteration.
my $cursor = $tree->new_cursor;
while (my ($key, $value) = $cursor->each) {
my $nested = $tree->new_cursor;
while (my ($nkey, $nvalue) = $nested->each) {
if ($key->shouldnt_be_in_this_tree_with($nkey)) {
$nested->delete;
}
}
}

# Iterate using an iterator subroutine
$tree->iterate(sub { print "$_[0] => $_[1]n" });

# Iterate using an iterator subroutine that returns the list of return values
# returned by the iterator
print join(, , $tree->map(sub { "$_[0] => $_[1]" })),"n";

# Grep-like operations
my @pairs = $tree->grep (sub { $_[0] =~ /S/ });
my @keys = $tree->grep_keys (sub { $_[0] =~ /S/ });
my @values = $tree->grep_values (sub { $_[0] =~ /S/ });

# Get all keys, values
my @all_keys = $tree->keys;
my @all_values = $tree->values;

# Clear it out and start over
$tree->clear;

B+ trees are balanced trees which provide an ordered map from keys to values. They are useful for indexing large bodies of data. They are similar to 2-3-4 Trees and Red-Black Trees. This implementation supports B+ trees using an arbitrary n value.

Suffix tree implementation library is a C library, an implementation of the suffix trees algorithm to store/retrieve key/data pairs.
The main advantages are a linear indexing time, little memory usage, and very fast retrieving.
It has been developped on FreeBSD/gcc but should be fairly portable.
The source code "testsfx.c" show an example of how to use the library both for inserting, retrieving, and deleting data. There arent many functions and comments should be enough to give you an idea of how to use the library. (read the header of the source file)
You should edit sfxdisk.h to suit your needs: you can change the alphabet size and the offset type. It should be OK to use "long long" 64 bits ints instead of long, in fact I tested it succesfully but havent gone to the point of filling more than 2 GB of data (needless to say you need a 64 bits filesystem).
Two "tools" come with the library (new with version 1.2): dumpsfx and loadsfx. dumpsfx is used to dump the database: dumpsfx [-s separator] if you want to output the result as readable text or dumpsfx < file.sfx > -h to output it for reloading with loadsfx.
dumpsfx outputs on stdout and loadsfx reads from stdin. loadsfx < suffix tree file to create > < dumped_file
Enhancements:
- removed an useless offset incrementation in STwritenode

Linguistic Tree Constructor is a free program for building linguistic syntax trees from text. Linguistic Tree Constructor lets the user build the tree in a point-and-click fashion.
The program does no analysis on its own -- the user is completely free to draw the tree however he or she wishes. However, the program makes sure that the tree is a tree and not some other kind of graph.
Syntactic theories supported
Three "flavors" of trees are supported:
- "Generic" syntax trees,
- X-Bar syntax trees
- RRG (Role and Reference Grammar) syntax trees (the LSC and the LSNP)
Labeling of nodes
- The program supports adding "labels" to nodes. These labels are userdefinable, and can be used for such things as:
- Rhetorical Structure Theory analyses
- Other discourse-level analyses
- RRG operator-projection analyses
- Subject-Object-Predicate analyses
Main features:
- Draw syntax trees using point-and-click
- Both tree-view and brackets-view are supported
- Supports up to five interlinear lines at word-level
- Interlinear lines can be switched on and off individually
- Change magnification
- Unlimited undo
- Copy (parts of) tree to clipboard as BMP
- Printing + Print Preview
- Uses any font (even Unicode fonts)
- Supports right-to-left languages as well as left-to-right
- Import from straight text (plain text)
- Import from word-per-record SFM interlinear text
- ... and many more...
Enhancements:
- A number of crashes were fixed.
- A bug with magnification on OS X was fixed.
- The speed of interaction with the program was improved.

Rubytree is a simple to use general purpose tree data structure implementation in Ruby.
It provides easy access methods for navigating the hierarchy, as well as for accessing the nodes. Rubytree project also provides ability to marshal the entire tree structure.
Enhancements:
- Minor changes were made to the documentation.

Tree::Binary is a Object Oriented Binary Tree for Perl.

SYNOPSIS

use Tree::Binary;

# a tree representaion of the expression:
# ((2 + 2) * (4 + 5))
my $btree = Tree::Binary->new("*")
->setLeft(
Tree::Binary->new("+")
->setLeft(Tree::Binary->new("2"))
->setRight(Tree::Binary->new("2"))
)
->setRight(
Tree::Binary->new("+")
->setLeft(Tree::Binary->new("4"))
->setRight(Tree::Binary->new("5"))
);
# Or shown visually:
# +---(*)---+
# | |
# +-(+)-+ +-(+)-+
# | | | |
# (2) (2) (4) (5)

# get a InOrder visitor
my $visitor = Tree::Binary::Visitor::InOrderTraversal->new();
$btree->accept($visitor);

# print the expression in infix order
print $visitor->getAccumulation(); # prints "2 + 2 * 4 + 5"

# get a PreOrder visitor
my $visitor = Tree::Binary::Visitor::PreOrderTraversal->new();
$btree->accept($visitor);

# print the expression in prefix order
print $visitor->getAccumulation(); # prints "* + 2 2 + 4 5"

# get a PostOrder visitor
my $visitor = Tree::Binary::Visitor::PostOrderTraversal->new();
$btree->accept($visitor);

# print the expression in postfix order
print $visitor->getAccumulation(); # prints "2 2 + 4 5 + *"

# get a Breadth First visitor
my $visitor = Tree::Binary::Visitor::BreadthFirstTraversal->new();
$btree->accept($visitor);

# print the expression in breadth first order
print $visitor->getAccumulation(); # prints "* + + 2 2 4 5"

# be sure to clean up all circular references
$btree->DESTROY();

This module is a fully object oriented implementation of a binary tree. Binary trees are a specialized type of tree which has only two possible branches, a left branch and a right branch. While it is possible to use an n-ary tree, like Tree::Simple, to fill most of your binary tree needs, a true binary tree object is just easier to mantain and use.

Binary Tree objects are especially useful (to me anyway) when building parse trees of things like mathematical or boolean expressions. They can also be used in games for such things as descisions trees. Binary trees are a well studied data structure and there is a wealth of information on the web about them.

This module uses exceptions and a minimal Design By Contract style. All method arguments are required unless specified in the documentation, if a required argument is not defined an exception will usually be thrown. Many arguments are also required to be of a specific type, for instance the $tree argument to both the setLeft and setRight methods, must be a Tree::Binary object or an object derived from Tree::Binary, otherwise an exception is thrown. This may seems harsh to some, but this allows me to have the confidence that my code works as I intend, and for you to enjoy the same level of confidence when using this module. Note however that this module does not use any Exception or Error module, the exceptions are just strings thrown with die.

This object uses a number of methods copied from another module of mine, Tree::Simple. Users of that module will find many similar methods and behaviors. However, it did not make sense for Tree::Binary to be derived from Tree::Simple, as there are a number of methods in Tree::Simple that just wouldnt make sense in Tree::Binary. So, while I normally do not approve of cut-and-paste code reuse, it was what made the most sense in this case.