Ports Search

This module provides perl access to Glib and GLib's GObject libraries. GLib is a portability and utility library; GObject provides a generic type system with inheritance and a powerful signal system. Together these libraries are used as the foundation for many of the libraries that make up the Gnome environment, and are used in many unrelated projects. This wrapper attempts to provide a perlish interface while remaining as true as possible to the underlying C API, so that any reference materials you can find on using GLib may still apply to using the libraries from perl. Where GLib's functionality overlaps perl's, perl's is favored; for example, you will find perl lists and arrays in place of GSList or GList objects. Some concepts have been eliminated; you need never worry about reference-counting on GObjects or GBoxed structures. Other concepts have been converted to a perlish analogy; the GType id will never be seen in perl, as the package name serves that purpose. [FIXME link to a document describing this stuff in detail.]

Luka is an exception handling and reporting framework. It's useful to look at it as an event handling framework. It comes from operational understanding of networks. Scenario that Luka is addressing is following: on a network with multiple hosts running multiple applications, it is very difficult to track operational status of all the functionality that those applications and hosts are meant to deliver. In order to make it easier, we decided to specify the error handling and reporting data model that each component delivering functionality has to conform to. What is a component? In most cases, it is a script, often run from cronjob, in some cases it is a class in an application. In all cases, a component has to successfully complete a task on which functionality of an application, or entire network, relies on. It is common practice that programmers choose their way of handling errors and reporting. Luka is an attempt to standardize that process. Its primary goal is to make it easier for smaller number of people to keep larger number of applications and networks running.

Test::Command intends to bridge the gap between the well tested functions and objects you choose and their usage in your programs. By examining the exit status, terminating signal, STDOUT and STDERR of your program you can determine if it is behaving as expected. This includes testing the various combinations and permutations of options and arguments as well as the interactions between the various functions and objects that make up your program. The various test functions below can accept either a command string or an array reference for the first argument. If the command is expressed as a string it is passed to system as is. If the command is expressed as an array reference it is dereferenced and passed to system as a list. The final argument for the test functions, $name, is optional. By default the $name is a concatenation of the test function name, the command string and the expected value. This construction is generally sufficient for identifying a failing test, but you may always specify your own $name if desired. Any of the test functions can be used as instance methods on a Test::Command object. This is done by dropping the initial $cmd argument and instead using arrow notation.

Skip test scripts if modules are not available. The requested modules will be loaded, and optionally have their versions checked. If the module is missing, the test script will be skipped. Modules that are found but fail to compile will exit with an error rather than skip. If used in a subtest, the remainder of the subtest will be skipped. Skipping will work even if some tests have already been run, or if a plan has been declared. Versions are checked via a $module->VERSION($wanted_version) call. Versions must be provided in a format that will be accepted. No extra processing is done on them. If perl is used as a module, the version is checked against the running perl version ($]). The version can be specified as a number, dotted-decimal string, v-string, or version object. If the RELEASE_TESTING environment variable is set, the tests will fail rather than skip. Subtests will be aborted, but the test script will continue running after that point.

Pyro is short for PYthon Remote Objects. It is an advanced and powerful Distributed Object Technology system written entirely in Python, that is designed to be very easy to use. Never worry about writing network communication code again, when using Pyro you just write your Python objects like you would normally. With only a few lines of extra code, Pyro takes care of the network communication between your objects once you split them over different machines on the network. All the gory socket programming details are taken care of, you just call a method on a remote object as if it were a local object! Pyro provides an object-oriented form of RPC. You can use Pyro within a single system but also use it for IPC. For those that are familiar with Java, Pyro resembles Java's Remote Method Invocation (RMI). It is less similar to CORBA - which is a system- and language independent Distributed Object Technology and has much more to offer than Pyro or RMI. But Pyro is small, simple and free!

SimpleParse is a BSD-licensed Python package providing a simple and fast parser generator using a modified version of the mxTextTools text-tagging engine. SimpleParse allows you to generate parsers directly from your EBNF grammar. Unlike most parser generators, SimpleParse generates single-pass parsers (there is no distinct tokenization stage), an approach taken from the predecessor project (mcf.pars) which attempted to create "autonomously parsing regex objects". The resulting parsers are not as generalized as those created by, for instance, the Earley algorithm, but they do tend to be useful for the parsing of computer file formats and the like (as distinct from natural language and similar "hard" parsing problems). As of version 2.1.0 the SimpleParse project includes a patched copy of the mxTextTools tagging library with the non-recursive rewrite of the core parsing loop. This means that you will need to build the extension module to use SimpleParse, but the effect is to provide a uniform parsing platform where all of the features of a give SimpleParse version are always available.

dnsjava is an implementation of DNS in Java. It supports all defined record types (including the DNSSEC types), and unknown types. It can be used for queries, zone transfers, and dynamic updates. It includes a cache which can be used by clients, and a minimal implementation of a server. It supports TSIG authenticated messages, partial DNSSEC verification, and EDNS0. dnsjava provides functionality above and beyond that of the InetAddress class. Since it is written in pure Java, dnsjava is fully threadable, and in many cases is faster than using InetAddress. dnsjava provides both high and low level access to DNS. The high level functions perform queries for records of a given name, type, and class, and return an array of records. There is also a clone of InetAddress, which is even simpler. A cache is used to reduce the number of DNS queries sent. The low level functions allow direct manipulation of DNS messages and records, as well as allowing additional resolver properties to be set.

From its homepage: xpuyopuyo is a UNIX port of a very big time sink :) . Puyo puyo is a puzzle game, somewhat like Tetris, where you strive to match up four "blobs" of the same color. Each match you make gives points, and also dumps gray rocks on the opponent which are irritating and troublesome to get rid of. Multiple matches at a time score more points, and dump more rocks on the opponent (a quintuple-match will dump around 20 rocks on the opponent, all at once). We ported it overnight to Linux, so we could play whenever we felt like. The AI's evolved more slowly, over the course of a week or so. I welcome sugges- tions on how to make the AI's more difficult during the game; currently, they are rather easy to beat on easy level, but more difficult on hard. There are still gaping holes in the game interface which should be fixed soon. Sugges- tions for improvements are welcome.

DiaCanvas is in its second incarnation: DiaCanvas2. Aiming towards future computing needs on GNOME based desktop environments, DiaCanvas2 is providing you with a full featured diagramming canvas: - Model/View/Controller based design: The DiaCanvas class only holds abstract data (using DiaShape objects), the data is rendered by one or more DiaCanvasView's. - Usage of the widely used GnomeCanvas for visualization. This makes it easy to let DiaCanvas2 display anti-aliased diagrams with translucency (alpha) support. - Export facilities for GnomePrint and SVG. - Objects can be rotated/sheared/resized/etc. without the need to recalculate shapes. DiaCanvas relies heavily on the LibArt library (which is a standard GNOME library). - Objects can connect to each other with handles. The connection is represented as a mathematical equation, which is solved using a real linear constraint solver (see the reference documentation for more info). Handles do not need predefined connection points, but can connect to each other in a more generic way. - Of course DiaCanvas2 has all the features a modern application needs, including undo/redo and copy/paste functionality (copying is not implemented yet).

INTERGIF 6.15 is a program for joining GIFs together (for animation), or splitting animations apart, or for optimising animations created by other programs. * Supports the animation, transparency and interleaving features of GIF89a. * Eliminates unused palette entries. * Minimises the final size of the GIF with a devious and cunning optimisation routine: almost every animated GIF the author has found on the web ends up smaller when run through InterGif. * Can forcibly reduce a GIF's palette to the standard Acorn 256-colour palette, or to a 216-entry "web safe" colour cube (as used on the Macintosh and by most Windows browsers),or to a palette file you supply. Alternatively, it can calculate the best palette for displaying the GIF, and then reduce to that. * From version 6.03, this also works with 16bpp and 24bpp input images -- and with GIFs which use more than 256 colours in total. (GIFs can only use 256 colours per frame, but each frame can have its own palette.) * Lets you trim away any wholly transparent rows or columns from the edges of your GIF (whether single-frame or animated). * Can dither 16bpp or 24bpp input files to whatever palette is required (error diffusion implementation kindly donated by Martin Wurthner).