Free label software for linux

Color Label is a service menu for KDE based on Color Folder 0.3.4 by HessiJames.

HowTo:

Extract all files and

copy colorlabel into /usr/bin/...

perhaps you need to make it executable chmod 755 /usr/bin/colorlabel

copy colorlabel.desktop to /home/~/.kde/share/apps/konqueror/servicemenus/colorlabel.desktop

gLabels is a lightweight program for creating labels and business cards for the GNOME desktop environment.
gLabels project is designed to work with various laser/ink-jet peel-off label and business card sheets that youll find at most office supply stores.
Whats New in 2.0.4 Stable Release:
- This release primarily fixes a couple of crashes when built on GNOME 2.12.
Whats New in 2.1.4 Development Release:
- This development release features a large overhaul of some of the underlying technologies.
- This includes migrating to GtkPrintOperation, Cairo, and Pango.

PostScript::MailLabels are modules for creating PostScript files of mailing address labels.
Flexible enough to tackle other printing tasks, basically anything requiring a set fields be printed on a regular grid. Also creates PostScript(tm) code for calibrating and testing mailing label printing.
The module has three distinct output modes. In my experience, printing mailing labels is a matter of tweaking parameters to get them all to fit properly on the page. This module is designed with this in mind.
The first output is the calibration sheet. This is a pair of annotated axes, either in inches or centimeters, centered on the page and covering the whole page in X and Y directions. The intent is for you to output this page first, and simply read off the relevant page dimensions directly.
The second output is the label test. This output is a series of boxes drawn on the page, meant to outline the edges of all the mailing labels. Take this sheet and line it up with a sheet of labels to see if they actually match perfectly. If not, tweak the parameters until they do. Note that sometimes you will get a message at the bottom of the sheet saying ``Bottom gap too large, last row cannot be printed.
This means that the printable area of your printer is too small to utilize the last row of labels. I have this problem. But I handle it for you. Note also the arrows on the test sheet. As you hold the test sheet over a sheet of labels, hold it up to the light and slide the test sheet so that the boxes match the edges of the labels. If you slide in the arrow direction, that is a positive adjustment.
The other direction is negative. If the edges of some boxes come out dashed, that means that the non-printing border cuts off the end of the label, so I will adjust the printing area appropriately. Dont try to line up the dashed lines with label edges - it wont work. Just line up the solid lines.
The third output is the labels themselves. By default, I have set up a US-centric address definition :
firstname, lastname, street address, city, state, zipcode
But with version 2.0, you can now create your own definition. You can define new fields, and you can define how those fields land on a label. You can also control the fonts on a per-field basis. Not the size, yet - later pilgrim.
Parameters you can set :
Paper size, orientation, borders on the printable area (many printers will not print right up to the edge of the paper), where the labels live on the page and how big they are, overall x-y shift of page, whether or not to print PostNET barcode, font, fontsize, units (english or metric), which Avery(tm) product code to use, and where the first label starts.
This last needs explanation. If you have a partially used sheet of labels, you might want to use it up. So you count the missing labels, starting at the upper left, and counting across, and then down. For example, if I have 3 columns of labels, label five is the second label in the second row.
If you have an Avery(tm) product that I havent defined, send me the specs and Ill add it.
Also, if there is another brand of labels that you use, send me the relevant data and Ill add that as well. I suspect that there must be some other vendor in Europe, but I dont know who that would be.
When setting up the addresses, I check to see if they will fit on the label. If not, I try to shorten them semi-intelligently until they fit. This part could use quite a bit more work, if done right it probably merits a module all its own.
Briefly, for the name line, I start trimming the ends off the first name, and leave the last name alone.
For the street, I look for things like Road or Avenue and nuke those first, then I trim the street name from the right.
Enhancements:
- Parentheses are now escaped in the generated PostScript code.

gdcalc project is a financial, statistics, scientific and programmers calculator for Unix and Linux with both RPN and algebraic modes.
The GUI was written with glade and uses the Gnome/Gtk+ toolkit - so it may well be compatible with themes and other whiz-bang features of those systems.
gdcalc has both Algebraic notation (ie. conventional, TI or Casio style) and Reverse Polish Notation (RPN or Hewlett-Packard style). If youve not heard of RPN before, you are probably familiar with algebraic calculators.
Very briefly, while simpler and more natural to use, RPN calculators need some study eg. they have an Enter key instead of the equals key.
Enhancements:
- change register label width X Y Z T L

The P65 assemblers are assemblers for the 6502 microprocessor (such as is used in the Commodore 64, Apple II, and Nintendo Entertainment System).
They are designed to be able to support a wide variety of output formats, both to support multiple target platforms and to produce code for emulators.
The eventual goal of P65 is to be as expressive as the more powerful assemblers of the late 80s, such as DASM. Its not there yet, but its getting there.
Main features:
- Highly portable - All versions of P65 are written in portable scripting languages. The original releases were done in Perl. While P65-Perl 1.1 is stable and reasonably powerful, it lacks some major features, such as modules and macros. P65-Ophis, the Python port, will run on slightly fewer architectures, but will still run on all current major systems.
- Flexible output format - P65 allows for very flexible control over data and assemble points. Output file formats are completely independent of the final memory maps.
- Multiple file support - libraries may be kept as seperate files and included seperately, facilitating code reuse.
- Temporary label support - source may contain "anonymous labels" that help decrease namespace pollution. P65-Ophis also supports named temporary labels that only exist within a well-defined scope.
- Assemble-time expressions - P65-Ophis supports High-byte/low-byte computations along with bitmasking and traditional arithmetic operations in code and data statements. Access to the current PC is also supported. P65-Perls expressions are more limited but are generally sufficient.
- Symbol table management - Allows for creating labels and data constants outside of the code, and for allocating RAM symbolically. This includes full support for segments.
- Optimal instruction selection - Compresses as many instructions as possible into zero page format. If this compression permits other instructions to become zero page instructions, it will compress those as well.

Object::Declare is a Perl module for declarative object constructor.

SYNOPSIS

use Object::Declare [MyApp::Column, MyApp::Param];

my %objects = declare {

param foo =>
!is global,
is immutable,
valid_values are qw( more values );

column bar =>
field1 is value,
field2 is some_other_value;

};

print $objects{foo}; # a MyApp::Param object
print $objects{bar}; # a MyApp::Column object

This module exports one function, declare, for building named objects with a declarative syntax, similar to how Jifty::DBI::Schema defines its columns.

In list context, declare returns a list of name/object pairs in the order of declaration (allowing duplicates), suitable for putting into a hash. In scalar context, declare returns a hash reference.
Using a flexible import interface, one can change exported helper functions names (declarator), words to link labels and values together (copula), and the table of named classes to declare (mapping):

use Object::Declare
declarator => [declare], # list of declarators
copula => { # list of words, or a map
is => , # from copula to prefixes for
are => , # labels built with that copula
}
aliases => { # list of label aliases:
more => less, # turns "is more" into "is less"
# and "more is 1" into "less is 1"
},
mapping => {
column => MyApp::Column, # class name to call ->new to
param => sub { # arbitrary coderef also works
bless(@_, MyApp::Param);
},
};

After the declarator block finishes execution, all helper functions are removed from the package. Same-named functions (such as &is and &are) that existed before the declarators execution are restored correctly.

Clutter is a simple GL-based canvas library.

SYNOPSIS

use Clutter qw( :init );

# create the main stage
my $stage = Clutter::Stage->get_default();
$stage->set_color(Clutter::Color->parse(DarkSlateGray));
$stage->signal_connect(key-press-event => sub { Clutter->main_quit() });
$stage->set_size(800, 600);

# add an actor and place it right in the middle
my $label = Clutter::Label->new("Sans 30", "Hello, Clutter!");
$label->set_color(Clutter::Color->new(0xff, 0xcc, 0xcc, 0xdd));
$label->set_position(($stage->get_width() - $label->get_width()) / 2,
($stage->get_height() - $label->get_height()) / 2);
$stage->add($label);

$stage->show_all();

Clutter->main();

0;

Clutter is a GObject based library for creating fast, visually rich graphical user interfaces. It is intended for creating single window heavily stylised applications such as media box uis, presentations or kiosk style programs in preference to regular desktop style applications.

Clutters underlying graphics rendering is OpenGL (version 1.2+) based. The clutter API is intended to be easy to use, attempting to hide many of the GL complexities. It targets mainly 2D based graphics and is definetly not intended to be a general interface for all OpenGL functionality.

As well as OpenGL Clutter depends on and uses Glib, Glib::Object, Gtk2::Pango, Gtk2::Gdk::Pixbuf and GStreamer.