Free entry points software for linux

Parcelle project is a PyGTK application that captures and saves clipboard history.
Main features:
- Automatically captures clipboard changes.
- Saves clipboard history.
- Sort and search through entries.
- Edit and save changes to entries.
- Edit current clipboard contents.
- Dates entry additions and edits.
- Option to launch on startup to capture quietly.

No-Referrer is a Firefox extension that adds an entry to the context menu that lets you open a link in a new tab, without sending the referrer information.

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.

Dasher is a zooming predictive text entry system, designed for situations where keyboard input is impractical (for instance, accessibility or PDAs).

Dasher is usable with highly limited amounts of physical input while still allowing high rates of text entry.

Dasher is Free software released under the GPL. Further documentation may be found in the Doc/ subdirectory.

ProGuard is a free Java class file shrinker, optimizer, and obfuscator. ProGuard project can detect and remove unused classes, fields, methods, and attributes. It can then optimize bytecode and remove unused instructions.
Finally, it can rename the remaining classes, fields, and methods using short meaningless names. The resulting jars are smaller and harder to reverse-engineer.
More compact jar files also means smaller storage requirements, faster transfer of applications across networks, faster loading, and smaller memory footprints.
ProGuards main advantage compared to other Java obfuscators is probably its compact template-based configuration. A few intuitive command line options or a simple configuration file are usually sufficient. For instance, the following configuration option preserves all applets in a jar:
-keep public class * extends java.applet.Applet
The user manual explains all available options and shows more examples of this powerful configuration style.
ProGuard is fast. It only takes seconds to process programs and libraries of several megabytes. The results section presents actual figures for a number of applications.
ProGuard is a command-line tool with an optional graphical user interface. It also comes with plugins for Ant and for the J2ME Wireless Toolkit.
ProGuard is a Java class file shrinker, optimizer, and obfuscator. The shrinking step detects and removes unused classes, fields, methods, and attributes. The optimization step analyzes and optimizes the bytecode of the methods. The obfuscation step renames the remaining classes, fields, and methods using short meaningless names. The resulting jars are smaller and harder to reverse-engineer.
ProGuard can also be used to list unused fields and methods in an application, and to print out the internal structure of class files.
ProGuard typically reads the input jars (or wars, ears, zips, or directories). It then shrinks, optimizes, and obfuscates them. It then writes the results to one or more output jars (or wars, ears, zips, or directories). The input jars can optionally contain resource files. ProGuard copies all non-class resource files from the input jars to the output jars. Their names and contents remain unchanged.
ProGuard requires the library jars (or wars, ears, zips, or directories) of the input jars to be specified. It can then reconstruct class hierarchies and other class dependencies, which are necessary for proper shrinking, optimization, and obfuscation. The library jars themselves always remain unchanged. You should still put them in the class path of your final application.
In order to determine which code has to be preserved and which code can be discarded or obfuscated, you have to specify one or more entry points to your code. These entry points are typically classes with main methods, applets, midlets, etc.
- In the shrinking step, ProGuard starts from these seeds and recursively determines which classes and class members are used. All other classes and class members are discarded.
- In the optimization step, ProGuard further optimizes the code. Among other optimizations, classes and methods that are not entry points can be made final, and some methods may be inlined.
- In the obfuscation step, ProGuard renames classes and class members that are not entry points. In this entire process, keeping the entry points ensures that they can still be accessed by their original names.
Any classes or class members of your code that are created or invoked dynamically (that is, by name) have to be specified as entry points too. It is generally impossible to determine these cases automatically, but ProGuard will offer some suggestions if keeping some classes or class members appears necessary. For proper results, you should at least be somewhat familiar with the code that you are processing.
ProGuard does handle Class.forName("SomeClass") and SomeClass.class constructs automatically. The referenced classes are preserved in the shrinking phase, and the string arguments are properly replaced in the obfuscation phase. With variable string arguments, it is generally impossible to determine their possible values (they might be read from a configuration file, for instance).
However, as mentioned, ProGuard will note constructs like "(SomeClass)Class.forName(variable).newInstance()". These might be an indication that the class or interface SomeClass and/or its implementations may need to be preserved. You can then adapt your configuration accordingly.
Whats New in 3.9 Stable Release:
- This release fixes a number of bugs.
- Notably, ".class" constructs compiled in Java 6 are now handled correctly.
- The optimization step now avoids a possible division by 0 and correctly processes local variables with indices larger than 255.
- The documentation and examples have been updated.
Whats New in 4.0 Beta Development Release:
- Added preverifier for Java 6 and Java Micro Edition, with new option -dontpreverify.
- Added new option -target to modify java version of processed class files.
- Made -keep options more orthogonal and flexible, with option modifiers allowshrinking, allowoptimization, and allowobfuscation.
- Added support for configuration by means of annotations.
- Improved shrinking of unused annotations.
- Added check on modification times of input and output, to avoid unnecessary processing, with new option -forceprocessing.
- Added new options -flattenpackagehierarchy and -repackageclasses (replacing -defaultpackage) to control obfuscation of packages names.
- Added new options -adaptresourcefilenames and -adaptresourcefilecontents, with file filters, to update resource files corresponding to obfuscated class names.
- Now respecting naming rule for nested class names (EnclosingClass$InnerClass) in obfuscation step, if InnerClasses attributes or EnclosingMethod attributes are being kept.
- Added new inter-procedural optimizations: method inlining and propagation of constant fields, constant arguments, and constant return values.
- Added optimized local variable allocation.
- Added over 250 new peephole optimizations.
- Improved making classes and class members public or protected.
- Now printing notes on suspiciously unkept classes in parameters of specified methods.
- Now printing notes for class names that dont seem to be fully qualified.
- Added support for uppercase filename extensions.
- Rewritten class file I/O code.
- Updated documentation and examples.

PHK is a PHP-oriented package system. PHKs purpose is to package a library or an application, in order to distribute and run it as a single file. As an introduction, you may think of it as a PHP-oriented jar, with a lot of additional features.
Main features:
- No runtime software : as it was said above, there is no runtime software to install before using a PHK archive, as it contains its own runtime code. Any installed PHP (version 5.1.0 or more) is ready to include/execute a PHK archive without any modification.
- Supports libraries, applications, plugins : a PHK archive can contain a library or an application (an application is a library with an entry point). PHK archives can also be used as plugins.
- Unlimited number of subfiles : a PHK archive can contain an unlimited number of subfiles and directories. A subfile can contain up 2 Gbytes of binary data. The total size of a PHK archive is limited to 2Gbytes. Every subfile can be, on a file by file basis, compressed (gzip or bz2), and/or filtered through php_strip_whitespace() (for PHP source).
- Standard locations for package information : PHK provides standard locations for administrative informations like packages name, author, license, copyright, etc. PHK also allows to specify an icon file and an URL. All these inforamtion are displayed in webinfo mode.
- Webinfo mode : in webinfo mode, the PHK archive behaves like a small web site, allowing the user to display every information about the archive, and the content of every subfile. This mode is a standard feature of every PHK archive.
- Mount/umount user scripts : the package author can specify a mount_script. This subfile will be called every time the PHK archive is mounted. In the same manner, an umount_script can be specified.
- Built-in CLI commands : several built-in CLI commands are available. These commands are the equivalent, in CLI mode, of the webinfo mode. They allow to display every information about the PHK archives structure and content.
- Meta-packages : PHK supports meta-packages, allowing a PHK archive to be incorporated as a subfile inside another PHK archive, along with other regular files. This feature is useful for unit tests (see the Zend Framework demonstration packages for an example) or to build meta-libraries (incorporating several librairies, but without mixing them together). These sub-PHK archives can be automatically mounted when the main package is mounted.
- Web path protection : In a PHK archive, the subfiles are protected from incorrect or unauthorized access from the web. The legitimate entry points are explicitely identified, making the package easier to secure. From the web, it is impossible to display or to call a subfile if it is not explicitely enabled by an option. Among other benefits, it allows to suppress the usual empty index.htm files in every directories !
- CRC checksum : A PHK archive includes a CRC checksum mechanism. Depending on the packages options, this checksum can be verified every time the package is mounted, or on users request.
- Digital signatures : A PHK package can be digitally signed (using a digital certificate). This feature allows users to verify that their package comes from a source they trust.

Dir::Which is a Perl module to search for directory entries in a list of directories.

SYNOPSIS

use Dir::Which qw/ which /;

@entries = which(
-entry => "myprog.conf",
-env => "myprog_path",
-defaultpath => ".:".$FindBin::Bin.":/etc:/usr/local/etc") ;

This module searches directory entries (files, dirs, links, named pipes...) in a list of directories specified as a path-like string.

The path string can be specified in an environment variable or as an argument.

Copy URL is an extension which adds an entry to the popup menu.

This extension adds an entry to the popup menu "Copy URL of this page". When selected, the URL of the current page will be copied to the system clipboard. The URL address should be in the clipboard for the use of other applications as well.