Free to human software for linux

Requirements:

• Nodoka GTK
• Engine

Kubuntu Human Theme was created because I started to like the Ubuntu Human theme and when I switched to KDE, I was missing it there. The theme is assembled from various Ubuntu style items, most of which can be found on KDE-look: Ubuntu Cristal background, Human (Revised) color scheme, nuoveXT icons, Ubuntu Kmenu icon, SoftGlow Orange kicker, default Plastik style and Crystal window deco.

Installation of .kth file thru KDE Control Center--Theme Manager--Install; then, if you want exactly the same look, get and install the above items (search on KDE-look). The Kmenu can be changed by replacing each kmenu.png in /usr/share/icons/nuovext/[SIZE]/apps/ Then refresh your icon set.

Number::Bytes::Human is a Perl module that can convert byte count to human readable format.

SYNOPSIS

use Number::Bytes::Human qw(format_bytes);
$size = format_bytes(0); # 0
$size = format_bytes(2*1024); # 2.0K

$size = format_bytes(1_234_890, bs => 1000); # 1.3M
$size = format_bytes(1E9, bs => 1000); # 1.0G

# the OO way
$human = Number::Bytes::Human->new(bs => 1000, si => 1);
$size = $human->format(1E7); # 10MB
$human->set_options(zero => -);
$size = $human->format(0); # -

THIS IS ALPHA SOFTWARE: THE DOCUMENTATION AND THE CODE WILL SUFFER CHANGES SOME DAY (THANKS, GOD!).

This module provides a formatter which turns byte counts to usual readable format, like 2.0K, 3.1G, 100B. It was inspired in the -h option of Unix utilities like du, df and ls for "human-readable" output.

From the FreeBSD man page of df: http://www.freebsd.org/cgi/man.cgi?query=df

"Human-readable" output. Use unit suffixes: Byte, Kilobyte,
Megabyte, Gigabyte, Terabyte and Petabyte in order to reduce the
number of digits to four or fewer using base 2 for sizes.

byte B
kilobyte K = 2**10 B = 1024 B
megabyte M = 2**20 B = 1024 * 1024 B
gigabyte G = 2**30 B = 1024 * 1024 * 1024 B
terabyte T = 2**40 B = 1024 * 1024 * 1024 * 1024 B

petabyte P = 2**50 B = 1024 * 1024 * 1024 * 1024 * 1024 B
exabyte E = 2**60 B = 1024 * 1024 * 1024 * 1024 * 1024 * 1024 B
zettabyte Z = 2**70 B = 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 B
yottabyte Y = 2**80 B = 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 B

I have found this link to be quite useful:

http://www.t1shopper.com/tools/calculate/

If you feel like a hard-drive manufacturer, you can start counting bytes by powers of 1000 (instead of the generous 1024). Just use bs => 1000.

But if you are a floppy disk manufacturer and want to start counting in units of 1024000 (for your "1.44 MB" disks)? Then use bs => 1_024_000.

If you feel like a purist academic, you can force the use of metric prefixes according to the Dec 1998 standard by the IEC. Never mind the units for base 1000 are (B, kB, MB, GB, TB, PB, EB, ZB, YB) and, even worse, the ones for base 1024 are (B, KiB, MiB, GiB, TiB, PiB, EiB, ZiB, YiB) with the horrible names: bytes, kibibytes, mebibytes, etc. All you have to do is to use si => 1. Aint that beautiful the SI system? Read about it:

http://physics.nist.gov/cuu/Units/binary.html

You can try a pure Perl "ls -lh"-inspired command with the one-liner, er, two-liner:

$ perl -MNumber::Bytes::Human=format_bytes
-e printf "%5s %sn", format_bytes(-s), $_ for @ARGV *

Why to write such a module? Because if people can write such things in C, it can be written much easier in Perl and then reused, refactored, abused. And then, when it is much improved, some brave soul can port it back to C (if only for the warm feeling of painful programming).

ctopy automates the parts of translating C source code to Python source code that are difficult for a human but easy for a machine.

This allows a human programmer to concentrate on the nontrivial parts of the translation.

xquarto project is a two-player board game based on logic.

Xquarto is a board game designed for the X windows environment. The game is a two-player game, although for the moment,it is only possible to play against the computer. The board is composed of 4x4 squares and 16 pieces. Each piece has four
properties: black or brown, horizontal or vertical, solid or hollow, round or square. This makes up 16 possible combinations and there is exactly one piece for each possibility.

Initially, the board is empty and it is successively filled with pieces. The game is over when a row, a column or a diagonal has four pieces carrying a common property in it, e.g. four black (brown) pieces, four square (round) pieces, four filled
(hollow) pieces, four horizontal (vertical) pieces. In the original quarto rules, the player who is the first to complete a row, column or diagonal as described above wins. This is the implicit mode under which xquarto runs. A variant of the game (tic rules) consists rather of avoiding alignments, i.e. the player who is forced to complete
an alignment loses.

The game is a two-player game. Player 1 chooses one of the 16 pieces. Player 2 then places this piece on one of the 16 squares of the board and chooses a piece out of the remaining 15 pieces which he gives to player 1, who places this piece on one of the remaining 15 squares on the board, etc...

Xquarto supports three different player combinations: human vs computer, computer vs human and human vs human (possibly through the local network in the latter case). The default combination is human vs computer, i.e. the human player starts the game against the computer. This can be changed by clicking on the "Actions" menu (see below for more details).

The rules are really very simple - believe me!

Patolli is a turn-based ancient Aztec/Mayan game written in C using the SDL library. Patolli used to be the favorite of the ancient Mayan/Aztec time.
The object of the game is to win all of your opponents money. In order to do this, you may have to play more than one game.
Main features:
- implement GPL sounds (if there is a such thing)
- create a make install target
- credits menu option
- sound/no sound switch
- music/no music switch
- human player name
- network version to play against other humans
- clean up the code (although there are lots of comments, the structure is very bad and needs to be cleaned up)

PureAdmin is a graphical utility used to administer and monitor your PureFTPd ftp server.
PureAdmin is a graphical tool used to make the management of PureFTPd a little easier.
PureAdmin project features a user manager, viewing of activities (uploads/downloads) and logfile viewing (updated in realtime).
It is not dependant on GNOME (only GTK+ 2.x) and it is developed with the GNOME Human Interface Guidelines in mind.
Enhancements:
- Fixed a startup-notification bug
- Fixed some bugs with the notification icon
- Added new tango based icons in various sizes.