Free directory tree software for linux

Open Directory in VLC is just a modified version of the Open in Kaffeine service menu.

I use it to open DVD/VIDEO_TS folders. VLC plays them with menus in tact.

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

Site Editor is a CGI script which allows a user to manage their web space without needing ftp access.

With only a web browser you can browse your web space, edit text files, upload files, and create and remove directories. Site Editor also has ZIP support making it easy to grab an entire directory tree.

Site Editor is completely functional but is missing some features and polish which would make it easier to use. Currently it requires access control to be handled by the web server. On top of this the code is a little raw, hence this is not a 1.0 release.

To configure for your system the "site_editor" script needs to be modified slightly. In the "Config" section edit the following variables:

$BASE_DIR Root directory for editing files.
$BASE_URL Web location for $BASE_DIR files. Can be relative or absolute.
$TITLE Title prefix to be used for each page.
$ICON_URL Location of icons. It may be relative or absolute.
$ZIP The full path to your Info-ZIP binary. Comment to disable.

I have included a simple patch to Apaches suexec which will allow the script to be root owned. With suexec and the script owned by root the user wont be able to modify the scripts configuration but will still be able to create and modify their own files.

Any comments and suggestions are welcome.

Iterator::IO is a Perl module with filesystem and stream iterators.

SYNOPSIS

use Iterator::IO;

# Return the names of files in a directory (except . and ..)
$iter = idir_listing ($path);

# Return all the files in a directory tree, one at a time.
# Like File::Find, in slow motion.
$iter = idir_walk ($path);

# Return the lines of a file, one at a time.
$iter = ifile ($filename, %options);

# Return the lines of a file, in reverse order
$iter = ifile_reverse ($filename, %options);

This module provides filesystem and stream iterator functions. See the Iterator module for more information about how to use iterators.

FUNCTIONS

idir_listing

$iter = idir_listing ($path);

Iterator that returns the names of the files in the $path directory. If $path is omitted, defaults to the current directory. Does not return the . and .. files (under unix).

Requires IO::Dir and Cwd.

Example:

To return only certain files, combine this with an igrep:

$iter = igrep {-s && -M < 1} idir "/some/path";

(Returns non-empty files modified less than a day ago). (igrep) is defined in the Iterator::Util module).

idir_walk

$iter = idir_walk ($path);

Returns the files in a directory tree, one by one. Its sort of like File::Find in slow motion.

Requires IO::Dir and Cwd.

ifile

$iter = ifile ($filename, %options);

Opens a file, generates an iterator to return the lines of the file.
%options is a reference to a hash of options. Currently, two options are supported:

chomp

chomp => boolean indicates whether lines should be chomped before being returned by the iterator. The default is true.

$/

$/ => value specifies what string to use as the record separator. If not specified, the current value of $/ is used.

"rs" or "input_record_separator" may be used as option names instead of "$/", if you find that to be more readable. See the English module.

Option names are case-insensitive.

ifile requires IO::File.
ifile_reverse

$iter = ifile_reverse ($filename, %options);

Exactly the same as "ifile", but reads the lines of the file backwards.
The input_record_separator option values undef (slurp whole file) and scalar references (fixed-length records) are not currently supported.

INTERFACE CHANGE

In version 0.01 of Iterator::IO, the "ifile" and ifile_reverse functions accepted their options in a different manner. This has now changed to operate via a hash reference of options. The old way will still work, but is deprecated and will be removed in a future release.

EXPORTS

This module exports all function names to the callers namespace by default.

DIAGNOSTICS

Iterator::IO uses Exception::Class objects for throwing exceptions. If youre not familiar with Exception::Class, dont worry; these exception objects work just like $@ does with die and croak, but they are easier to work with if you are trapping errors.

See the Iterator module documentation for more information on how to trap and handle these exception objects.

Parameter Errors

Class: Iterator::X::Parameter_Error

You called an Iterator::IO function with one or more bad parameters. Since this is almost certainly a coding error, there is probably not much use in handling this sort of exception.

As a string, this exception provides a human-readable message about what the problem was.

Exhausted Iterators

Class: Iterator::X::Exhausted

You called value on an iterator that is exhausted; that is, there are no more values in the sequence to return.

As a string, this exception is "Iterator is exhausted."

I/O Errors

Class: Iterator::X::IO_Error

This exception is thrown when any sort of I/O error occurs; this only happens with the filesystem iterators.

This exception has one method, os_error, which returns the original $! that was trapped by the Iterator object.

As a string, this exception provides some human-readable information along with $!.

Internal Errors

Class: Iterator::X::Internal_Error

Something happened that I thought couldnt possibly happen. I would appreciate it if you could send me an email message detailing the circumstances of the error.

Bio::Tree::Tree is an implementation of TreeI interface.

SYNOPSIS

# like from a TreeIO
my $treeio = new Bio::TreeIO(-format => newick, -file => treefile.dnd);
my $tree = $treeio->next_tree;
my @nodes = $tree->get_nodes;
my $root = $tree->get_root_node;

This object holds handles to Nodes which make up a tree.

Bio::Tree::DistanceFactory is a Perl module to construct a tree using distance based methods.

SYNOPSIS

use Bio::Tree::DistanceFactory;
use Bio::AlignIO;
use Bio::Align::DNAStatistics;
my $tfactory = Bio::Tree::DistanceFactory->new(-method => "NJ");
my $stats = Bio::Align::DNAStatistics->new();

my $alnin = Bio::AlignIO->new(-format => clustalw,
-file => file.aln);
my $aln = $alnin->next_aln;
# Of course matrix can come from a different place
# like PHYLIP if you prefer, Bio::Matrix::IO should be able
# to parse many things
my $jcmatrix = $stats->distance(-align => $aln,
-method => Jukes-Cantor);
my $tree = $tfactory->make_tree($jcmatrix);

This is a factory which will construct a phylogenetic tree based on the pairwise sequence distances for a set of sequences. Currently UPGMA (Sokal and Michener 1958) and NJ (Saitou and Nei 1987) tree construction methods are implemented.

XML::Simple::Tree is a tree object extension for XML::Simple data structures.

SYNOPSIS

## script 1
## create XML::Simple::Tree object and do a preorder traversal

## create XML::Simple::Tree object from an xml document ($xml_file)
my $xml_obj = XML::Simple::Tree->new(file => directory.xml,
node_key => dir,
target_key => name);

## sub set_do_node() method takes subroutine reference to be executed at current node
$xml_obj->set_do_node(
sub {
my $self = $xml_obj;

my $cnode = $self->get_cnode();
my $level = $self->get_level();
my $padding = * x ($level + 1);

print "$padding$cnode->{name}[0]n";
}
);

## sub set_do_leaf() method takes subroutine reference to be executed at leaf node
$xml_obj->set_do_leaf(
sub {
my $self = $xml_obj;

print "n";
}
);

## Tree pre order traversal method that executes do_node() at each node and do_leaf() at each leaf
$xml_obj->traverse();


## script 2
## find a node and retrieve a parameter.

my $xml_obj =
XML::Simple::Tree->new(
file => $xml_file,
node_key => directory,
target_key => name
);

my $want_node = $xmlObj->find_node($target_directory);
my $mtime = $want_node->{mtime}[0];

## script 3
## find a node and cut (remove) it from tree.

my $cut_name = bin;

my $mainXml =
XML::Simple::Tree->new( file => $xml_file,
node_key => directory,
target_key => name);

$mainXml->cut_node($cut_name);

## script 4
## take XML::Simple::Tree object and paste it into a target node of another
## convert it back to xml

my $target_dir = xxx;

my $cut_tree =
XML::Simple::Tree->new(file => $cut_xml_file,
node_key => directory,
target_key => name);

$config_tree->paste_node($target_dir, $cut_tree->get_cnode()->{directory}[0]);

## convert to xml
my $xml = $config_tree->toXML();

## Additional examples can be found in the included tests.

This module extends XML::Simple by taking the data structure returned by XML::Simple::XMLin($xml_file, forcearray => 1) and putting it in a class complete with tree manipulation and traversal methods. Important to know is that XMLin is called with the option ForceArray => 1. This option forces nested elements to be represented as arrays even when there is only one.