Free binhex 4 software for linux

JBinHex is both a library and a command-line tool, written in Java, to decode files in the Apple Macintosh BinHex 4.0 format.

It accepts the following command line parameters:

Either -u < url > or -f < file > to specify the source BinHexed file. If neither of those options is present, DeBinHex reads stdin.
-d to decode the data fork. It will be put in the file with the name that came from the BinHex header.
-df < filename > to decode the data fork to the named file instead of the name that came from the BinHex header.
-r to decode the resource fork. It will be put in the file with the name that came from the BinHex header, with the extension ".resource" appended to it.
-rf < filename > to decode the resource fork to the named file instead of the name that came from the BinHex header.
Both -d/-df options and -r/-rf may be present at the same time. If none of these options is present, DeBinHex will decode the data fork as if the -d options was specified.
-h to only show the header of the BinHex file on stdout. The decoding options are ignored.

Convert::BinHex can extract data from Macintosh BinHex files.

ALPHA WARNING: this code is currently in its Alpha release. Things may change drastically until the interface is hammered out: if you have suggestions or objections, please speak up now!

SYNOPSIS

Simple functions:

use Convert::BinHex qw(binhex_crc macbinary_crc);

# Compute HQX7-style CRC for data, pumping in old CRC if desired:
$crc = binhex_crc($data, $crc);

# Compute the MacBinary-II-style CRC for the data:
$crc = macbinary_crc($data, $crc);

Hex to bin, low-level interface. Conversion is actually done via an object ("Convert::BinHex::Hex2Bin") which keeps internal conversion state:
# Create and use a "translator" object:
my $H2B = Convert::BinHex->hex2bin; # get a converter object
while (< STDIN >) {
print $STDOUT $H2B->next($_); # convert some more input
}
print $STDOUT $H2B->done; # no more input: finish up

Hex to bin, OO interface. The following operations must be done in the order shown!
# Read data in piecemeal:
$HQX = Convert::BinHex->open(FH=>*STDIN) || die "open: $!";
$HQX->read_header; # read header info
@data = $HQX->read_data; # read in all the data
@rsrc = $HQX->read_resource; # read in all the resource

Bin to hex, low-level interface. Conversion is actually done via an object ("Convert::BinHex::Bin2Hex") which keeps internal conversion state:
# Create and use a "translator" object:
my $B2H = Convert::BinHex->bin2hex; # get a converter object
while (< STDIN >) {
print $STDOUT $B2H->next($_); # convert some more input
}
print $STDOUT $B2H->done; # no more input: finish up

Bin to hex, file interface. Yes, you can convert to BinHex as well as from it!
# Create new, empty object:
my $HQX = Convert::BinHex->new;

# Set header attributes:
$HQX->filename("logo.gif");
$HQX->type("GIFA");
$HQX->creator("CNVS");

# Give it the data and resource forks (either can be absent):
$HQX->data(Path => "/path/to/data"); # here, data is on disk
$HQX->resource(Data => $resourcefork); # here, resource is in core

# Output as a BinHex stream, complete with leading comment:
$HQX->encode(*STDOUT);

PLANNED!!!! Bin to hex, "CAP" interface. Thanks to Ken Lunde for suggesting this.
# Create new, empty object from CAP tree:
my $HQX = Convert::BinHex->from_cap("/path/to/root/file");
$HQX->encode(*STDOUT);

BinHex is a format used by Macintosh for transporting Mac files safely through electronic mail, as short-lined, 7-bit, semi-compressed data streams. Ths module provides a means of converting those data streams back into into binary data.

LinCVS is a graphical Interface for the cvs client commandline tool on the Unix, Windows and Mac OS X platform. LinCVS allows to load modules from a server (checkout), create modules on the server (import), as well as checking the state of directories and individual files or updating them.
Basic operations like add, remove and commit are supported as matter of course, just like showing the actual differences between the server version and the local sandbox, graphical display of the version tree, and manifoldy graphical support of project maintenance. All actions are logged on the cvs server (configurable via history), and are therewith comprehensible.
To keep LinCVS independant of the cvs version, LinCVS uses the local but separat installed cvs and therewith always should work with the latest version.
After choosing a startup dir, the project-explorer searches the subdirectories for cvs projects, and displays these on the workbench. Now all functions on one/many files or whole directories can be accessed over pulldown menues or simply a right mouseclick. The state of the individual directories is continuously scanned by LinCVS.
This means the symbol of the dir tells the user that there are for example still uncommited changes somewhere in the depth of a dir hierarchy, even without having opened them yet. So the project state is visualized right after a cvs status call. Completed with on-the-fly dir scanning, LinCVS is qualified for large projects with many thousand files.
Because of the continuous efforts of network administrators, to encrease network security, LinCVS supports all standard cvs connection protocols. Proxy support is also available, this requires a patched cvs. This is of course available on our download page.
Because LinCVS does not affect the cvs internal project maintenance, a concurrent use with cvs commandline is possible. The function of the LinCVS dir state display is not impaired therewith.
Even though LinCVS graphically supports almost the whole cvs range of functions (and is continuously under development;-), it is easy to customize the GUI to the individual needs. Popup menues are freely configurable, while the menues always provide full feature access. An extra toolbar enables direct access to often used features.
In contrast to other programs this one is really easy to use.
Enhancements:
- This version fixes a lot of bugs.

IMP H3 is the Internet Messaging Program, allows Web-based access to IMAP and POP3 mail servers and provides a range of features normally found only in desktop email clients.

There are several current branches of IMP. IMP 4.1.x is the current production version of the stable branch. It requires PHP 4.3.0 and version 3.x of the Horde framework. It adds new features like crypting support, flexible charset handling, virtual folders for saved searches, a WYSIWYG editor for creating HTML messages, improved MIME message handling, and many more.

IMP 3.2.8 is the latest production version of the previous stable branch. It requires PHP 4.1.0 and version 2.0 of the Horde framework. It adds advanced features such as searching multiple mailboxes, identities, and a hierarchical mailbox navigator, as well as a cleaner, redesigned user interface. As with IMP 2.2 before it, it passes the "MIME Torture Test" that UW makes available.

DeuTex is a wad composer for Doom, Heretic, Hexen and Strife. It can be used to extract the lumps of a wad and save them as individual files. Conversely, it can also build a wad from separate files. When extracting a lump to a file, it does not just copy the raw data, it converts it to an appropriate format (such as PPM for graphics, Sun audio for samples, etc.).
Conversely, when it reads files for inclusion in pwads, it does the necessary conversions (for example, from PPM to Doom picture format).If you like to do wad hacking beyond level editing, DeuTex is a must. In addition, DeuTex has functions such as merging wads, etc. I use it all the time.
Main features:
- Supported platforms
- Unix and DOS. Should not be difficult to port to other platforms.
- Supported iwads
- Doom, Doom II, Ultimate Doom, Doom alpha 0.4 and 0.5, Doom press release pre-beta, Heretic, Hexen, Strife.
- Supported file formats
- .au, .voc, .wav, .bmp, .gif (will go away), .ppm.
Enhancements:
- default transparent colour is (0, 47, 47) instead of (0, 255, 255),
- flats are put between FF_START and F_END,
- Doom alpha 0.4 and Doom alpha 0.5 are supported,
- Doom press release pre-beta is supported,
- Hexen is supported,
- Strife is supported,
- new command -usedidx,
- on Unix (especially Linux), builds much more smoothly,
- on DOS and Windows, builds with DJGPP and Cygwin,
- source available and libre license (GPL + LGPL + Pbmplus),
- GIF is deprecated,
- many bug fixes and small improvements.

Tribler is a P2P client with special focus on social networking.
Easy downloading
- Adds more than simple keyword search, youtube grid
Recommendation and Friends
- See what other people like, related files, find person with the same taste
Video on Demand
- When the download is on its way, you can use the integrated video player to start watching ASAP
Wealth of content
- Search both Bittorrent, Youtube, and Liveleak for content.
All-in-one interface
- No need to hunt down .torrent files on websites, upgrade to the latest Divx codecs, install the Flash plugin. Tribler has one-stop shopping

wxSand is a Falling Sand Game is a particle toy - you can play with different elements, explore how they interact, and, in some reimplementations, make your own elements.

It is great fun to make interactive structures, ecosystems, and toys in a Falling Sand Game.

First of all, mad props go out to the original creator of this game. Great idea. I only wish I could read Japanese... Heres a link to the original, or at least as close to the original as I can find (Again, without knowing how to read Japanese.)
http://ishi.blog2.fc2.com/blog-entry-158.html

Having wasted hours of productivity on the Java verison of the Falling Sand Game, I began to think of improvements that could be made from the original. No source was available for the original, and Java isnt my choice programming language, that I decided to start de novo with C/C++ and the cross-platform wxWidgets.

(I leave it to you Java fans out there to make your own improved Falling Sand Game.)

I tend to feel that The Falling Sand Game should be more of a Zen experience than anything else. I also belive that the game should be as cyclic as possible, so that environments can run and evolve for long periods of time. Finally, I realized the close connection of The Sand Game with the game of Life: Whereby, with a few very simple rules, and some starting conditions, you can create a very unpredictable outcome.
Of course, the original is pretty sweet. So Ive make a version with my own rules, and one with the original rules, and then one with the original rules plus some neat extra items. I have implemented many, many more interactions and elements than the original version. Discover them as you play.

Version 2 has no fire (Versions 3 & 4 do, though.) I dont like how easy it is to destroy everything. It also doesnt have any free-moving characters. I feel they distract attention from the evolution of the field.

Originally, I didnt want to make this Open Source. I think it takes away from the mysticism of the game. Those of you that are so inclined should be able to see the simple algorithm. Note the close connection with the game of Life. Also note the impossible situations, like unequalized water levels. These arent shortcomings of the game, but instead interesting artifacts of the rules of this alternate reality!