SVG-cards is a set of playing cards made from pure SVG with all kings, queens, jacks, numbers, jokers, and backs of cards.

You can use SVG-cards everywhere you like : Web pages, games, the GNOME desktop, the KDE desktop, and so on...

You can print them on your color printer and make real cards or T-shirts.

The kings, queens and jacks are based on the french representation, because I find them beautiful. You can access to each either by rendering the file into a pixmap and clipping each card or by using their name with a DOM interface. All cards are inside a SVG group.

Example :

the king of spade is inside this group :

< g id="king_spade" >
...
< /g >

Names are the following :

black_joker
red_joker
back
{king,queen,jack}_{club,diamond,heart,spade}
{1,2,3,4,5,6,7,8,9,10}_{club,diamond,heart,spade}

Examples :

- the ace of club is 1_club
- the queen of diamond is queen_diamond

Whats New in This Release:

· A bug that prevented SVG cards from being displayed in Firefox and Adobe Illustrator was fixed.

WML::Card is a Perl extension for builiding WML Cards according to the browser being used.

SYNOPSIS

use WML::Card;
my $options= [ [Option 1, http://...], [Option 2, http://...], ];
my $c = WML::Card->guess(index,Wap Site); $c->link_list(indice, undef, 0, $options, $options); $c->print;

This perl library simplifies the creation of WML cards on the fly. It produces the most suitable wml code for the browser requesting the card. In this way the one building the cards does not have to worry about the differences in how each wap browser displays the wml code. In combination wht WML::Deck it provides functionality to build WAP applications.

Methods

$card = WML::Card->guess( $id, $title, [$user_agent] );
This class method constructs a new WML::Card object. The first argument defines the WML cards id and the second argument its title. The if the third argument is not defined, the value is obtained from $ENV{HTTP_USER_AGENT}.

$c->buttons($label, $type, $task, $href)
$c->table ($data, $title, $offset, $pager, @headers)
$c->link_list($name, $listtitle, $offset, $pager, $data, $align)
$c->value_list($name, $listtitle, $offset,$pager,$data)

The variable $data is an array reference like: my $menu_items= [ [Option 1, http://...], [Option 2, http://...], ];

The variable $pager is the number of items wanted to be displayed in each card.

$c->print
$c->info($content)
$c->img($file, $alt)
$c->input($label, $text, $name, $format, $type, $size, $target, $arg);
$c->link($target, $text);
$c->br

Penguin Cards project is a card game.

PenguinCards is a two-player card game. The aim is to find the pairs of cards on the board. The one who finds out more card pairs is the winner.

PenguinCards is a java-based game.

If you are unhappy with images on the cards, then simply copy your cards into images/pictures/penguins directory. That is it!

Whats New in This Release:

· Initial release

Games::Cards is a Perl module for writing and playing card games.

SYNOPSIS

use Games::Cards;
my $Rummy = new Games::Cards::Game;

# Create the correct deck for a game of Rummy.
my $Deck = new Games::Cards::Deck ($Rummy, "Deck");

# shuffle the deck and create the discard pile
$Deck->shuffle;
my $Discard = new Games::Cards::Queue "Discard Pile";

# Deal out the hands
foreach my $i (1 .. 3) {
my $hand = new Games::Cards::Hand "Player $i" ;
$Deck->give_cards($hand, 7);
$hand->sort_by_value;
push @Hands, $hand;
}

# print hands (e.g. "Player 1: AS 2C 3C 3H 10D QS KH")
foreach (@Hands) { print ($_->print("short"), "n") }

$Hands[1]->give_a_card ($Discard, "8D"); # discard 8 of diamonds

This module creates objects and methods to allow easier programming of card games in Perl. It allows you to do things like create decks of cards, have piles of cards, hands, and other sets of cards, turn cards face-up or face-down, and move cards from one set to another. Which is pretty much all you need for most card games.

bingo-cards project consists in a program to create number, word/letter, and picture bingo cards.

These cards can be used for entertainment in the car, in a classroom (for example, to teach the element symbols for the Periodic Table), or just with your kids.

You could also create bingo cards with little pictures of everyday objects, then call the names out in Spanish, French, Italian, or German (or whatever you fancy).

Whats New in This Release:

· Win32 Borland CBuilder 3 version ported to Kylix Linux. All tested. Only major issue is cannot select multiple pictures for import. Note for compilation to work, put included crt1.o in /usr/lib {it is a dependency of Kylix, and is crt1.o from glibc-devel 2.1.92}.
· First port of GUI to Linux using Kylix. Seems to work fine, apart from bulk adding of pictures fo picture bingo. (need to add one at a time).

Nebula Cards project is a card game engine.

Nebula Cards is a networked, modular card game engine written in pure Java.

The game rules, user interfaces, and computer players all take the form of pluggable Java classes, and most four-player, trick-taking games can be implemented.

It currently includes Spades and Hearts, with a computer player for Spades.

Whats New in This Release:

· last release before a major restructuring.
· added Game class in a backward-compatible way.
· added util.proc to house the new GameProcedure library.
· added util.ui.GraphicalCardSelector (untested).

Khalkhi cards allows you to have cards of the entries in your addressbook floating on the desktop, see the status in the several systems a person has an account in, and do a lot of things, like surfing to her homepage, starting an email or a chat, or dropping her a file/url.

A card lists all properties of an addressbook entry. Are status services installed for a property, the status is displayed below the property item. Actions services are available by the context menu (right click on a property item), and so called data action services by the drop menu (drag a file/url onto the card or an item).

The program is based upon the Khalkhi framework, thus endlessly extendable by plugins. It cannot be used directly, is only available by a service within the framework. So install also the framework and the Khalkhi applet for Kicker:

http://www.kde-apps.org/content/show.php?content=54450
http://www.kde-apps.org/content/show.php?content=54451

Needs 0.2.2 of the Khalkhi framework (see link above).

Whats New in This Release:

· adaption to rename of Contacts framework to Khalkhi framework

Games::Cards::Poker is a Perl module for Pure Perl Poker functions.

SYNOPSIS

use Games::Cards::Poker;

# Deal Four (4) players hands and score them...
my $players = 4; # number of players to get hands dealt
my $hand_size = 5; # number of cards to deal to each player
my @hands = ();# player hand data
my @deck = Shuffle(Deck());

while($players--) {
push(@{$hands[$players]}, pop(@deck)) foreach(1..$hand_size);
printf("Player$players score:%4d hand:@{$hands[$players]}n",
ScoreHand(@{$hands[$players]}));
}

Poker provides a few functions for creating decks of cards and manipulating them for simple Poker games or simulations.

Generator project is a Sega Genesis (MegaDrive) emulator.

Generator is a portable Sega Genesis (Mega Drive) emulator with gtk/SDL, SVGAlib and Tcl/Tk user interfaces.

It features its own unique portable 68000 core processor emulation enhanced by recompilation techniques.

Whats New in This Release:

· [CORE] Support for Genecyst patch files / Game Genie
· [CORE] Support for AVI uncompressed and MJPEG output
· [68000] Re-added busy wait removal that got lost
· [SOUND] Added configurable single-pole low-pass filter
· [CORE] Added autoconf/automake version checks
· [VDP] Fix FIFO busy flag (Nicholas Van Veen)
· [SOUND] Various further endian improvements from Bastien Nocera
· and andi@fischlustig.de (Debian)
· [SOUND] Various BSD compatibility improvements from
· Alistair Crooks and Michael Core (NetBSD)
· [UI] SDL Joystick support from Matthew N. Dodd (FreeBSD)
· [68000] Do pre-decrement with two reads (Steve Snake)
· [68000] Make TAS not write (Steve Snake) fixes Gargoyles, Ex Mutant
· [68000] Re-write ABCD,etc based on info from Bart Trzynadlowski
· [68000] Implement missing BTST op-code (fixes NHL Hockey 94)

XML::Generator is a Perl extension for generating XML.

SYNOPSIS

use XML::Generator :pretty;

print foo(bar({ baz => 3 }, bam()),
bar([ qux => http://qux.com/ ],
"Hey there, world"));

# OR

use XML::Generator ();

my $X = XML::Generator->new(:pretty);

print $X->foo($X->bar({ baz => 3 }, $X->bam()),
$X->bar([ qux => http://qux.com/ ],
"Hey there, world"));
Either of the above yield:
< foo xmlns:qux="http://qux.com/" >

< bam / >
< /bar >
< qux:bar >Hey there, world< /qux:bar >
< /foo >

In general, once you have an XML::Generator object, you then simply call methods on that object named for each XML tag you wish to generate.

By default, use XML::Generator; tries to export an AUTOLOAD subroutine to your package, which allows you to simply call any undefined methods in your current package to get pieces of XML. If you already have an AUTOLOAD defined then XML::Generator will not override it unless you tell it to. See "STACKABLE AUTOLOADs".

XML::Generator::Essex is a Perl module that can generate XML with Essex.

SYNOPSIS

package My::Generator;

use XML::Generator::Essex;
@ISA = qw( XML::Generator::Essex );

use strict;

sub main { # Called by XML::Generator::Essex->generate().
my $self = shift;
}

## And, to use:

my $g = MY::Generator->new( Handler => $h );
$g->generate( ... );

Provides Essex output primitives like put() and constructors for essex events.

Methods

put

Example Whats emitted
======= ==============
put; ## (whatevers in $_: event, characters, etc)
put "text "foo" ] ## < a >foo< /a >
put comment "foo"; ## < !--foo-- >
put $event; ## an event (see constructors below)
put $data; ## Emit a data structure
put @list; ## Emit multiple events and / or data structures

Emits one or more data structures as XML. Returns the result of emitting the last event (ie the result from the next SAX processor).

Most of the things you can pass to put (strings, constructed events) are relatively self evident.

For instance, you can pass any events you construct, so an Essex script to make sure all character data is emitted in CDATA sections might look like:

get( "text()" ), put cdata $_ while 1;

A less obvious feature is that you can pass a (possibly nested) Perl ARRAY that defines an XML tree to emit:

put [
root => { id => 1 }, ## HASHes contain attributes
"root content",
[ a => "a content" ],
"more root content",
[ b => { id => 2 }, "b content" ],
];

will emit the SAX events corresponding to the XML (whitespace added for legibility):

< root id="1" >
root content
< a >a content< /a >
more root content
< b id="2" >b content< /b >
< /root >

NOTE: this does not allow you to control attribute order.

By using the DOM constructors, you could also write the above as:

put elt(
root => { id => 1 }, ## HASHes contain attributes
"root content",
elt( a => "a content" ),
"more root content",
elt( b => { id => 2 }, "b content" ),
];

to emit the XML < root id="1" >< !--comment-- >content< /root >.

You can actually pass any blessed object to put() that provides a generate_SAX() method. This will be called with the results of $self->get_handler() (which may be undefined) and should return a TRUE if the handler is undefined or if no events are sent. If any events are sent, it should return the result of the last event.

See XML::Essex::Model for some more examples.

put() is a bit DWIMy: it will fill in the name of end_elements for you if you leave them out:
put start "foo";
...
put end;

It will also die() if you emit the wrong end_elt for the currently open element (it keeps a stack), or if you emit and end_document without emitting end_elements. You can catch this error and put() the proper end_element events if you like.

If the filter exits after half-emitting a document and does not set a result, an error is emitted. This is to notify you that a document was half-emitted. die() to get around this.

Note that downstream filters are free to cache things you send, so dont modify events once theyre sent. If you need to do that, send a copy and modify the original.

output_monitor

Returns a handle to the output monitor. See XML::Essex::Filter::OutputMonitor for details.

SQL::Generator is a Perl module to generate SQL-statements with oo-perl.

SYNOPSIS

use SQL::Generator;

With this module you can easily (and very flexible) generate/construct sql-statements. As a rookie, you are used to write a lot of sprintf`s every time i needed a statement (i.e.for DBI).

Later you start writing your own functions for every statement and every sql-dialect (RDBMS use to have their own dialect extending the general SQL standard). This SQL::Generator module is an approach to have a flexible abstraction above the statement generation, which makes it easy to implement in your perl code. Its main purpose is to directly use perl variables/objects with SQL-like code.

WSDL::Generator is a Perl module to generate wsdl file automagically.

SYNOPSIS

use WSDL::Generator;
my $wsdl = WSDL::Generator->new($init);
Foo->a_method($param};
print $wsdl->get(Foo);

You know folks out there who use another language than Perl (huh?) and you want to release a SOAP server for them

1/ thats very kind of you
2/ you need to generate a wsdl file
3/ this module can help

Because Perl is dynamically typed, it is a fantastic language to write SOAP clients, but that makes perl not-so-easy to use as SOAP server queried by statically typed languages such as Delphi, Java, C++, VB...

These languages need a WSDL file to communicate with your server.
The WSDL file contains all the data structure definition necessary to interact with the server.

It contains also the namespace and URL as well.

PerlPoint::Generator::SDF is a generic SDF generator.

METHODS

new()

Parameters:

class

The class name.

Returns: the new object.

XML::Generator::DOM is an XML::Generator subclass for producing DOM trees instead of strings.

SYNOPSIS

use XML::Generator::DOM;

my $dg = XML::Generator::DOM->new();
my $doc = $dg->xml($dg->xmlcmnt("Test document."),
$dg->foo({baz => bam}, 42));
print $doc->toString;
yields:
< ?xml version="1.0" standalone="yes"? >
< !--Test document-- >
< foo baz="bam" >42< /foo >

XML::Generator::DOM subclasses XML::Generator in order to produce DOM trees instead of strings (see XML::Generator and XML::DOM). This module is still experimental and its semantics might change.

Essentially, tag methods return XML::DOM::DocumentFragment objects, constructed either from a DOM document passed into the constructor or a default document that XML::Generator::DOM will automatically construct.

Calling the xml() method will return this automatically constructed document and cause a fresh one to be constructed for future tag method calls. If you passed in your own document, you may not call the xml() method.

Below, we just note the remaining differences in semantics between XML::Generator methods and XML::Generator::DOM methods.