Free external links software for linux

Sort::External is a Perl module that can sort huge lists.

SYNOPSIS

my $sortex = Sort::External->new( -mem_threshold => 2**24 );
while ( ) {
$sortex->feed($_);
}
$sortex->finish;
while ( defined( $_ = $sortex->fetch ) ) {
&do_stuff_with($_);
}

Problem: You have a list which is too big to sort in-memory.
Solution: "feed, finish, and fetch" with Sort::External, the closest thing to a drop-in replacement for Perls sort() function when dealing with unmanageably large lists.

How it works:

Cache sortable items in memory. Periodically sort the cache and empty it into a temporary sortfile. As sortfiles accumulate, interleave them into larger sortfiles. Complete the sort by sorting the input cache and any existing sortfiles into an output stream.

Note that if Sort::External hasnt yet flushed the cache to disk when finish() is called, the whole operation completes in-memory.

In the CompSci world, "internal sorting" refers to sorting data in RAM, while "external sorting" refers to sorting data which is stored on disk, tape, punchcards, or any storage medium except RAM -- hence, this modules name.

Stringification

Items fed to Sort::External will be returned in stringified form (assuming that the cache gets flushed at least once): $foo = "$foo". Since this is unlikely to be desirable when objects or deep data structures are involved, Sort::External throws an error if you feed it anything other than simple scalars.

Taint and UTF-8 flags

Expert: Sort::External does a little extra bookkeeping to sustain each items taint and UTF-8 flags through the journey to disk and back.

METHODS

new()
my $sortscheme = sub { $Sort::External::b $Sort::External::a };
my $sortex = Sort::External->new(
-mem_threshold => 2**24, # default: 2**20 (1Mb)
-cache_size => 100_000, # default: undef (disabled)
-sortsub => $sortscheme, # default sort: standard lexical
-working_dir => $temp_directory, # default: see below
);

Construct a Sort::External object.

-mem_threshold -- Allow the input cache to consume approximately -mem_threshold bytes before sorting it and flushing to disk. Experience suggests that the optimum setting is somewhere between 2**20 and 2**24: 1-16Mb.
-cache_size -- Specify a hard limit for the input cache in terms of sortable items. If set, overrides -mem_threshold.
-sortsub -- A sorting subroutine. Be advised that you MUST use $Sort::External::a and $Sort::External::b instead of $a and $b in your sub. Before deploying a sortsub, consider using a GRT instead, as described in the Sort::External::Cookbook. Its probably a lot faster.
-working_dir -- The directory where the temporary sortfiles will reside. By default, this directory is created using File::Temps tempdir() command.
feed()

$sortex->feed( @items );

Feed one or more sortable items to your Sort::External object. It is normal for occasional pauses to occur during feeding as caches are flushed and sortfiles are merged.

finish()
# if you intend to call fetch...
$sortex->finish;

# otherwise....
use Fcntl;
$sortex->finish(
-outfile => sorted.txt,
-flags => (O_CREAT | O_WRONLY),
);

Prepare to output items in sorted order.

If you specify the parameter -outfile, Sort::External will attempt to write your sorted list to that location. By default, Sort::External will refuse to overwrite an existing file; if you want to override that behavior, you can pass Fcntl flags to finish() using the optional -flags parameter.

Note that you can either finish() to an -outfile, or finish() then fetch()... but not both.

fetch()
while ( defined( $_ = $sortex->fetch ) ) {
&do_stuff_with($_);
}

Fetch the next sorted item.

This class can be used to keep track of the pages navigated by a user, so it can generate back or next links providing a similar effect to the use of the Javascript history.go() function.
It uses sessions to store an array variable that holds the URL of each page of a site that the user accesses. It can limit the number of pages that are kept in the history array.
It may also ignore pages accessed with the POST method or with certain URLs based on options that define exclusion regular expressions. The class can generate links to go back to the last page or the first page that was recorded.
Enhancements:
- The class is completely changed.
- This release adds creation of several objects of a class, a predefined start page, an expanded list of exceptions, and the methods get_history_back, get_history_next, is_history_back (check back one page), is_history_next (check the next page), get_history_backs (go to the first page), get_history_nexts (go to the last page), and get_history_header (go to the previous and next pages using external parameters).
- It adds history "always", and has more compatibility with javascript:history.go() (no checking previous and next pages).
- New methods have been added for the manipulation of history "always".

MyThreads-Links project is a flexible web based links manager that looks similar to Yahoo but was written in PHP and uses MySQL.
MyThreads-Links uses PHPLib Templates so that its very simple for anyone to change the look and feel of the program without having to edit the code.
Main features:
- Any user can suggest, edit or delete links and categories (and sub-categories),
- links and categories modifications are then validated by the webmaster,
- search engine,
- meta categories (new links, updated links, most requested links),
- optional email notification,
- easy customization since all HTML is in templates (english and french available),
- easy database customization, add some fields in your database and have them managed by myThreads in 5 minutes,
- easy installation with the web based installer.

Links is graphics and text mode WWW browser, similar to Lynx. Links displays tables, frames, downloads on background, uses HTTP/1.1 keepalive connections, and features Javascript.
In graphics mode it displays PNG, JPEG, GIF, TIFF, and XBM pictures, runs external bindings on other types, and features anti-aliased font, smooth image zooming, 48-bit dithering, and gamma and aspect ratio correction.
Main features:
- Links runs on Linux, BSD, UNIX in general, OS/2, Cygwin under Windows, AtheOS, BeOS, FreeMint.
- Links runs in graphics mode (mouse required) on X Window System (UN*X, Cygwin), SVGAlib, Linux Framebuffer, OS/2 PMShell, AtheOS GUI
- Links runs in text mode (mouse optional) on UN*X console, ssh/telnet virtual terminal, vt100 terminal, xterm, and virtually any other text terminal. Mouse is supported for GPM, xterm, and OS/2. Links supports colors on terminal.
- Easy and quick user control via pull-down menu in both text and graphics mode, in 25 languages.
- HTML 4.0 support (without CSS)
- HTTP 1.1 support
- Tables, frames in both graphics and text mode, builtin image display in graphics mode
- Builtin image display for GIF, JPEG, PNG, XBM, TIFF in graphics mode
- Anti-advertisement animation filter in animated GIFs
- Javascript support with full user control over script run
- Bookmarks
- Background file downloads
- Automatic reconnection in case of TCP connection breakdown
- Keepalive connections
- Background (asynchronous) DNS lookup
- Possibility to hook up external programs for all MIME types, possibility to choose one of more programs at every opening.
- 48-bit high-quality image gamma correction, resampling and Floyd-Steinberg dithering in all color depths.
- Font resampling (antialiasing) for virtually unlimited pitch range, LCD optimization of fonts and images.
- Builtin fonts in the executable without reliance on any fonts installed in the system
- User-adjustable menu, HTML font size and image zoom factor.
- User-adjustable display gammas (red, green, blue), viewing-condition correction gamma and precise calibration of both monitor and Links on a calibration pattern
- Automatic aspect ratio correction for modes like 640x200, 640x400, 320x200 with user-adjustable manual aspect ratio correction.
- Support for one-wheel mice (vertical scroll), two-wheel mice (vertical and horizontal scroll) and smooth scrolling by grabbing the plane with a mouse (no wheel needed).
- Easy installation, the browser is just one executable and no more files.

The project is a simple program using xine code from mplayer (thanks!) to download BBC Listen Again streams.
Simply open the "Listen with External Real Player" links with this program and you can save the Real audio file. Play it with mplayer, vlc, or even Real Player (their linux player is actually quite good amazingly).
To build it you just need Qt 4. If it doesnt work, you might want to generate mplayers config.h for your system, and then copy it over libreal/config.h
Ive also included a binary that might possible work if you are lucky, but this is linux so it probably wont.
Anyway, enjoy! Also Mark Thomas - legend.
PS: If someone wants to make some packages that automatically do the association thing, that would be great!
PPS: Progress bar is approximate - it will take as long to download as the programme lasts.
To install, do something like:
qmake
make
sudo make install
Then (for KDE):
Go to a BBC listen again stream. Download the .ram file linked to by "Listen in External Real Player".
Right click it->properties->Type: Edit file type->Add Application->/usr/bin/keeplistening
Enhancements:
- Fixed compilation errors (kdevelop assumed absolute paths)
- Close on errors
- Added auto-close checkbox (on by default)
- Ignore lines starting with ## in ram files.

HTML::Links::Localize is a Perl module that can convert HTML Files to be used on a hard disk.

SYNOPSIS

use HTML::Links::Localize;

my $converter =
HTML::Links::Localize->new(
base_dir => "/var/www/html/shlomi/Perl/Newbies/lecture4/",
dest_dir => "./dest"
);

$converter->process_file("mydir/myfile.html");

$converter->process_dir_tree(only-newer => 1);

my $new_content = $converter->process_content($html_text);

HTML::Links::Localize converts HTML files to be used when viewing on the hard disk. Namely, it converts relative links to point to "index.html" files in their directories.

To use it, first initialize an instance using new. The constructor accepts two named parameters which are mandatory. base_dir is the base directory (or source directory) for the operations. dest_dir is the root destination directory.

Afterwards, you can use the methods:

$new_content = $converter->process_content(FILE)

This function converts a singular text of an HTML file to a hard disk one. FILE is any argument accepatble by HTML::TokeParser. It returns the new content.

$converter->process_file($filename)

This function converts a filename relative to the source directory to its corresponding file in the destination directory.

$converter->process_dir_tree( [ only-newer => 1] );

This function converts the entire directory tree that starts at the base directory. only-newer means to convert only files that are newer in a make-like fashion.