The wmctrl program is a command line tool to interact with an
EWMH/NetWM compatible X Window Manager.
It provides command line access to almost all the features defined in
the EWMH specification. Using it, it's possible to, for example, obtain
information about the window manager, get a detailed list of desktops
and managed windows, switch and resize desktops, change number of
desktops, make windows full-screen, always-above or sticky, and
activate, close, move, resize, maximize and minimize them.
The xcb-util module provides a number of libraries which sit on top of
libxcb, the core X protocol library, and some of the extension
libraries. These experimental libraries provide convenience functions
and interfaces which make the raw X protocol more usable. Some of the
libraries also provide client-side code which is not strictly part of
the X protocol but which have traditionally been provided by Xlib.
Image module is a port o Xlib's XImage and XShmImage functions.
This program sets attribute "override_redirect" to True for any window
you've specified (using window name). Window Managers should ignore
such windows; it's useful, for example, if you're using wmx Window Manager,
and want to have a clock on every virtual screen and without any
borders. Just add the following string to your X-startfile (after
starting watch app):
xnodecor -w watch
(assuming that your watch application has a window named "watch")
The goal of the xfce4-quicklauncher-plugin is double.
First, it is intented to offer you a fast and easy way to configure the
plugins wich are on your panel.
Secondly, it is able to display these launchers on one or more lines, and
they are displayed so that they don't waste space. They also feature
a little zoom effect when you pass the mouse over them.
Sqitch is a database change management application. What makes it
different from your typical migration-style approaches? A few things:
## No opinions
Sqitch is not integrated with any framework, ORM, or platform.
Rather, it is a standalone change management system with no opinions
about your database engine, application framework, or development
environment.
## Native scripting
Changes are implemented as scripts native to your selected database
engine. Writing a PostgreSQL application? Write SQL scripts for
psql. Writing a MySQL-backed app? Write SQL scripts for mysql.
## Dependency resolution
Database changes may declare dependencies on other changes -- even
on changes from other Sqitch projects. This ensures proper order
of execution, even when you've committed changes to your VCS
out-of-order.
## No numbering
Change deployment is managed by maintaining a plan file. As such,
there is no need to number your changes, although you can if you
want. Sqitch doesn't much care how you name your changes.
## Iterative development
Up until you tag and release your application, you can modify your
change deployment scripts as often as you like. They're not locked
in just because they've been committed to your VCS. This allows you
to take an iterative approach to developing your database schema.
Or, better, you can do test-driven database development.
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.
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).
This is a pure-Java implementation of Berkeley DB by SleepyCat (now
Oracle). Java-1.7 is required for building. From the
"Berkeley DB JE was designed from the ground up in Java. It takes full
advantage of the Java environment. The Berkeley DB JE API provides a
Java Collections-style interface, as well as a programmatic interface
similar to the Berkeley DB API.
Berkeley DB JE is different from all other Java databases available
today. Berkeley DB JE is not a relational engine built in Java. It
is a Berkeley DB-style embedded store, with an interface designed
for programmers, not DBAs. Berkeley DB JE's architecture employs a
log-based, no-overwrite storage system, enabling high concurrency and
speed while providing ACID transactions and record-level locking.
Berkeley DB JE efficiently caches most commonly used data in memory,
without exceeding application-specified limits. In this way Berkeley
DB JE works with an application to use available JVM resources while
providing access to very large data sets.
The Berkeley DB JE architecture provides an underlying storage layer
for any Java application requiring high performance, transactional
integrity and recoverability."
AUC TeX is a comprehensive customizable integrated environment for
writing input files for LaTeX using GNU Emacs.
AUC TeX lets you run TeX/LaTeX and other LaTeX-related tools, such
as a output filters or post processor from inside Emacs. Especially
`running LaTeX' is interesting, as AUC TeX lets you browse through the
errors TeX reported, while it moves the cursor directly to the reported
error, and displays some documentation for that particular error. This
will even work when the document is spread over several files.
AUC TeX automatically indents your `LaTeX-source', not only as you
write it -- you can also let it indent and format an entire document.
It has a special outline feature, which can greatly help you `getting an
overview' of a document.
Apart from these special features, AUC TeX provides a large range of
handy Emacs macros, which in several different ways can help you write
your LaTeX documents fast and painlessly.
All features of AUC TeX are documented using the GNU Emacs online
documentation system. That is, documentation for any command is just
a key click away! AUC TeX is written entirely in Emacs-Lisp, and hence
you can easily add new features for your own needs.
Data::FormValidator's main aim is to make the tedious coding of input
validation expressible in a simple format and to let the programmer focus
on more interesting tasks.
When you are coding a web application one of the most tedious though
crucial tasks is to validate user's input (usually submitted by way of
an HTML form). You have to check that each required fields is present
and that some fields have valid data. (Does the phone input looks like a
phone number? Is that a plausible email address? Is the YY state
valid? etc.) For a simple form, this is not really a problem but as
forms get more complex and you code more of them this task becames
really boring and tedious.
Data::FormValidator lets you define profiles which declare the
required fields and their format. When you are ready to validate the
user's input, you tell Data::FormValidator the profile to apply to the
user data and you get the valid fields, the name of the fields which
are missing. An array is returned listing which fields are valid,
missing, invalid and unknown in this profile.
Seamus Venasse <svenasse@polaris.ca>