Free 1.0 layouts software for linux

PageLayout is a layout lanager for Java Swing/AWT that encapsulates, in a single library, the functionality of many other layout managers. It allows you to lay out components in appropriately aligned rows, columns, and grids.
The elements of rows, columns, and grids may themselves be rows, columns and grids of components. As a result, relatively complex layouts can be managed with code that is compact and conceptually quite straightforward to understand and, therefore, maintain.
PageLayout is available for download for JDK1.5. PageLayout is distributed under LGPL.
The distribution contains the source, extensive documentation, and a large number of nontrivial examples that illustrate the simplicity and the comprehensive nature of the approach.
Enhancements:
- Apart from the addition of new convenience methods, no changes have been made to the code base.
- Programs running under the previous version 1.11 of the layout manager should work without any changes whatsoever.

MP3::Album::Layout is a Perl extension to manage/represent a layout for a mp3 album.

SYNOPSIS

use MP3::Album::Layout;

#create a new layout
my $layout = new MP3::Album::Layout;

#change the disc title
$layout->title("Perl conference");

#add a track
$layout->add_track(artist=>someone, title=>regex how to);

#edit track
$layout->edit_track(position=>1, artist=>still dont know the name);

MP3::Album::Layout represents a mp3 album layout, which contains the (artistic) information of a album.

PyUI is a user interface library written entirely in the high-level language Python. It has a modular implementation that allows the drawing and event input to be performed by pluggable "renderers".
It can run in environments from hardware accelerated 3D surfaces to regular desktop windows. PyUI was originally targeted as a User Interface for games, but it has evolved in time into a more general UI toolkit with applicability outside of games.
The goal of pyui is that is be very simple to use and that the implementation be kept as simple as possible. Some lessons learned from Extreme Programming are being applied to the development process. The current state of PyUI is no longer exactly simple as it evolves towards being a fully features GUI toolkit, but the development methodology has been successful in keeping the code stable and usable throughout its life so far.
PyUI is being used on a commercial computer game development project at Ninjaneering and is owned by Sean Riley, one of the founders of that company. If you are using or thinking of using PyUI, drop us an email!
Main features:
- A set of useful GUI widgets including buttons, list boxes, menus, and scrollbars
- Windows with resizability and movability
- An extensible event system for interacting with the user interface
- An interactive python console window
- Layout managers similar so the Java Swing layout managers
- Portability and scalability

cpphs is a liberalised re-implementation of cpp, the C pre-processor, in Haskell.
Why re-implement cpp? Rightly or wrongly, the C pre-processor is widely used in Haskell source code. It enables conditional compilation for different compilers, different versions of the same compiler, and different OS platforms.
It is also occasionally used for its macro language, which can enable certain forms of platform-specific detail-filling, such as the tedious boilerplate generation of instance definitions and FFI declarations. However, there are two problems with cpp, aside from the obvious aesthetic ones:
- For some Haskell systems, notably Hugs on Windows, a true cpp is not available by default. * Even for the other Haskell systems, the common cpp provided by the gcc 3.x series is changing subtly in ways that are incompatible with Haskells syntax. There have always been problems with, for instance, string gaps, and prime characters in identifiers. These problems are only going to get worse.
So, it seemed right to provide an alternative to cpp, both more compatible with Haskell, and itself written in Haskell so that it can be distributed with compilers.
This version of the C pre-processor is pretty-much feature-complete, and compatible with the -traditional style. It has two main modes:
- conditional compilation only (--nomacro),
- and full macro-expansion (default).
In --nomacro mode, cpphs performs only conditional compilation actions, namely #includes, #ifs, and #ifdefs are processed according to text-replacement definitions (both command-line and internal), but no parameterised macro expansion is performed. In full compatibility mode (the default), textual replacements and macro expansions are also processed in the remaining body of non-cpp text.
Working features:
#ifdef simple conditional compilation
#if the full boolean language of defined(), &&, ||, ==, etc.
#elif chained conditionals
#define in-line definitions (text replacements and macros)
#undef in-line revocation of definitions
#include file inclusion
#line line number directives
line continuations within all # directives
/**/ token catenation within a macro definition
## ANSI-style token catenation
# ANSI-style token stringisation
__FILE__ special text replacement for DIY error messages
__LINE__ special text replacement for DIY error messages
__DATE__ special text replacement
__TIME__ special text replacement
Macro expansion is recursive. Redefinition of a macro name does not generate a warning. Macros can be defined on the command-line with -D just like textual replacements. Macro names are permitted to be Haskell identifiers e.g. with the prime and backtick ` characters, which is slightly looser than in C, but they still may not include operator symbols.
Numbering of lines in the output is preserved so that any later processor can give meaningful error messages. When a file is #included, cpphs inserts #line directives for the same reason. Numbering should be correct even in the presence of line continuations. If you dont want #line directives in the final output, use the --noline option.
Any syntax errors in cpp directives gives a message to stderr and halts the program. Failure to find a #included file produces a warning to stderr, but processing continues.
Differences from cpp:
In general, cpphs is based on the -traditional behaviour, not ANSI C, and has the following main differences from the standard cpp.
General
- The # that introduces any cpp directive must be in the first column of a line (whereas ANSI permits whitespace before the #).
- Generates the #line n "filename" syntax, not the # n "filename" variant.
- C comments are only removed from within cpp directives. They are not stripped from other text. Consider for instance that in Haskell, all of the following are valid operator symbols: /* */ */* However, you can turn on C-comment removal with the --strip option.
- Macros are never expanded within Haskell comments, strings, or character constants, unless you give the --text option to disable lexing the input as Haskell.
- Macros are always expanded recursively, unlike ANSI, which detects and prevents self-recursion. For instance, #define foo x:foo expands foo once only to x:foo in ANSI, but in cpphs it becomes an infinite list x:x:x:x:..., i.e. cpphs does not terminate.
Macro definition language
- Accepts /**/ for token-pasting in a macro definition. However, /* */ (with any text between the open/close comment) inserts whitespace.
- The ANSI ## token-pasting operator is available with the --hashes flag. This is to avoid misinterpreting any valid Haskell operator of the same name.
- Replaces a macro formal parameter with the actual, even inside a string (double or single quoted). This is -traditional behaviour, not supported in ANSI.
- Recognises the # stringisation operator in a macro definition only if you use the --hashes option. (It is an ANSI addition, only needed because quoted stringisation (above) is prohibited by ANSI.)
- Preserves whitespace within a textual replacement definition exactly (modulo newlines), but leading and trailing space is eliminated.
- Preserves whitespace within a macro definition (and trailing it) exactly (modulo newlines), but leading space is eliminated.
- Preserves whitespace within macro call arguments exactly (including newlines), but leading and trailing space is eliminated.
- With the --layout option, line continuations in a textual replacement or macro definition are preserved as line-breaks in the macro call. (Useful for layout-sensitive code in Haskell.)
Enhancements:
- This release now includes a compatibility script for command line arguments to match the original cpp.
- There are several minor bugfixes, e.g. quotes around replacements for special macros like __FILE__, etc.
- Interaction with preprocessors like hsc2hs is also improved: if they allow non-cpp directives like #def, these are now passed through to the output with a warning to stderr, rather than halting with an error.
- Likewise, a #! line in a shell script is now ignored.

Qanava is a library built on top of the standard QT QCanvas to enable graphical display of graphs and other relational structures.
Build:
Just generate makefiles with the qmake command, and launch the build with make. The compilation has been tested successfully with GCC 3.3.6, GCC 4.0.0 and QT 3.3.4.
There is no dependencies outside of Trolltech QT.
Installation:
There is currently no automated installation system since this package is a preview version that is not stable enough to be used in production software.
Main features:
- Describe and layout simple graphs (with less than a few thousand nodes).
- Draw grids and graphical elements with various visual attributes on a QT canvas to model nodes.
- Provide ways to select nodes, display tooltips and manage zooming and navigation on the canvas.

RSStool is a software to read, parse, merge and write RSS (and Atom) feeds.

Lately a new technology called "RSS feeds" has caught my attention I decided to make it successful by writing this small tool.

Usage:

rsstool [OPTION] FILE|URL...

Read, parse, merge and write RSS (and ATOM) feeds

Supports: RSS 0.9x, 1.0, 2.0 and ATOM 0.1, 0.2, 0.3

The RSS (or ATOM) feeds will be merged and re-sorted if you enter more than
one URL or FILEname

Options:
--version output version information and exit
--help display this help and exit
-q be quiet/less verbose
-s strip HTML code from RSS (or Atom) feeds
-r sort reverse
--html output as html (using -q will result in single line)
--txt output as plain text (using -q will result in single line)
-1 output as single line

--template=FILE|URL parse template file and replace tags with content
Tags: "< rsstool:url item=NUM >" url/link of item NUM
"< rsstool:title item=NUM >" title of item NUM
"< rsstool:desc item=NUM >" description of item
with NUM
"< rsstool:date item=NUM >" date of item NUM
"< rsstool:site item=NUM >" site where item with
NUM came from
Thats right, you could use/replace these custom tags in HTML
pages and upload them to a server who does only static HTML
"< rsstool:start item=NUM >" start of item NUM
"< rsstool:end item=NUM >" end of item NUM
These tags will be replaced with a "< !--" and a "-- >" if
the item NUM is empty
"< rsstool:updated >" rsstool notice (Thank You!)

--property=FILENAME output feed(s) into a property file
Layout: NAME_NUM=VALUE
NAME is "title", "url", etc..
NUM is an integer counting the items
VALUE is the content

XCclock is a small application which offers a nice clock and an alarm function.

Simply push the right mouse button above the clock and select something in the popup menu.

To run and build the Xclasses X11 layout library is required.

Usage of XCclock:

xclock [-q] [-m] [-t]

q : disables quit functions in menus
m : disables minutes in clock (usefull if you use a really small one)
t : disables the textbox below the clock that shows the alarm time