Free c tablelayout software for linux

C++ Portable Components project are a collection of open-source class libraries that simplify and accelerate the development of network-centric, portable applications in C++.
The libraries integrate perfectly with the C++ Standard Library and fill many of the functional gaps left open by it.
Their modular and efficient design and implementation makes the C++ Portable Components extremely well suited for embedded development, an area where the C++ programming language is becoming increasingly popular, due to its suitability for both low-level (device I/O, interrupt handlers, etc.) and high-level object-oriented development.
The C++ Portable Components help developers to focus on the unique core features of the product they are developing ? the features that will ultimately sell the product. By reusing the tried and tested components provided by the C++ Portable Components, developers do not need to waste valuable time and resources re-inventing the wheel.
C++ Portable Components Layers
The classes provided by the Applied Informatics C++ Portable Components provide support for:
- threads, thread synchronization and advanced abstractions for multithreaded programming
- streams and filesystem access
- shared libraries and class loading
- powerful logging and error reporting
- security
- network programming (TCP/IP sockets, HTTP, FTP, SMTP, etc.)
- XML parsing (SAX2 and DOM) and generation
- configuration file and options handling
- an embeddable, lightweight SQL database
Todays highly complex software systems often outlive the hardware platforms they have originally been built on. Applications based on the C++ Portable Components can be easily ported to a new platform, thus helping to save and increase the return on investments made in software.
Enhancements:
- This release contains major bugfixes and performance improvements in the HTTP classes.

GNU C library (glibc) is one of the most important components of GNU Hurd and most modern Linux distributions.

GNU C library is used by almost all C programs and provides the most essential program interface.

The history of Unix and various standards determine much of the interface of the C library. In general the GNU C library supports the ISO C and POSIX standards. We also try to support the features of popular Unix variants (including BSD and System V) when those do not conflict with the standards. Different compatibility modes (selectable when you compile an application) allow the peaceful coexistence of compatibility support for different varieties of Unix.

The GNU C library is primarily designed to be a portable and high performance C library.

It follows all relevant standards (ISO C 99, POSIX.1c, POSIX.1j, POSIX.1d, Unix98, Single Unix Specification). It is also internationalized and has one of the most complete internationalization interfaces known.

C Comic Collection project is a GTK application for downloading, cataloging, and viewing Web comics. It uses a MySQL database.
To compile this software, just type "make".
It requires development libraries for gtk, gtk_imlib, cURL, mysql and pthreads. If youre on Linux these should come with your distrobution; I dunno for other OS. If you only have the runtimes and are using a 386 derivative (Pentium et al) you can get a binary from http://c-comiccollect.sourceforge.net.
Compilation will produce a binary called "gtk-cc"; copy this to your /usr/bin (youll need root privileges, copy to your ~/bin (you wont) or just run it from where it is (./gtk-cc &).
You can populate the database by running the included "comiccollection.sql" against an empty database. (mysql -u < username > < dbname > < comiccollection.sql). It even includes some comics to get you started!
Enhancements:
- Minor improvements - only really relevant if you view KeenSpace comics.
- Fixed file non-deletion problem
- Fixed KeenSpace file download problem

ResourcePool is a C++ library which can be used to pool resources of every kind. One very interesting side effect is that it can also be used of abstraction layer by providing a unique API for different resources of similar resource types.
Most prominent example are SQL databases. The ResourcePool does currently include a convenient way to access MySQL and Oracle databases in the same way, so that changing for MySQL to Oracle or vice-versa does not need big code changes.
Enhancements:
- Corrected handling of NoFailoverExceptions. Previously it did just not work.
- Fixed a bug which could cause undefined behavior in MultiThreadedModel when a caller had to wait for resources (when the Max limit is reached).
- The argument validation of the bindout() and isnull() methods of SQLSelect(Row) commands has been corrected.
- Fixed a bug in the Cache class which caused an unreasonable exception in case an already cached value is put again.
- The isnull() method has been added to the Runtime selectable SQL driver (fatalmind::ResourceType::SQL).
- The NoFailoverExceptions thrown in the mysql driver do now include the correct message. The messages were lost due to a missing explicit constructor call to the virtual base class.
- The getFactory() method in ResourcePool is now public and returns a const reference.
- Implemented some rudimentary statistics. See ResourcePool.getStats() for details.
- Building improvement: -lrt is used (and not used) more correctly.
- The testing framework has been extended to optionally perform testing in multiple threads. The default behavior has not been changed (make check does not use multiple threads). However when running the test programs manually you can add "-m" as argument. Each "m" does add an additional thread for testing. However, the test programs itself need also to provide such test cases.
- The test cases (used with make check) do now use the complete library. This has the drawback that building must always be done in the top level directory before performing tests. However, the tests use the real library now (and not just a subset) so that the overall testing quality is a little improved.

Simple C++ ODBC Database API is designed to encapsulate the ODBC API functionality in an object oriented manner.
The API was created due to an absence of any other such API that was database independent. The database independence is achieved using the ODBC (Open DataBase Connectivity) API.
The API provides a Database object that can be used to create instances of Query objects. The Query objects are used to query a database and allow columns to be bound for the query.
The flowing column objects are currently available (as of Jan 2005): a boolean column, a long column and a string column. The string column makes use of the libstdc++ string class so you dont have to mess around with malloc.
The Database object also has some convenience member functions that allow queries that return a single integer or string to be executed without having to create a query object or bind columns.
The API has been tested to work with both MySql and PostGreSQL on a Debian Linux platform.
Enhancements:
- DoubleColumn, IntColumn, and BigintColumn were added.
- The LongColumn is deprecated.

GLT OpenGL C++ Toolkit 0.7 project contains classes and routines for programming interactive 3D graphics with OpenGL.
The aim of Glt is to augment the OpenGL API with convenient mechanisms for manipulating the OpenGL state machine.
Glt is a work in progress, and by no means covers the entire OpenGL specification. However, it already includes several useful classes and is designed so that additional classes can be added easily. In addition to Glt, the GlutMaster classes provide C++ wrappers for the GLUT API.
Main features:
- GltFrameBuffer
- Read and write from frame buffer
- Save to PPM, TGA, BMP or PNG image files
- GltFrameBufferRGB
- GltFrameBufferZ
- GltFrameBufferStencil
- GltColor
- RGBA Color
- Over 600 predefined colors
- Color interpolation and arithmetic
- GltTexture
- Read from PPM, TGA, BMP or PNG image files
- Automatic texture binding
- Support for compressed compiled textures
- Support for procedural textures
- GltFont
- GltFontAscii Bitmapped ASCII font. Ten fonts included.
- GltFontUnicode Bitmapped Unicode font. Includes English, Chinese, Japanese and Korean.
- Vector, Matrix, Plane and BoundingBox
- Vector math functions: dot and cross products and arithmetic
- Transformation matrices, inverse, transpose and determinant
- Plane equation evaluation, ray-plane intersection
- Full OpenGL integration
- Random Number Generation
- GltRandomLCG Park and Miller LCG generator
- GltRandomLFSRMix Linear Feedback Shift Register generator
- GltRandomDouble, GltRandomInteger with configurable range
- GltRandomSphere point-on-sphere generator
- GltRandomOrientation orientation frame generator
- GltLight OpenGL Light Source.
- GltLightModel OpenGL Lighting Model.
- GltMaterial OpenGL Material Settings.
- OpenGL Matrix Manipulation
- GltOrtho Orthographic Projection.
- GltTextOverlay Text-box overlay.
- GltViewport Viewport settings.
- GltShape Scenegraph node class
- Transformation matrix
- Predefined shapes: GlutSphere,GlutCube,GlutCylinder, etc...
- GltShapes container class

JThreads/C++ is a Java like threads for C++.

A unique and very useful product, JThreads/C++ is a portable thread abstraction library that mimics the thread classes and primitives found in Java™. Supported on Windows 95, NT and many flavors of Unix, JThreads/C++ simplifies the development of multi-threaded applications by encapsulating all platform-specific function calls inside a well-designed, easy-to-use class library.

How Does It Work?

Java’s support for multi-threaded programming is provided by the following constructs:

The classes java.lang.Thread and java.lang.ThreadGroup
The interface java.lang.Runnable
The synchronized keyword
The methods wait, notify and notifyAll in java.lang.Object

The Java classes java.lang.Thread and java.lang.ThreadGroup are directly translated into the C++ classes JTCThread and JTCThreadGroup. The only difference is that the JThreads/C++ classes have JTC as a prefix instead of the Java package java.lang. The Java interface java.lang.Runnable is implemented as the abstract C++ class JTCRunnable, which contains the pure virtual method run.

Support for the synchronized keyword is slightly more difficult, since it is not possible to add new keywords to C++. JThreads/C++ addresses this issue using two additional classes, JTCMonitor and JTCSynchronized, wich together form the replacement for the synchronized keyword. JTCMonitor also provides the methods wait, notify and notifyAll.