Free pack software for linux

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

QUAKE 4 Quakemas Map Pack is a bonus collection for Christmas with maps for Quake 4.

This Map Pack is compatible with QUAKE 4 1.0, and updates 1.0.4.0 and 1.0.5.0.

This Map Pack consists of the file pak013.pk4 and contains the following multiplayer maps:

Campgrounds Redux (q4dm9):

With QUAKE 4s updated technology, Campgrounds Redux now has a fresh look and feel, revitalizing this QUAKE III(tm) classic. Excellent for any number of players, this updated version supports Deathmatch, Team Deathmatch and Tournament modes, where hard-core QUAKE fans can get crazy with this throw-back to one of their old favorites.

Railed (q4tourney1):

Set in an abandoned, rusting Strogg facility, the environment in Railed produces fast-paced frenetic tournament style action! This new map is all about close-quarters combat and hair-trigger reflexes as players hustle through the winding, multi-tiered corridors. Designed especially for Tournament play, Railed also supports Deathmatch and Team Deathmatch game modes, and is guaranteed to provide some thrilling fast-action gameplay.

Tremors (q4ctf7):

Built within a twisting underground cavern and peppered throughout with pipes, bridges, and catwalks, Tremors demands tactical expertise. Enemies attack from above and below in the enormous, multi-tiered environment, making team-play invaluable. Tremors is perfect for huge Capture-The-Flag games, and also supports the Arena Capture-The-Flag gameplay mode.

To use the new maps in the map rotation cycle, a new map cycle script file has been included with the Map Pack, called mapcycle-mp1.scriptcfg.

To use the new map cycle script:

1. On the Multiplayer- Create Server screen, click "Advanced Options"
2. In the "Map cycle script file" field, enter mapcycle-mp1.scriptcfg
3. Click "Close advanced options"
4. Start the server

Alternately, this can be set with the console command:

g_mapCycle mapcycle-mp1.scriptcfg

To uninstall, simply delete the pak013.pk4 file from your QUAKE 4q4base directory.

Algorithm::BinPack is a Perl module that can efficiently pack items into bins.

SYNOPSIS

Algorithm::BinPack efficiently packs items into bins. The bins are given a maximum size, and items are packed in with as little empty space as possible. An example use would be backing up files to CD, while minimizing the number of discs required.

my $bp = Algorithm::BinPack->new(binsize => 4);

$bp->add_item(label => "one", size => 1);
$bp->add_item(label => "two", size => 2);
$bp->add_item(label => "three", size => 3);
$bp->add_item(label => "four", size => 4);

for ($bp->pack_bins) {
print "Bin size: ", $_->{size}, "n";
print " Item: ", $_->{label}, "n" for @{ $_->{items} };
}

METHODS

new

Creates a new Algorithm::BinPack object. The maximum bin size is specified as a named argument binsize, and is required. A fudge factor may be specified as a named argument fudge. If a fudge factor is specified, item sizes will be rounded up to a number divisible by the fudge factor. This can help keep items with similar sizes in order by their labels.

my $bp = Algorithm::BinPack->new(binsize => 4);
my $bp = Algorithm::BinPack->new(binsize => 100, fudge => 10);

add_item

Adds an item to be packed into a bin. Required named arguments are label and size, but any others can be specified, and will be saved. An optional bin argument can be used to manually put an item into the specified bin.

$bp->add_item(label => one, size => 1);
$bp->add_item(label => two, size => 2, desc => The second numeral);
$bp->add_item(label => zero, size => 3, bin => 0);
$bp->add_item(qw(label three size 3));
$bp->add_item(qw(label four size 4 random key));

prefill_bin

(Deprecated method) add_item now knows how to handle the bin argument directly, so this method is redundant.

pack_bins

Packs the items into bins. This method tries to leave as little empty space in each bin as possible. It returns a list of hashrefs with the key size containing the total bin size, and items containing an arrayref holding the items in the bin. Each item is in turn a hashref containing the keys label, size, and any others added to the item. If a fudge factor was used, each item will contain a key fudgesize, which is the size this item was fudged to.

for my $bin ($bp->pack_bins) {
print "Bin size: ", $bin->{size}, "n";

for my $item (@{ $bin->{items} }) {
printf " %-6s %-20sn", $_, $item->{$_} for keys %{ $item };
print " ---n";
}
}

Tie::Array::PackedC is a tie a Perl array to a C-style array (packed; elements of a single, simple data type).

SYNOPSIS

use Tie::Array::PackedC qw(packed_array packed_array_string);
my $ref=packed_array(1,2,3,4);
my $ref2=packed_array_string(my $s,1,2,3,4);

use Tie::Array::PackedC Double=>d;
tie my @array,Tie::Array::PackedC::Double,1..10;
$array[0]=1.141;

Provides a perl array interface into a string containing a C style array. In other words the string is equivelent to the string that would be returned from the equivelent pack command (defaulting to pack type "l!") using a normal array of the same values. Eg:

my @foo=(1..10);
my $string=pack "l!*",@foo;

leaves $string in basically the same condition as

my (@foo,$string);
tie @foo,Tie::Array::PackedC,$string,1..10;

Its only basically the same and not exactly the same because the tie version may be longer due to preallocation.

Slackfr Media pack is a set of multimedia packages for the Slackware Linux distribution.
It contains:
- a52dec
- avifile
- binaries-codec
- divx4linux
- faac-1.25
- faad2-2.5
- ffmpeg-snapshot
- lame-3.97
- libdv
- libdvdcss
- libdvdnav
- libdvdread
- libebml
- libfame
- libmatroska
- live
- mpeg2dec
- win32_dmo
- x264
- xvidcore
- Transcode
- MPlayer

Wolfenstein: Enemy Territory is a Multiplayer Online First Person Shooter. Wolfenstein: Enemy Territory is a team game; you will win or fall along with your comrades. The only way to complete the objectives that lead to victory is by cooperation, with each player covering their teammates and using their class special abilities in concert with the others.

Featuring multiplayer support for as many as 64 players, Wolfenstein: Enemy Territory challenges gamers to the ultimate test of teamwork and strategy. Each of the five character classes is critical to a teams ultimate victory or defeat on the battlefield. The Covert Operative class allows players to steal uniforms, perform reconnaissance and gain access to enemy positions. While, the Engineer allows the Axis and Allied teams to lay and diffuse mines as well as build battlefield bridges, towers, forward command bases and other improvements in the midst of combat to gain advantages for their team.

Wolfenstein: Enemy Territory further online players the option to slug it out in the intense Team Last-Man-Standing game mode, where squad-mates cooperate to ensure their team has the last surviving man on the battlefield. With new game modes, character classes, weaponry, and added tactical skills, Wolfenstein: Enemy Territory will keep gamers in the trenches for hours.

Net::Packet::CDP::TypeSoftwareVersion is a Perl module for Cisco Discovery Protocol Software Version extension header.

SYNOPSIS

use Net::Packet::Consts qw(:cdp);
require Net::Packet::CDP::TypeSoftwareVersion;

# Build a layer
my $layer = Net::Packet::CDP::TypeSoftwareVersion->new(
type => NP_CDP_TYPE_SOFTWARE_VERSION,
length => 8,
softwareVersion => GGGG,
);
$layer->pack;

print RAW: .unpack(H*, $layer->raw)."n";

# Read a raw layer
my $layer = Net::Packet::CDP::TypeSoftwareVersion->new(raw => $raw);

print $layer->print."n";
print PAYLOAD: .unpack(H*, $layer->payload)."n"
if $layer->payload;

This modules implements the encoding and decoding of the Cisco Discovery Protocol Software Version type extension header.