Free libraries software for linux

jsPro is a set of libraries that extend the core Javascript classes and provide a number of new classes.

The aim is to provide a rich set of object-based functionality to the Javascript language.

SAgl is a portable small antialiased graphics library. It offers lines, circles, and bezier curves, as well as thick lines and fills.

It can be used on top of SDL or with X or any other graphics system.

Easy Game Library is library of C++ classes designed to make game programming easier. Now it consists only of easy_sprite library which consists of classes for using sprites.

It should compile on different platforms because it uses SDL library as backend.

Installation:

To install run such sequence of commands:

make - Compiles library and tests

make install - Installs library and tests

Software Render Library is an Open Source software implementation of a polygon-based renderer (like your graphics card).
Main features:
- Transform vertices (from world to screen coordinates)
- Lighting
- Apply fog
- Rasterization of points, lines and triangles
- Texturation
- Z-Buffers
- Alpha blending
- Output to several pixel formats
Installation:
1. `cd to the directory containing the packages source code and type `./configure to configure the package for your system. If youre using `csh on an old version of System V, you might need to type `sh ./configure instead to prevent `csh from trying to execute
`configure itself.
If youre using GNU `make or any other `make program that supports the `VPATH variable, you should instead create a new directory, `cd to it and type `../srlib-src/configure.
This way you can keep the source directory clean and have your sources in a directory which is not modifyable by normal users.
Running `configure takes awhile. While running, it prints some messages telling which features it is checking for.
2. Type `make to compile the package.
3. Type `make install to install the libraries, headers and documentation. At the moment, only static libraries are built; support for shared libraries will be provided soon.
4. You can remove the library binaries and object files from the build directory by typing `make clean. To also remove the files that `configure created (so you can compile the package for a different kind of computer), type `make distclean.
There is also a `make maintainer-clean target, but that is intended mainly for the packages developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution.
Version restrictions:
- Read or write files and file formats, like png or jpeg. Software Render Library expects pixel data in a suitable format in a memory buffer.
- Read and process file formats describing a scene. Software Render Library only takes simple commands like "render this list of triangles" or "apply this certain light".
- Tesselation, i.e. dividing more abstract elements like cubes or spheres into lines and triangles.

The CentralNic Unicode Library provides some PHP classes for maniuplating Unicode data. These classes are general purpose but are intended for use when working with Internationalised Domain Names (IDNs).

Existing support for Unicode and multi-byte strings in PHP is not great, requiring either an extension that is not compiled into PHP by default, or one of a number of third-party libraries, most of which are not currently maintained (for example, the
I18N_UnicodeString class in PEAR was last updated in August 2004).

There is a Unicode extension under development, but it isnt public yet, and again requires a third party library to do the heavy lifting, so probably wont be enabled in a default PHP build.

Using the CentralNic Unicode Library is as simple as downloading the current release, and including the main Unicode.php file from your scripts. You then get instant access to the two Unicode_String and Unicode_Character classes.

The CentralNic Unicode Library is released under the GNU Library General Public License, version 2.0. This is not the "Lesser" GPL (version 2.1 and higher), which is more restrictive.

The use of the Library GPL means that you can use the code in your own proprietary software. While you are not obliged to pass back any changes you make to the code, we would greatly appreciate it if you did.

The GTK ADI Library is a GTK widget library that implements an ADI widget framework.

GTK ADI Library is an Advanced Document Interface: yet another approach to the MDI - Multi Document Interface.

WMApp DockApp Library is a C++ based library for writing WindowMaker-style dockapps. To write a dockapp, it is generally necessary to perform some magic Xlib incantations, supply a clipping mask, and set up X event checking.
Like larger graphics libraries such as GTK+ and Qt, WMApp automates this process by providing the classes and functions necessary for widget creation and callbacks.
The library provides numerous widgets, all with the traditional dockapp appearance. Many common dockapps could already be rewritten to use this library.
WMApp widgets available (most shown above) include:
- WMText, a text widget with three available font sizes (two are shown).
- WMLED, for creating the cutesy blinkenlights beloved by authors of PPP/Ethernet status dockapps.
- WMHistory, for showing the history of some quantity.
- WMMeterBar, for showing the quantitys instantaneous value. Available in three different styles.
- WMSlider, a subclass of WMMeterBar. This class lets you change a value by clicking or scrolling the mouse wheel over the widget.
- WMImage (not shown), a box with the capability to display a pixmap.
- WMButton. Buttons may have one or more callback functions attached.
- Or, inherit from WMCallback in order to give any other widget the ability to run callback functions.
- WMCanvas, a subclass of WMImage that lets you draw directly onto the dockapp.
- WMEllipse; inherit from this widget to create rounded buttons, images, etc.
- WMFrame. These container widgets may be nested to create the desired layout.
- WMWindow (one instance for each possible state of the dockapp). These contain all the other widgets for that state. WMWindows may have callback functions attached that execute every so often. These could be used, for instance, to update a clock or progress bar, or to "time out" an Internet connection.
Enhancements:
- Several fixes were made so that WMApp will compile with modern, stricter C++ compilers.
- Two new, very small fonts are now available.
- There are also new set/getuserdata() members of the WMApp and WMWidget classes that can be used to store arbitrary data to be used within callback functions.

DM1 Thread Library is part of the DM1 project. This library was born out of my need to have a portable C++ Thread library that would be simple to use, and would provide all the necessary Threads functionality I required for the DM1 project.
Initially, this library was in C, but when I decided to re-write DM1 in C++, I ported the library to C++. During the port, I enhanced the functionality of the Threads library.
The DM1 Threads library aims to be small. It does not try to provide a comprehensive set of functionality, but only what is absolutely essential for a project like DM1. I had the simplicity of the Java Threads package in mind when creating this library.
The constructs provided by the DM1 Thread library are:
- Thread objects that represent Operating System threads.
- A Mutex is provided as a mechanism for Mutual Exclusion . Mutexes are used to ensure that a piece of code is executed by only one thread at any point in time.
- Events are provided as low-level mechanisms for thread synchronisation. Events can be waited for, and signalled to.
- A higher level object, that combines the functionality of an Event and a Mutex, is provided. This is the Monitor object. A Monitor can be locked exclusively, just like a Mutex, but it can also be made the object of a Wait operation. The signalling mechanism supports notification of one or more waiting threads.
- To enable more efficient locking when both shared and exclusive access to data is required, Latches are provided.
- Apart from the Thread synchronisation primitives described above, the library also provides a ThreadPool for the situation when it is inefficient to create a thread exclusively for a particular task, and it is desirable to share a pool of threads for executing multiple tasks.
Design Principles
The DM1 Threads library was designed with the following principles in mind:
1. Implement the bare minimum that is required. This Threads library does not aim to be a comprehensive threads package.
2. Avoid complex algorithms. If a particular construct is hard to implement correctly on all platforms, avoid it.
3. Document the library.
4. Avoid low level code, such as assembler code to implement Spin locks. Rely on the libraries provided by the Operating System.
5. Avoid holding Mutexes beyond function calls. A DM1 Thread library function will not hold any Mutex locks when it returns.
6. Avoid using clever C++ techniques wherever possible. (Unfortunately, some cleverness is required to implement the Thread class correctly).
7. Avoid dependency on external libraries. The DM1 library only requires the standard C library, apart from native Threads functionality.
8. Always report an error as soon as it is discovered.
9. Insert debug messages that can be switched on at run-time.
10. Do not throw exceptions from destructors because these might be executing as a result of an uncaught exception.
11. Never let an error go unreported.