Free regions software for linux

Data::Region Perl module can define hierarchical areas with behaviors.

SYNOPSIS

use Data::Region;

$r = Data::Region->new( 8.5, 11, { data => PageObj->new() } );
$r->data( PageObj->new() );

foreach my $c ( $r->subdivide(2.5,3) ) {
$a = $c->area(0.25,0.25, 2.25,2.75);
$a2 = $c->area(0.25,0.25, -0.25,-0.25); # as offset from lower right

($t,$m,$b) = $a->split_vertical(2,5,1); # sequential heights
($t,$m,$b) = $a->split_vertical_abs(0,2,7); # absolute offsets
($l,$r) = $a->split_horizontal(2); # $l gets width of 2, $r gets the rest

my($x1,$y1,$x2,$y2) = $a->coords();
my $data = $a->data(); # data inherits from parent, if not set
$a->action( sub { $data->setfont("Times-Bold", 10);
$data->text($x1,$y1, "Some Text");
$data->line( $_[0]->coords() ); # the non-closure way
} );
}
$r->render(); # heirarchically perform all the actions

# Get some info about a region:
($w,$h) = ( $a->width(), $a->height() );
($x1,$y1, $x2,$y2) = $a->coords();
($x1,$y1) = $a->top_left();
($x2,$y1) = $a->top_right();
($x1,$y2) = $a->bottom_left();
($x2,$y2) = $a->bottom_right();

Data::Region allows you to easily define a set of nested (2-dimensional) areas, defined by related coordinates, and to associate actions with them. The actions can then be performed hierarchically from any root of the tree.

Data::Region was written to provide an easy way to do simple page layout, but has, perhaps, more general uses.

Penguin Greetings is a Perl Web-based greeting card application. Penguin Greetings is two products wrapped into one. Penguin Greetings is an engine for handling web "ecards." It is also a collection of 200 cards that can be quickly and easily installed into any server for an immediate ecards solution. In addition, another 24 card images are included separately in the Penguin Greetings - Four Seasons collection and another 16 note card images are now included in the Penguin Greetings - Savoring the sights of Seattle Collection. The cards are photo-based and are similar in style and taste to Apples iCards content. To see the complete Penguin Greetings solution, go to the demonstration page.
The Penguin Greetings (pgreet) engine is a web-based greeting cards for LINUX and other UNIX-based systems written in Perl. Penguin Greetings is template-based and shifts ecards to be more like email instead of web-only objects. For flexibility and security, a separate daemon works with the emails and stores data permanently on the server.
Main features:
- Supports any number of ecard sites running on the same server. Each site is independent with its own configuration, database files, and HTML content. Localization/Internationalization is supported so that secondary ecard sites can be used to support multiple languages and regions. User ecard sites are supported.
- Customizable HTML templates for both the ecards and creation screens so that the web content is completely independent of the Perl program. Perl content is embedded using Embperl or now HTML::Mason so that the full power of Perl is available to content developers and for server-side processing. Object-oriented ecard sites can be created using Embperl::Object or Mason. At the same time, creating templates does not require any specific knowledge of Perl. Using Embperl or Mason, it is possible to build complicated ecard sites as demonstrated by the Penguin Greetings - California Poppy Collection. or the Penguin Greetings - Savoring the sights of Seattle Collection
- Support for a persistent Perl interpreter via SpeedyCGI for robust performance under production loads. Configuration and state information is cached in memory for improved performance under SpeedyCGI. Retains support for standard CGI for portability.
- Greeting cards that function more like email. The announcement of the card includes the text of the card so that the recipient can reply to the message. The email of the author is included in the email reply-to field so that recipients can reply to the ecard using the reply feature of most email clients.
- Uses MIME multipart HTML formatted email to directly send complete ecards to recipients.
- Automated installation procedure, including: the installation of CPAN modules not included in Perl 5.8.0, localization of configuration files, and installation of applications, configuration files, and a default ecard website.
- Access to card creation can be limited to users stored in an htpasswd file on server for sites which want to have ecards available only to a particular group of people.
- A separate application daemon to handle such chores as: card scheduling for emailing on a particular date, purging of old cards after a certain date, and backup database files.
- A user agent separate from the user ID which the web server runs as for mailing and storing of data. If desired, ecards can be emailed under existing email accounts on server. Specific human users on the server can be given access to this feature via an access control list.
- Extensive configuration options. Including the location of configuration and data files, performance tuning, and content parameters.
- Based on standard Perl CPAN modules for portability and reliability.
- Extensive logging of daemon activities.
- Six secondary demonstrations sites included with the distribution, Five of which exist in both English and French as examples of internationalization. Four use Embperl::Object to demonstrate object-oriented website building techniques and one uses HTML::Mason.

Zerotools project contains a set of tools to aid keeping virtual disks clean (by filling binary zero to those regions which are no longer in "use"). This is done on-the-fly or manually, depending on which tool suits the needs best.

In technical terms the on-the-fly mechanism uses LD_PRELOAD to wrap the unlink library call and zerounlink-wrapper provides a symlink based mechanism to target individual programs so that they will be run using the unlink wrapper. For comparison against other tools, please see the "Other solutions" section.

Please note that zerotools dont compete with various tools that rewrite file contents with "random" data in order to make data retrieval close to impossible. Do not use zerotools for this, or claim that they are good tools for this. Theyre not. (This text was added for people who only read introductions.)

Zerotools are Linux specific, implemented using C and licensed under GNU General Public License (v2). The tools are provided without a warranty of any kind, in the understanding that software bugs do exist and bad things can happen.

Bugs and limitations

There are no known bugs. Known to me at least. Bugs will be fixed based on intelligent reporting by end users or automatically if I have extra time. My email address is at the start of each source file should you feel the need to send patches.
Thread-protection is not yet tested properly. Neither is LFS-requirement (which means that zerotools might not be able to handle files over 2 GiB size on 32-bit architectures). Building or running zerotools on older Linux systems has not been attempted (but will be done as soon as older systems are installed in test environment). User participation in testing is also appreciated.

Testing has been done on many Linux distributions running kernels (2.4 and 2.6) and with glibc versions (2.3.2 to 2.5.3, with vendor patches, so this is advisory information only). Architectures that were tested are x86, x86_64, ia_64, and ppc (32-bit). Other architecture test results are welcome.

zerounlink and zerounlink-wrapper do not work with statically linked executables. This is a limitation in the technique and there are no workarounds (known to me).
One mis-feature exists in zerounlink: when checking whether a file should be zeroed or not, zerounlink doesnt take into account sparse files. If the file is sparse, it would make sense to overwrite only the parts of file which have non-zero content.

This means that zerounlink would have to read through all of the original file and search for the non-zero content first. This would also mean that instead of only writing to the unlinked file, zerounlink would have to read it in as well. This would cause extra I/O operations. Not sure whether special sparse-file support is worth the extra effort and complexity so this feature has not been implemented.

Drop me a note if you think you need it. (The reason for having this feature is to do with how most dynamic virtual disks are implemented. They will allocate real space when any data is written to an vdisk area, even if the writes consist of only binary zeroes. Its a bit silly, but thats how most of them work. This is the same reason why filling the filesystem with a file containing only binary zeroes (with dd or other tool) is not really a good solution to clean up the vdisk.)

When reporting bugs about listings on this web page, please include the listing number and line number of the problematic bit to speed up fixes. For other web-related fixes, try to include two to three word phrase which can be grepped with. Do not send diffs against xhtml.

FreeDoko is a Doppelkopf-game, written by Borg Enders and Diether Knof. It is developed under and for the platforms Linux and Windows.

The game is still under developement, but since some time playable.

The game ”Doppelkopf“ is a card game for four or more Players. One game will be played by four players.

Doppelkopf originates probably from the mostly in south germany played game ”Schafkopf“. Its name comes from the double (in German: Doppel) existence of each Card (Doppel-Schafkopf). Meanwhile Doppelkopf is played in whole germany, but mainly in north germany and the region of Rhein and Main.

Doppelkopf is a card game with 48 cards and at least 4 players. It is not unlike the card game ”Skat“. Doppelkopf is played with two normal Skat packs of cards (each has 32 cards) without sevens and eights. Here the players with the club queens are playing together. So there are while playing often new pairs.

Doppelkopf is like Skat a game which depends on the skills of each player. This guarantees a exciting and varied game event.

libipgeo library is written on top of the IP2LOCATION database allowing the user to do geo-targeting of IP addresses. For a given IPv4 address, libipgeo can lookup the following:

Country Code
Country
Region
City
Latitude
Longitude
ISP

NEW:libipgeo now searchs the IP2LOCATION database in O(lg n) and is TONS faster!

Included with the libipgeo distribution is a simple traceroute client that does IPv4 targeting:

[rounder:Projects/libipg/sample] root# ./trig -ien1 -LlCry 4.2.2.2 ../../IP-COUNTRY-REGION-CITY-LATITUDE-LONGITUDE-ISP-FULL/
IP-COUNTRY-REGION-CITY-LATITUDE-LONGITUDE-ISP.CSV
Trig 1.0 [geo-targeting traceroute scanner]
01: 66.123.162.113 US SAN RAMON CALIFORNIA 37.7661 -121.9730
02: 63.203.35.65 US SAN FRANCISCO CALIFORNIA 37.7002 -122.4060
03: 63.203.35.17 US SAN FRANCISCO CALIFORNIA 37.7002 -122.4060
04: 64.161.1.30 CA MONTREAL QUEBEC 45.5000 -73.5830
05: 64.161.1.54 CA MONTREAL QUEBEC 45.5000 -73.5830
06: 144.223.242.81 US KANSAS CITY MISSOURI 39.1749 -94.5804
07: 209.245.146.245 US UNKNOWN UNKNOWN 0.0000 0.0000
08: 209.244.3.137 US BROOMFIELD COLORADO 39.9135 -105.0930
09: 64.159.4.74 US SAN CLEMENTE CALIFORNIA 33.4322 -117.5780
10: 4.24.9.142 EG CAIRO AL QAHIRAH 30.0500 31.2500
11: 4.2.2.2 US PROVIDENCE RHODE ISLAND 41.8231 -71.4204

Krita is a image editing and painting application for KOffice. The application is almost ready for use, and the architecture provides a solid framework to build an application on.
Because of the current unfinished state, Krita is not yet part of the regular KOffice releases, but the source is available from the KDE SVN repository. We hope to get Krita into a releasable state for KOffice 1.4.
Krita, like other KDE and KOffice applications, is free software which uses GPL Licensing. You enjoy the same rights to own, copy and modify this software with commercial and personal use, so long as you dont restrict the freedom of others to do the same.
Main features:
- Painting with brushes and colors
- Creating brushes from circles and squares
- Filling with colour and patterns
- Gradients
- Erasing
- Airbrush
- Simple geometric forms
- Many filters
- undo and redo
- Loading and saving of images in its native file format.
- Importing and exporting of images in all file formats supported by your installation of ImageMagick.
- Adding, removing, reordering and merging of layers.
- Layer transparency.
- Loading Gimp brushes, pipe brushes, gradients and patterns.
- Zoom.
- Color selection.
- Gray(A), RGB(A) and color models.
- Support for Wacom tablets.
- High-quality scaling
- Selections
- And much, much more
Or rather, what should it do, and what does it do already:
- brushes, drawing and layer editing tools (not complete)
- Color management using Little CMS
- RGB, RGBA and Grayscale color modes with adjustable color selectors. CMYK is implemented but buggy at the moment.
- Import/Export of png, jpg, xpm, tiff and bmp images, including color-indexed images. Import of gif images. (complete)
- an XML file format which saves and loads layer and channel information and full 32 bit image data (complete)
- color editing and selection tools (partly complete)
- dithering, transparency, blending and color reductions (partly complete)
- multiple views of the same image (complete)
- multiple images in the same view (complete)
- gradients and patterns (under development)
- cut,copy and paste between images and layers using rectangular area and other basic selection methods (incomplete)
- masking of selected regions during painting operations (under development)
- user-definable brushes (under development)
- adjustable zoom levels (mostly complete)
- scaling of images, selections and layers (incomplete)
- graphical access to layer and channel information (partly complete)
- import/export of xcf (Gimp) image files (complete, in as far as ImageMagick supports this)
- embedding in other KOffice apps (needs testing)
- user-oriented documentation of all the above basic functionality (incomplete)
- Scripting using kjsembed
Other planned features:
- HSV, Wet & Sticky and Wet Canvas color models
- image manipulation filters for advanced import/export
- wide range of region selection methods, including fuzzy selection and boundary detection
- scripting with the Python language
KParts architecture and plugins allow:
- plugins for effects and operation on images and selections
- additional tools
- additional filters
- components loaded as needed

Monto is a simple WindowMaker dockapp for manually mounting devices like floppy, HDD, USB, zip, CD, etc. (a maximum of four devices).

Mounting/unmounting operations are performed by one click on the dockapp region associated with the mount point alias.

Configuration options can be changed by manual editing ~/.clay/monto file (Its necessary when monto is run for the first time - autoconfig based on /etc/fstab
is currently unavailable) using text editor.

Meaning of led colors as follows:

* blue - when device is mounting
* green - when device is mounted

Suggestions, comments and patches are welcome.