Free pad software for linux

xpad project is a sticky note application written using GTK+ 2.0 that strives to be simple, ault-tolerant, and customizable.
xpad consists of independent pad windows; each is basically a text box in which notes can be written. Despite being called xpad, all that is needed to run or compile it is
the GTK+ 2.0 libraries.
Main features:
- GTK+ 2.0 powered text view.
- Fault tolerant. All information is kept on the hard drive, not memory. So if power is lost or your computer freezes, there is little lost information.
- xpad is very customizable. The color scheme and font can be changed. These settings can be applied to one pad or set as the default for future pads. Want window decorations or not? Your choice.
- A customizable toolbar puts the most frequently used commands at your fingertips.
- Support for the X session management protocol.
- Support for the freedesktop.org system tray proposal.
Enhancements:
- Fixed a crash when opening pads with formatting.

GNOME War Pad is VGA Planets client for GNOME 2 desktop platform. It aims to develop a full featured client, including scripting Python support.
VGA Planets is a play-by-email space conquest strategy game, it can be played by 11 players max. This game is being played by strategy fanatics all over the world for some years now, is very addictive and there are several servers on the Internet that host various kinds of this games.
Well, first of all this game is great, I thank Tim Wisseman for his creation, secondly its very cheap to register it (I think 5 USD) and if you dont want to register it, you still can play it with some limitations. Plus, because this game was developed for DOS, almost all clients existing this days are for DOS or Windows, and since Im a GNU/Linux freak, Im tired of playing VP with dosemu, its just too slow! :-)...so thats my itch, I wanna scratch it as ESR says.
Actually, there isnt a GNU/Linux client for VP that Im aware of, I know that PCCs author, Stefan Reuther from Germany, is porting his excellent client to GNU/Linux using the SDL library, this is great! but again, GNOME deserves to have its own client, so I started this project as an excuse to learn how to program for GNOME, and also to polish my C programming skills.
This software is Free Software, released under the GNU General Public License, you may copy, modify it and redistribute it under the conditions of this license.
Enhancements:
- this is a major milestone in this projects development because now the player can make some real actions into the game! no more viewing-only! Enjoy!

StepMania project is a music/rhythm game. The player presses different buttons in time to the music and to note patterns that scroll across the screen. Features 3D graphics, visualizations, support for gamepads/dance pads, a step recording mode, and more!
This release was done under totally different management and with different Windows and Linux builders, so let us know how it went.
Enhancements:
- Fix keyboard/joy mapping crash.
- Fix fail extra stage causes game over.
- Fix preview music in editor.
- Fix song edit crash when pressing v.

Des package contains the Des extension module for Perl.

The Des extension module gives access to the DES library.

The following is a brief and over-simplified description of the relevant stuff about DES.

DES keys are 8-byte blocks. A key is passed to a perl function as an 8-byte string. Before keys can be used to encrypt or decrypt data, the key needs to be transformed into a key schedule using the function set_key. There is a certain amount of overhead in creating these key schedules (which are 128 bytes or 256 bytes depending on implementation and architecture) so they can be created and cached for later if desired. Encryption and decryption can be done in 3 modes:

ECB (electronic code book) mode

Takes a des_cblock (perl 8-byte string) and produces another des_cblock. (Very rarely useful for large amounts of plain text, subject to known plaintext attacks under certain circumstances, only slightly faster than CBC or PCBC mode, and you lose even this advantage in perl).

CBC (cipher block chaining) mode

Takes an arbitrary length string, pads it out (internally) on the right with NULs to a multiple of 8-bytes. Encrypts/decrypts the data and produces output (same size as padded input) which is an exact multiple of 8 bytes long. Changing a single bit of the cleartext affects all the following ciphertext. However, changing a single bit of the ciphertext affects only the corresponding cleartext block and the following block. This is occasionally an advantage but is usually a disadvantage.

PCBC mode

A modified CBC mode with indefinite proagation of single bit errors both from cleartext to ciphertext and from ciphertext to cleartext. "Usually" the best mode (for certain values of "usually").

Functions imported by use Des.

string_to_key (STRING)

Takes an arbitrary STRING and munges it (with a one-way function) into a DES key, which is returned.

set_key (KEY)

The DES key KEY (which must be a string of exactly 8 bytes) is turned into a key schedule which is returned.

ecb_encrypt (INPUT, SCHEDULE)

The INPUT argument (which must be a string of exactly 8 bytes) is encrypted using ECB mode using key schedule SCHEDULE (created using set_key) and the resulting 8-byte string is returned.

ecb_decrypt (INPUT, SCHEDULE)

The INPUT argument (which must be a string of exactly 8 bytes) is decrypted using ECB mode using key schedule SCHEDULE (created using set_key) and the resulting 8-byte string is returned.

cbc_encrypt (INPUT, OUTPUT, SCHEDULE, IV)

The INPUT argument can be of arbitrary length, although it will be internally padded on the right with NULs to the nearest multiple of 8 bytes. INPUT is taken and encrypted using CBC mode with key schedule SCHEDULE and initialisation vector IV. If OUTPUT is not undef then it assumed to be an lvalue which is grown (if necessary) and receives the encrypted output. Whether or not OUTPUT is undef, the output is also available as the return value of the function.

cbc_decrypt (INPUT, OUTPUT, SCHEDULE, IV)

The INPUT argument can be of arbitrary length, although it will be internally padded on the right with NULs to the nearest multiple of 8 bytes. INPUT is taken and decrypted using CBC mode with key schedule SCHEDULE and initialisation vector IV. If OUTPUT is not undef then it assumed to be an lvalue which is grown (if necessary) and receives the decrypted output. Whether or not OUTPUT is undef, the output is also available as the return value of the function.

pcbc_encrypt (INPUT, OUTPUT, SCHEDULE, IV)

The INPUT argument can be of arbitrary length, although it will be internally padded on the right with NULs to the nearest multiple of 8 bytes. INPUT is taken and encrypted using PCBC mode with key schedule SCHEDULE and initialisation vector IV. If OUTPUT is not undef then it assumed to be an lvalue which is grown (if necessary) and receives the encrypted output. Whether or not OUTPUT is undef, the output is also available as the return value of the function.

pcbc_decrypt (INPUT, OUTPUT, SCHEDULE, IV)

The INPUT argument can be of arbitrary length, although it will be internally padded on the right with NULs to the nearest multiple of 8 bytes. INPUT is taken and decrypted using PCBC mode with key schedule SCHEDULE and initialisation vector IV. If OUTPUT is not undef then it assumed to be an lvalue which is grown (if necessary) and receives the decrypted output. Whether or not OUTPUT is undef, the output is also available as the return value of the function.

pcbc_cksum (INPUT, SCHEDULE, IV)

The INPUT argument can be of arbitrary length, although it will be internally padded on the right with NULs to the nearest multiple of 8 bytes. CBC mode is used to generate an 8-byte cryptographic checksum using key schedule SCHEDULE and initialisation vector IV. This checksum is returned.
Functions in package Des which can be imported

random_key ()

Produces a random DES key based on current time, PID and a counter.
read_password (PROMPT [, VERIFY])

Prints PROMPT on the terminal, turns off echo if possible and reads a password from the keyboard. If the optional VERIFY argument is present and true than the password is prompted for a second time and the two are compared. If different, the prompting is repeated. The resulting string is turned into a DES key (using string_to_key (q.v.) internally) and that key is returned.

AppleII::Disk is a Perl module for block-level access to Apple II disk image files.

SYNOPSIS

use AppleII::Disk;
my $disk = AppleII::Disk->new(image.dsk);
my $data = $disk->read_block(1); # Read block 1
$disk->write_block(1, $data); # And write it back :-)

AppleII::Disk provides block-level access to the Apple II disk image files used by most Apple II emulators. (For information about Apple II emulators, try the Apple II Emulator Page at http://www.ecnet.net/users/mumbv/pages/apple2.shtml.) For a higher-level interface, use the AppleII::ProDOS module.
AppleII::Disk provides the following methods:

$disk = AppleII::Disk->new($filename, [$mode])

Constructs a new AppleII::Disk object. $filename is the name of the image file. The optional $mode is a string specifying how to open the image. It can consist of the following characters (case sensitive):

r Allow reads (this is actually ignored; you can always read)
w Allow writes
d Disk image is in DOS 3.3 order
p Disk image is in ProDOS order

If you dont specify d or p, then the format is guessed from the filename. .PO and .HDV files are ProDOS order, and anything else is assumed to be DOS 3.3 order.

If you specify w to allow writes, then the image file is created if it doesnt already exist.

$size = $disk->blocks([$newsize])

Gets or sets the size of the disk in blocks. $newsize is the new size of the disk in blocks. If $newsize is omitted, then the size is not changed. Returns the size of the disk image in blocks.

This refers to the logical size of the disk image. Blocks outside the physical size of the disk image read as all zeros. Writing to such a block will expand the image file.

When you create a new image file, you must use blocks to set its size before writing to it.

$contents = $disk->read_block($block)

Reads one block from the disk image. $block is the block number to read.
$contents = $disk->read_blocks(@blocks)

Reads a sequence of blocks from the disk image. @blocks is a reference to an array of block numbers. As a special case, block 0 cannot be read by this method. Instead, it returns a block full of 0 bytes. This is how sparse files are implemented. If you want to read the actual contents of block 0, you must call $disk->read_block(0) directly.

$contents = $disk->read_sector($track, $sector)

Reads one sector from the disk image. $track is the track number, and $sector is the DOS 3.3 logical sector number. This is currently implemented only for DOS 3.3 order images.

$disk->fully_allocate()

Expands the the physical size of the disk image file to match the logical size of the disk image. It will be expanded as a sparse file if the filesystem containing the image file supports sparse files.

$disk->write_block($block, $contents, [$pad])

Writes one block to the disk image. $block is the block number to write. $contents is the data to write. The optional $pad is a character to pad the block with (out to 512 bytes). If $pad is omitted or null, then $contents must be exactly 512 bytes.

$disk->write_blocks(@blocks, $contents, [$pad])

Writes a sequence of blocks to the disk image. @blocks is a reference to an array of block numbers to write. $contents is the data to write. It is broken up into 512 byte chunks and written to the blocks. The optional $pad is a character to pad the data with (out to a multiple of 512 bytes). If $pad is omitted or null, then $contents must be exactly 512 bytes times the number of blocks.

As a special case, block 0 cannot be written by this method. Instead, that block of $contents is just skipped. This is how sparse files are implemented. If you want to write the contents of block 0, you must call $disk->write_block directly.

$disk->write_sector($track, $sector, $contents, [$pad])

Writes one sector to the disk image. $track is the track number, and $sector is the DOS 3.3 logical sector number. $contents is the data to write. The optional $pad is a character to pad the sector with (out to 256 bytes). If $pad is omitted or null, then $contents must be exactly 256 bytes. This is currently implemented only for DOS 3.3 order images.

$padded = AppleII::Disk::pad_block($data, [$pad, [$length]])

Pads $data out to $length bytes with $pad. Returns the padded string; the original is not altered. Dies if $data is longer than $length. The default $pad is " ", and the default $length is 512 bytes.

If $pad is the null string (not undef), just checks to make sure that $data is exactly $length bytes and returns the original string. Dies if $data is not exactly $length bytes.

pad_block is a subroutine, not a method, and is not exported. You probably dont need to call it directly anyway, because the write_XXX methods will call it for you.

xpertmud project is a fully Perl-scriptable multi-window MUD Client for KDE2.
xpertmud (eXtensible PERl scripTable MUD Client) is an extensible Perl/Python scriptable MUD client.
It supports multiple windows (which are fully scriptable), and has nearly all of the features you would expect from a MUD client: triggers, aliases, keybindings, timers, etc
Main features:
- Using full programming languages (Perl/Python) as scripting languages.
- Nice GUI bindings for scripting languages (open multiple windows, print to windows using ANSI control sequences).
- Scripting callbacks for text entered in the GUI and received from the mud. Enables you to program aliases and triggers.
- Bindings for key-press events (enables you to implement Num-Pad walking and hot-keys).
- Scripting callbacks for timers.
- Nice functions to handle your callbacks easily within the command line environment or scripts.
- Bindings to send text to the server from scripts.
- Dcop scripting capabilities.
- Nice plugin support. Simply put a widget into a plugin and write some wrapper code in the scripting language to use the plugin. Enables you to write any kind of control widgets or time-critical calculations using C++.
- Multi-Line line edit. Just press ctrl-enter to get a new line of input.
- Mud Compression Protocol.
- Support for charset negotiation over telnet
- Support for lots of different charsets, including full utf8 support