Free in place software for linux

Easiest Edit In Place enables Web (2.0) developers to generate any number of edit in place widgets with only one line of script code.
Using stylesheets and spans, any piece of text can be edited by any type of widget. Easiest Edit In Place features CSS customization and automatic caret positioning.
Main features:
- It requires only 1 line of javascript to make any number of widgets editable.
- Caret positioning. When editing inline, the caret is positioned at the point the user clicked, to make it more intuitive.
- Editor can be anything, from ordinary text input to text areas or custom widgets.
- Everything can be styled using CSS.
Eeip has been tested on Firefox and IE.
Enhancements:
- A bug that could lead to the accidental display of placeholder text when dealing with empty fields in some circumstances was fixed.

Minnow is a Web-based PDF discussion engine for discussing and annotating documents in an online, multi-user environment.
Minnow was developed by the Mathematical Biology group at the Northwest Fisheries Science Center in Seattle, WA with support by NOAA/NMFS.
Enhancements:
- This release includes some major updates such as full-text extraction from PDFs, edit-in-place support for editing titles and descriptions of documents after theyve been imported, a progress meter for converting large PDFs to images, and user-level access control, allowing you to specify which users can view a document.

Parsifal is a validating XML 1.0 parser written in ANSI C. Parsifal API is based on SAX2.
Parsifal can be used for parsing XML based messages (such as REST and RSS) and for application specific data processing e.g. config files, data files etc. Parsifal can also be used for document-oriented processing (e.g. XHTML xhtml1-transitional.dtd) and for parsing modular documents because it is conforming XML 1.0 parser and it supports features like internal and external general entities, DTD parameter entities and default attributes etc. Parsifal is ideal for processing large data files and streams since its SAX based and consumes very little memory not to mention it is fast enough for most purposes cos its written in C.
Using Parsifal in place of large XML processing libraries (e.g. libxml, xerces) or even in the place of small Expat (which doesnt support DTD validation) can be justified for limited memory environments and in applications requiring bundled parser; because of its modular design parsifal can be easily compiled to support DTD validation or to perform only non-validating parsing etc. If you need higher level tools, for example dom/xpath processing, you should look for other libs of course.
Main features:
- PublicID legal chars arent fully checked
- XML Namespaces 1.0 duplicate URIs arent checked
- Allows some illegal placement for parameter entity references (see conformance test results)
- Validation of TokenizedType attributes (e.g. ID) are not yet implemented nor checking for existence of valid NOTATIONs etc.
- Doesnt check non-determinism of content models in validating mode
Supported XML encodings
- UTF-8
- ISO-8859-1
- US-ASCII
When compiled with GNU libiconv support:
- UTF-16, UCS-2, UTF-32, UCS-4
- EUC-JP
- SHIFT_JIS
- ISO-8859-{1,2,3,4,5,7,9,10,13,14,15,16}
Enhancements:
- This release fixes GCC 4 issues and polishes the configuration script.

Tk::Gpack module contains abbreviated geometry arguments for pack, grid and place geometry managers.

This module exports four functions for each of the different geometry mananers into the Tk namespace. These functions provide a variety of styles for controlling the indevidual geometry of one, or bulk groups of widgets. Each geometry manager has a series of single letter abbreviations allowing a significant reduction in code, while remaining fairly intuitive.

SYNOPSIS

use Tk::Gpack ;
gpack, ggrid, and gplace are group packers, they recieve an even numbered list of alternating widgets and abbreviations.
gpack($one, slan $two, sran $three, slanx1fb) ; # group pack
ggrid($one, r25c10, $two, c9r15, $three, c1r1se ) ; # group grid
gplace($one, w40h40x120y120anw, $two, x40y40ase, $three, aww20h20x25y140) ; # group placer
tpack, tgrid, and tplace are target packers, and use exactly the same format except they take a preceding target widget, (typically a frame) which will be automatically be used in conjunction with the -in => argument.
tpack($FRAME1, $one, slan $two, sran $three, slanx1fb) ; # target pack
tgrid($TOPLEVEL1, $one, r25c10, $two, c9r15, $three, c1r1se ) ; # target grid
tplace($MW, $one, w40h40x120y120anw, $two, x40y40ase, $three, aww20h20x25y140) ; # target placer
xpack xgrid and xplace are expand packers, and used inline as a direct replacement to pack grid and place. The first string passed is the abbreviation string, while anything remaining will be parsed as the standard verbose options.
$one->xpack(slan, -in => $FRAME1) ; # expand pack
$two->xgrid(r4c4sw, -in => $TOPLEVEL2) ; # expand grid
$three->xplace(x20y20aw, -in => $MW) ; # expand place
spack sgrid and splace are self packers, they assume that an abbreviation is embedded in the widget as an option called -geometry. You must be using derived widgets for this to work, and have defined a configspec -geometry. The self packers perform the same as xpack in that they permit additional verbose option pairs to be passed which will be appended to the expansion of the embedded abbreviation. If you are using a default widget geometry as shown below, you can still override it by simply using xpack in place of spack. (spack wont take the abbreviation as an argument) This is particularly handly for templated code. To use spack splace and sgrid do the following:
package DerivedButton ;
...
sub Populate {
$self->ConfigSpecs(-geometry => [PASSIVE, data, Data, slan]) ; # DerivedButton()->spack(-in => $foo) ;
Obviously this last example is not complete. Once youve built a derived widget it should make sense though.

DETAILS

The abbreviations are fairly intuitive. All supported options are represented by a single character. For the pack geometry manager all passed values are also single characters. For grid and place passed values may be multiple characters. Numeric arguments for grid and place are variable length integers for example. There are a few redundant characters, but they work as expected.

NOT ALL OPTIONS TRANSLATE, in this version. (And probably for quite a few versions to come) But the most used ones do. Please review the following translation lists to see How things are supported at this time.

SUPPORTED TRANSLATIONS

# OPTIONS pack()
###################
x = -expand
s = -side
a = -anchor
f = -fill
X = -padx
Y = -pady

# VALUES pack()
####################
c = center
l = left
r = right
t = top
n = n
s = s
e = e
w = w
y = y
x = x
b = both
b = bottom

# OPTIONS grid()
####################
r = -row
c = -column
s = -sticky

# VALUES grid()
####################
n = n
s = s
e = e
w = w

# OPTIONS place()
####################
w = -width
h = -height
x = -x
y = -y
a = -anchor

# VALUES place()
####################
n = n
ne = ne
nw = nw
s = s
se = se
sw = sw
e = e

DupeFinder is a simple application for locating, renaming, moving and deleting duplicate files in a directory structure.
Its perfect both for users who havent kept their hard drives very well organized and need to do some cleaning to free space, and for users who like to keep lots of backup copies of important data "just in case" something bad should happen.
Main features:
Although DupeFinder is a quite small application, it should have all of the features you will need to remove and reorganize large directories full of duplicate files:
- Well designed graphical interface with full tooltip and "Whats This?" question button support, useful in an application which you probably wont need to use frequently
- Quick processing by eliminating analysis of unwanted data through file extension filtering
- View files in external applications by double-clicking
- Rename files in place or move to new locations
- Default settings disallow deletion of all copies of duplicate files to prevent accidental data loss
- Generate simple reports identifying groups of duplicate files for later processing
While everything works pretty well in most cases, there are a few issues with DupeFinder to be aware of. I hope to fix most of the following bugs sometime soon:
- May crash if files containing "~" or ":" characters are encountered
- May crash if self referencing symlinks are encountered
- Zero byte files cannot be deleted
- May not be able to delete files with Unicode characters in filename
- Display does not update if identified duplicates are moved, renamed or modified external to DupeFinder

Gmail Skins provides skins and other extra features for Gmail.
Main features:
- Change the colour/skin of your inbox.
- Integrate your google homepage alongside your inbox. This allows you to view weather reports, rss feeds, news headlines, flickr recently added, google calendar module etc from your inbox.
- Easily insert images from your Picasa web album in to your emails
- Insert smileys/emoticons and images in to your emails.
- Insert HTML tables and other complex HTML in to your emails.
- Make the navigation (Inbox, Starred, Sent Mail, etc) horizontal.
- Fix the navigation in place so that you dont have to scroll to the top of the page to see it.
- Zebra stripes on mailbox - pretty!
- Change the attachment paperclip (on inbox) to an icon indicating the type of attachment.
- Hide various page elements (invite panel, page footer, your email address from the top right of inbox).
To access the settings panel you must change the language on your gmail account to EN-US - This is because of how tightly gmailskins integrates in to the Gmail interface. You can change your language back again afterwards and the settings will still be applied, although "your mileage may vary".
Some features will be added to your account, please do not mistake these for beta features rolled out by google like this guy: http://www.digg.com/links/Gmail_New_Features.

List::Pairwise is a Perl module with map/grep arrays and hashes pairwise.

SYNOPSIS

use List::Pairwise qw(:all);

my %a = (
snoogy1 => 4,
snoogy2 => 2,
NOT => 4,
snoogy3 => 5,
hehe => 12,
);

# keys/values emulation (only slower)
my @keys = mapp {$a} %a;
my @values = mapp {$b} %a;

# reverse hash (does not work in-place)
my %reverse_a = mapp {$b, $a} %a;

# reverse array pairs in-place
my @a = %a;
mapp { ($a, $b) = ($b, $a) } @a;

# modify values in-place
mapp {$b++} %a;

# modify keys (does not work in-place)
my %b = mapp {lc($a) => $b} %a;

# grep hash subset
my %subset1 = grepp {$a =~ /snoogy/} %a;
my %subset2 = grepp {$b < 5} %a;

# grep some specific values
my @snoog_values = mapp {$b} grepp {$a =~ /snoogy/} %a;
# This does not work:
# values grepp {$a =~ /snoogy/} %a; # values() expects a real hash

Klaxon is a simple detector od scanning booted from inetd.

Instead of actually executing anything, it returns a benign error to the caller, and syslogs the calling host, username, and name of attempted service access. Its also extremely useful for detecting portscanner attacks like those perpetrated by ISS and SATAN. Ident support (RFC931) is currently optional. klaxon is useful to watch in place of any tcp or udp service port where you would not suspect activity.

Ident is a protocol sometimes also called TAP which is based on RFC931. If the machine that the scan attempt supports this protocol (usually out of inet) you will get a username as well as the hostname of the attacking machine. NOTE: This information should be taken with a grain of salt as ident can be very easy to spoof. However, it can also be useful, so I have left it as an option in the source. The current timeout for determining if the remote machine supports ident is 3 seconds. You can adjust this in the Makefile. Both ident-full and ident-free version of the executable are built from one Makefile. Currently, it compiles out of the box on Solaris2.X, SunOS4.1.X, Digital Unix 3.2*, Linux, HPUX, AIX, and probably others.