Free created equal software for linux

Tk_CreateItemType is a Perl module that define new kind of canvas item.

SYNOPSIS

#include

Tk_CreateItemType(typePtr)

Tk_ItemType * Tk_GetItemTypes()

ARGUMENTS

Tk_ItemType *typePtr (in)

Structure that defines the new type of canvas item.

INTRODUCTION

Tk_CreateItemType is invoked to define a new kind of canvas item described by the typePtr argument. An item type corresponds to a particular value of the type argument to the create method for canvases, and the code that implements a canvas item type is called a type manager. Tk defines several built-in item types, such as rectangle and text and image, but Tk_CreateItemType allows additional item types to be defined. Once Tk_CreateItemType returns, the new item type may be used in new or existing canvas widgets just like the built-in item types.
Tk_GetItemTypes returns a pointer to the first in the list of all item types currently defined for canvases. The entries in the list are linked together through their nextPtr fields, with the end of the list marked by a NULL nextPtr.

You may find it easier to understand the rest of this manual entry by looking at the code for an existing canvas item type such as bitmap (file tkCanvBmap.c) or text (tkCanvText.c). The easiest way to create a new type manager is to copy the code for an existing type and modify it for the new type.

Tk provides a number of utility procedures for the use of canvas type managers, such as Tk_CanvasCoords and Tk_CanvasPsColor; these are described in separate manual entries.

DATA STRUCTURES

A type manager consists of a collection of procedures that provide a standard set of operations on items of that type. The type manager deals with three kinds of data structures. The first data structure is a Tk_ItemType; it contains information such as the name of the type and pointers to the standard procedures implemented by the type manager:

typedef struct Tk_ItemType {
char *name;
int itemSize;
Tk_ItemCreateProc *createProc;
Tk_ConfigSpec *configSpecs;
Tk_ItemConfigureProc *configProc;
Tk_ItemCoordProc *coordProc;
Tk_ItemDeleteProc *deleteProc;
Tk_ItemDisplayProc *displayProc;
int alwaysRedraw;
Tk_ItemPointProc *pointProc;
Tk_ItemAreaProc *areaProc;
Tk_ItemPostscriptProc *postscriptProc;
Tk_ItemScaleProc *scaleProc;
Tk_ItemTranslateProc *translateProc;
Tk_ItemIndexProc *indexProc;
Tk_ItemCursorProc *icursorProc;
Tk_ItemSelectionProc *selectionProc;
Tk_ItemInsertProc *insertProc;
Tk_ItemDCharsProc *dCharsProc;
Tk_ItemType *nextPtr;
} Tk_ItemType;

The fields of a Tk_ItemType structure are described in more detail later in this manual entry. When Tk_CreateItemType is called, its typePtr argument must point to a structure with all of the fields initialized except nextPtr, which Tk sets to link all the types together into a list. The structure must be in permanent memory (either statically allocated or dynamically allocated but never freed); Tk retains a pointer to this structure.

The second data structure manipulated by a type manager is an item record. For each item in a canvas there exists one item record. All of the items of a given type generally have item records with the same structure, but different types usually have different formats for their item records. The first part of each item record is a header with a standard structure defined by Tk via the type Tk_Item; the rest of the item record is defined by the type manager. A type manager must define its item records with a Tk_Item as the first field. For example, the item record for bitmap items is defined as follows:

typedef struct BitmapItem {
Tk_Item header;
double x, y;
Tk_Anchor anchor;
Pixmap bitmap;
XColor *fgColor;
XColor *bgColor;
GC gc;
} BitmapItem;

The header substructure contains information used by Tk to manage the item, such as its identifier, its tags, its type, and its bounding box. The fields starting with x belong to the type manager: Tk will never read or write them. The type manager should not need to read or write any of the fields in the header except for four fields whose names are x1, y1, x2, and y2. These fields give a bounding box for the items using integer canvas coordinates: the item should not cover any pixels with x-coordinate lower than x1 or y-coordinate lower than y1, nor should it cover any pixels with x-coordinate greater than or equal to x2 or y-coordinate greater than or equal to y2. It is up to the type manager to keep the bounding box up to date as the item is moved and reconfigured.

Whenever Tk calls a procedure in a type manager it passes in a pointer to an item record. The argument is always passed as a pointer to a Tk_Item; the type manager will typically cast this into a pointer to its own specific type, such as BitmapItem.

The third data structure used by type managers has type Tk_Canvas; it serves as an opaque handle for the canvas widget as a whole. Type managers need not know anything about the contents of this structure. A Tk_Canvas handle is typically passed in to the procedures of a type manager, and the type manager can pass the handle back to library procedures such as Tk_CanvasTkwin to fetch information about the canvas.

name

This section and the ones that follow describe each of the fields in a Tk_ItemType structure in detail. The name field provides a string name for the item type. Once Tk_CreateImageType returns, this name may be used in create methods to create items of the new type. If there already existed an item type by this name then the new item type replaces the old one.

itemSize

typePtr->itemSize gives the size in bytes of item records of this type, including the Tk_Item header. Tk uses this size to allocate memory space for items of the type. All of the item records for a given type must have the same size. If variable length fields are needed for an item (such as a list of points for a polygon), the type manager can allocate a separate object of variable length and keep a pointer to it in the item record.

FreezeThaw is a Perl module for converting Perl structures to strings and back.
SYNOPSIS
use FreezeThaw qw(freeze thaw cmpStr safeFreeze cmpStrHard);
$string = freeze $data1, $data2, $data3;
...
($olddata1, $olddata2, $olddata3) = thaw $string;
if (cmpStr($olddata2,$data2) == 0) {print "OK!"}
Converts data to/from stringified form, appropriate for saving-to/reading-from permanent storage.
Deals with objects, circular lists, repeated appearence of the same refence. Does not deal with overloaded stringify operator yet.
EXPORT
Exportable
freeze thaw cmpStr cmpStrHard safeFreeze.
User API
cmpStr
analogue of cmp for data. Takes two arguments and compares them as separate entities.
cmpStrHard
analogue of cmp for data. Takes two arguments and compares them considered as a group.
freeze
returns a string that encupsulates its arguments (considered as a group). thawing this string leads to a fatal error if arguments to freeze contained references to GLOBs and CODEs.
safeFreeze
returns a string that encupsulates its arguments (considered as a group). The result is thawable in the same process. thawing the result in a different process should result in a fatal error if arguments to safeFreeze contained references to GLOBs and CODEs.
thaw
takes one string argument and returns an array. The elements of the array are "equivalent" to arguments of the freeze command that created the string. Can result in a fatal error (see above).
Version restrictions:
A lot of objects are blessed in some obscure packages by XSUB typemaps. It is not clear how to (automatically) prevent the UNIVERSAL methods to be called for objects in these packages.
The objects which can survive freeze()/thaw() cycle must also survive a change of a "member" to an equal member. Say, after
$a = [a => 3];
$a->{b} = $a->{a};
$a satisfies
$a->{b} == $a->{a}
This property will be broken by freeze()/thaw(), but it is also broken by
$a->{a} = delete $a->{a};

Gregorian calendar 1582 is a small Python script to generate calendars for any year in the history greater or equal to one.

The output format is the same as the Unix "cal" command. However, it supposes the Gregorian Reformation took place on October 4th, 1582, in contrast to the cal, which supposes the reformation took place on September 3rd, 1752.

Revver is an upload client in Java for the Revver site.

To upload videos to Revver, you need a Revver account (create account now) and the Revver Upload Tool. After you download and double-click the Upload Tool, you can drag and drop a video to post it to your account.

We accept all common formats, including Quicktime, Windows Media, MPEG, MPG, ASF, MOV, WMV and most forms of AVI. Once you upload a video, it will be processed by our system to add the RevTag. To see the status of your files, login to Revver.com.

Creators: Share your videos and earn money.

Were here to help you earn money from your videos. Posting your videos is easy, free, and will get your work in front of a big audience (and its also a good way to share videos with friends). But Revver is much more than that - every video you upload is tagged so that you can earn money when people watch.
Before you post your video anywhere online, get a RevTag.

Unlike most video sites that take videos and give nothing back to creators, we created Revver from the beginning to support videomakers. When you upload a video, well attach a RevTag -- a single frame ad at the end of the video. Every time someone clicks on the ad, youll earn money.

Revver is an equal partnership -- you earn what we earn.

The income from RevTags is always split 50-50 between Revver and the creator. (If a partner site delivers the video to their users, we split the income after subtracting an affiliate commission.) Our success depends on your success. Heres how it works:

1. Create an account

It only takes 2 minutes to sign up and its completely free.

2. Post a video, get a RevTag

Drag and drop to upload your video. Well attach a RevTag to the file.

3. Share it, track it, earn money

Your video will appear on Revver.com and you can link to it or send it to friends. Every time someone clicks on the ad, youll earn money. And no matter where your video travels, the RevTag goes with it.

randoMp3 is a small Perl script that generates playlists for XMMS. randoMp3 script is given the number of entries that should be in the playlist, and then it searches the filesystem for MP3s and randomly selects MP3s to include.

You also can enter a time limit, which causes the script to stop selecting MP3s when the total playing time of all selected MP3 is approximately equal to the given time limit (+/- 4min).

to run the script you have to install the module MP3::Info. You can do this by typing:
$perl -MCPAN -e install MP3::Info

Options:

randomp3.pl -f playlistname -d directory [-t time] [-n number] [-h help]

-f choosen playlistname
-d root directory for mp3s. e.g. /mp3s/
-t the time you want to listen. input in minutes. e.g. 15
-n number of files you want in youre playlist. e.g. 30
-h print help dialog.

you must start the program with -n OR -t
you cannot use both parameters together.

Math::CDF is a Perl module to generate probabilities and quantiles from several statistical probability functions.

SYNOPSIS

use Math::CDF;

$prob = &Math::CDF::pnorm(1.96);

if( not defined($z = &Math::CDF::qnorm(0.975)) ) { die "qnorm() failed"; }

or

use Math::CDF qw(:all);

$prob = pnorm(1.96);

This module provides a perl interface to the DCDFLIB. See the section on DCDFLIB for more information.

Functions are available for 7 continuous distributions (Beta, Chi-square, F, Gamma, Normal, Poisson and T-distribution) and for two discrete distributions (Binomial and Negative Binomial). Optional non-centrality parameters are available for the Chi-square, F and T-distributions. Cumulative probabilities are available for all 9 distributions and quantile functions are available for the 7 continuous distributions.

All cumulative probability function names begin with the character "p". They give the probability of being less than or equal to the given value [ P(X<<less