Free compare fonts software for linux

Ctcompares project purpose is to allow you to compare several sets of C code trees on a token basis, rather than on a line by line basis. The programs help to identify similarities between snippets of code in both trees.
Enhancements:
- The comparison method has been completely rewritten.
- A database is now used to hold 16-token "tuples" as keys; the result attached to each key is the list of source files which have that tuple.
- Tuples with multiple files from different source trees indicate potential code similarity.
- These are then fully tested to find actual code similarity.

Choosefont is a simple but extremely efficient tool for quickly finding the required font in a large amount of fonts.

It was created due to the lack of decent font selection widgets in many application.

Apart from finding a font, Choosfont can also creat css, html and other code for the selected font, this code is automatically copied to the X clipboard.

List::Compare is a Perl module to compare elements of two or more lists.

SYNOPSIS

The bare essentials:

@Llist = qw(abel abel baker camera delta edward fargo golfer);
@Rlist = qw(baker camera delta delta edward fargo golfer hilton);

$lc = List::Compare->new(@Llist, @Rlist);

@intersection = $lc->get_intersection;
@union = $lc->get_union;

General Comments

List::Compare is an object-oriented implementation of very common Perl code (see "History, References and Development" below) used to determine interesting relationships between two or more lists at a time. A List::Compare object is created and automatically computes the values needed to supply List::Compare methods with appropriate results. In the current implementation List::Compare methods will return new lists containing the items found in any designated list alone (unique), any list other than a designated list (complement), the intersection and union of all lists and so forth. List::Compare also has (a) methods to return Boolean values indicating whether one list is a subset of another and whether any two lists are equivalent to each other (b) methods to pretty-print very simple charts displaying the subset and equivalence relationships among lists.

Except for List::Compares get_bag() method, multiple instances of an element in a given list count only once with respect to computing the intersection, union, etc. of the two lists. In particular, List::Compare considers two lists as equivalent if each element of the first list can be found in the second list and vice versa. Equivalence in this usage takes no note of the frequency with which elements occur in either list or their order within the lists. List::Compare asks the question: Did I see this item in this list at all? Only when you use List::Compare::get_bag() to compute a bag holding the two lists do you ask the question: How many times did this item occur in this list?

SYNOPSIS

use Array::Compare;

my $comp1 = Array::Compare->new;
$comp->Sep(|);
$comp->Skip({3 => 1, 4 => 1});
$comp->WhiteSpace(0);
$comp->Case(1);

my $comp2 = Array::Compare->new(Sep => |,
WhiteSpace => 0,
Case => 1,
Skip => {3 => 1, 4 => 1});

my @arr1 = 0 .. 10;
my @arr2 = 0 .. 10;

$comp1->compare(@arr1, @arr2);
$comp2->compare(@arr1, @arr2);

If you have two arrays and you want to know if they are the same or different, then Array::Compare will be useful to you.
All comparisons are carried out via a comparator object. In the simplest usage, you can create and use a comparator object like this:

my @arr1 = 0 .. 10;
my @arr2 = 0 .. 10;

my $comp = Array::Compare->new;

if ($comp->compare(@arr1, @arr2)) {
print "Arrays are the samen";
} else {
print "Arrays are differentn";
}

Notice that you pass references to the two arrays to the comparison method.

Internally the comparator compares the two arrays by using join to turn both arrays into strings and comparing the strings using eq. In the joined strings, the elements of the original arrays are separated with the ^G character. This can cause problems if your array data contains ^G characters as it is possible that two different arrays can be converted to the same string.

To avoid this, it is possible to override the default separator character, either by passing and alternative to the new function

my $comp = Array::Compare->new(Sep => |);

or by changing the seperator for an existing comparator object

$comp->Sep(|);

In general you should choose a separator character that wont appear in your data.

You can also control whether or not whitespace within the elements of the arrays should be considered significant when making the comparison. The default is that all whitespace is significant. The alternative is for all consecutive white space characters to be converted to a single space for the pruposes of the comparison. Again, this can be turned on when creating a comparator object:

my $comp = Array::Compare->new(WhiteSpace => 0);

or by altering an existing object:

$comp->WhiteSpace(0);

You can also control whether or not the case of the data is significant in the comparison. The default is that the case of data is taken into account. This can be changed in the standard ways when creating a new comparator object:

my $comp = Array::Compare->new(Case => 0);

or by altering an existing object:

$comp->Case(0);

In addition to the simple comparison described above (which returns true if the arrays are the same and false if theyre different) there is also a full comparison which returns a list containing the indexes of elements which differ between the two arrays. If the arrays are the same it returns an empty list. In scalar context the full comparison returns the length of this list (i.e. the number of elements that differ). You can access the full comparision in two ways. Firstly, there is a DefFull attribute. If this is true then a full comparison if carried out whenever the compare method is called.

my $comp = Array::Compare->new(DefFull => 1);
$comp->compare(@arr1, @arr2); # Full comparison

$comp->DefFull(0);
$comp->compare(@arr1, @arr2); # Simple comparison

$comp->DefFull(1);
$comp->compare(@arr1, @arr2); # Full comparison again

Secondly, you can access the full comparison method directly

$comp->full_compare(@arr1, @arr2);

For symmetry, there is also a direct method to use to call the simple comparison.

$comp->simple_compare(@arr1, @arr2);

The final complication is the ability to skip elements in the comparison. If you know that two arrays will always differ in a particular element but want to compare the arrays ignoring this element, you can do it with Array::Compare without taking array slices. To do this, a comparator object has an optional attribute called Skip which is a reference to a hash. The keys in this hash are the indexes of the array elements and the values should be any true value for elements that should be skipped.

For example, if you want to compare two arrays, ignoring the values in elements two and four, you can do something like this:

my %skip = (2 => 1, 4 => 1);
my @a = (0, 1, 2, 3, 4, 5);
my @b = (0, 1, X, 3, X, 5);

my $comp = Array::Compare->new(Skip => %skip);

$comp->compare(@a, @b);

This should return true, as we are explicitly ignoring the columns which differ.

Of course, having created a comparator object with no skip hash, it is possible to add one later:

$comp->Skip({1 => 1, 2 => 1});

or:

my %skip = (1 => 1, 2 => 2);
$comp->Skip(%skip);

To reset the comparator so that no longer skips elements, set the skip hash to an empty hash.

$comp->Skip({});

You can also check to see if one array is a permutation of another, i.e. they contain the same elements but in a different order.

if ($comp->perm(@a, @b) {
print "Arrays are permsn";
else {
print "Nope. Arrays are completely differentn";
}

In this case the values of WhiteSpace and Case are still used, but Skip is ignored for, hopefully, obvious reasons.

Struct::Compare is a recursive diff for perl structures.

SYNOPSIS

use Struct::Compare;
my $is_different = compare($ref1, $ref2);

Compares two values of any type and structure and returns true if they are the same. It does a deep comparison of the structures, so a hash of a hash of a whatever will be compared correctly.

This is especially useful for writing unit tests for your modules!

PUBLIC FUNCTIONS

$bool = compare($var1, $var2)

Recursively compares $var1 to $var2, returning false if either structure is different than the other at any point. If both are undefined, it returns true as well, because that is considered equal.

Gentium is a typeface family designed to enable the diverse ethnic groups around the world who use the Latin script to produce readable, high-quality publications.

Gentium fonts project supports a wide range of Latin-based alphabets and includes glyphs that correspond to all the Latin ranges of Unicode.

The design is intended to be highly readable, reasonably compact, and visually attractive. The additional "extended" Latin letters are designed to naturally harmonize with the traditional 26 ones. Diacritics are treated with careful thought and attention to their use.

Gentium also supports both ancient and modern Greek, including a number of alternate forms. These fonts were originally the product of two years of research and study by the designer at the University of Reading, England, as part of an MA program in Typeface Design.

SIL International has now embraced the Gentium project, and plans to continue development. Expansion of the glyph set to include more extended Latin glyphs, archaic Greek symbols, and full Cyrillic script support is the next step. Work on this has already begun, but the results will not be available for a few months. Addition of bold and bold italic faces will follow.

Gentium is freely available and may be used by anyone at no cost. It is now released under the SIL Open Font License, a free and open source license that permits modification and redistribution.

Our hope is that it will stimulate literature production and elevate extended Latin alphabets to greater parity with the basic Latin alphabet. We also hope it will encourage other type designers to appreciate and support those fascinating and beautiful extra letters.

FOP (Formatting Objects Processor) is the worlds first print formatter driven by XSL formatting objects (XSL-FO) and the worlds first output independent formatter.
Apache FOP project is a Java application that reads a formatting object (FO) tree and renders the resulting pages to a specified output. Output formats currently supported include PDF, PCL, PS, SVG, XML (area tree representation), Print, AWT, MIF and TXT. The primary output target is PDF.
Enhancements:
- This release is the successor of version 0.20.5, FOPs production grade version.
- It contains the new API first introduced in 0.92 beta; support for Open Type fonts; support for the rgb-icc() function and a proprietary cmyk() function; copy/paste from PDF content using embedded TrueType fonts; support for PDF/A-1b and PDF/X-3:2003; improved Java2D, print, and bitmap renderers; and automatic support for all Java2D fonts for TIFF, PNG, print, AWT rendering.

VSOFont is a small library used to draw very simple and fast user definable 2D vector fonts. At some point in time, when working with handheld devices, the font functions GLUT offered proved to be too massive. so i decided to write a very simple 3D vector text system using OpenGL myself. The application is coded in ANSI C.
Enhancements:
- added vsofont_read_font_from_memory().
- changed vsofont_read_font() to vsofont_read_font_from_file().
- example shows now how to draw a bolded string.
- VSOFONT header file should now work in C++ projects.
- small optimizations here and there.