Free c bindings software for linux

Glib Binding Properties library adds an implementation of binding properties to GLib / GTK+ library (it also includes Ada 95 for GtkAda GTK bindings, GtkAda was made by ACT corp.)

Binding properties is automatic synchronizing values of several properties to keep their values correspondingly to each other, so that when a property changes properties bound with it automatically change accordingly. Also bindings with value transformation functions are supported.

Binding properties much reduces development time of desktop applications and increases reliability as frees you from time consuming and error-prone writing callback handlers of property changes. (Probably wrong property change handlers is the most often cause of errors in GUI applications!)

Current version 0.9.1 is an alpha version. Please test it.

GStreamer Python Bindings project provide Python bindings for the GStreamer project. These bindings provide access to almost all of the GStreamer C API through an object oriented Python API.
GStreamer is a library that allows the construction of graphs of media-handling components, ranging from simple Ogg/Vorbis playback to complex audio (mixing) and video (non-linear editing) processing.
Applications can take advantage of advances in codec and filter technology transparently. Developers can add new codecs and filters by writing a simple plugin with a clean, generic interface.
GStreamer is released under the LGPL.
Main features:
Multiplatform
- GStreamer has been ported to a wide range of operating systems, processors and compilers. This include but are not limited to Linux on i86,PPC, ARM using GCC. Solaris on x86 and SPARC using both GCC and Forte, MacOSX, Microsoft Windows using MS Visual Developer and IBM OS/400.
Comprehensive Core Library
- Graph-based structure allows arbitrary pipeline construction
- Based on GLib 2.0 object model for object-oriented design and inheritance
- Small core library of less than 150KB, about 10 K lines of code
- Pluggable scheduling system capable of dealing with most pipeline structures
- Multi-threaded pipelines are trivial and transparent to construct
- Clean and simple API for both plugin and application developers
- Extremely lightweight data passing means very high performance/low latency
- Complete debugging system for both core and plugin/app developers
- Clocking to ensure global inter-stream synchronization
Intelligent Plugin Architecture
- Dynamically loaded plugins provide elements and media types, demand-loaded via an XML registry, similar to ld.so.cache
- Element interface handles all known types of sources, filters, sinks
- Capabilities system allows verification of element compatibility using MIME types and media-specific properties
- Autoplugging uses capabilities system to complete complex paths automatically
- Pipelines can be saved to XML and loaded back to working state
- Resource friendly plugins dont waste RAM
Extensive Development Tools
- Graphical editor allows pipelines to be built quickly, run, and saved as XML
- gst-launch command-line tool enables even quicker prototyping and testing, similar to ecasound
- All tools written as libraries to allow easy reuse
- A lot of documentation, including partially completed manual and plugin writers guide
- Large selection of test programs and example code
- Access to GStreamer API with various programming language

Tk::bindtags can determine which bindings apply to a window, and order of evaluation.

SYNOPSIS

$widget->bindtags([tagList]); @tags = $widget->bindtags;

When a binding is created with the bind command, it is associated either with a particular window such as $widget, a class name such as Tk::Button, the keyword all, or any other string. All of these forms are called binding tags. Each window has a list of binding tags that determine how events are processed for the window. When an event occurs in a window, it is applied to each of the windows tags in order: for each tag, the most specific binding that matches the given tag and event is executed. See the Tk::bind documentation for more information on the matching process.

By default, each window has four binding tags consisting of the the windows class name, name of the window, the name of the windows nearest toplevel ancestor, and all, in that order. Toplevel windows have only three tags by default, since the toplevel name is the same as that of the window.

Note that this order is different from order used by Tcl/Tk. Tcl/Tk has the window ahead of the class name in the binding order. This is because Tcl is procedural rather than object oriented and the normal way for Tcl/Tk applications to override class bindings is with an instance binding. However, with perl/Tk the normal way to override a class binding is to derive a class. The perl/Tk order causes instance bindings to execute after the class binding, and so instance bind callbacks can make use of state changes (e.g. changes to the selection) than the class bindings have made.

The bindtags command allows the binding tags for a window to be read and modified.

If $widget->bindtags is invoked without an argument, then the current set of binding tags for $widget is returned as a list. If the tagList argument is specified to bindtags, then it must be a reference to and array; the tags for $widget are changed to the elements of the array. (A reference to an anonymous array can be created by enclosin the elements in [ ].) The elements of tagList may be arbitrary strings or widget objects, if no window exists for an object at the time an event is processed, then the tag is ignored for that event. The order of the elements in tagList determines the order in which binding callbacks are executed in response to events. For example, the command

$b->bindtags([$b,ref($b),$b->toplevel,all])

applies the Tcl/Tk binding order which binding callbacks will be evaluated for a button (say) $b so that $bs instance bindings are invoked first, following by bindings for $bs class, followed by bindings for $bs toplevel, followed by all bindings.

If tagList is an empty list i.e. [], then the binding tags for $widget are returned to the perl/Tk default state described above.

The bindtags command may be used to introduce arbitrary additional binding tags for a window, or to remove standard tags. For example, the command

$b->bindtags([TrickyButton,$b->toplevel,all])

replaces the (say) Tk::Button tag for $b with TrickyButton. This means that the default widget bindings for buttons, which are associated with the Tk::Button tag, will no longer apply to $b, but any bindings associated with TrickyButton (perhaps some new button behavior) will apply.

Inline::C is a Perl module that can Write Perl Subroutines in C.

Inline::C is a module that allows you to write Perl subroutines in C. Since version 0.30 the Inline module supports multiple programming languages and each language has its own support module. This document describes how to use Inline with the C programming language. It also goes a bit into Perl C internals.

If you want to start working with programming examples right away, check out Inline::C-Cookbook. For more information on Inline in general, see Inline.

Usage

You never actually use Inline::C directly. It is just a support module for using Inline.pm with C. So the usage is always:
use Inline C => ...;
or
bind Inline C => ...;

Function Definitions

The Inline grammar for C recognizes certain function definitions (or signatures) in your C code. If a signature is recognized by Inline, then it will be available in Perl-space. That is, Inline will generate the "glue" necessary to call that function as if it were a Perl subroutine. If the signature is not recognized, Inline will simply ignore it, with no complaints. It will not be available from Perl-space, although it will be available from C-space.

Inline looks for ANSI/prototype style function definitions. They must be of the form:

return-type function-name ( type-name-pairs ) { ... }

The most common types are: int, long, double, char*, and SV*. But you can use any type for which Inline can find a typemap. Inline uses the typemap file distributed with Perl as the default. You can specify more typemaps with the TYPEMAPS configuration option.

A return type of void may also be used. The following are examples of valid function definitions.

int Foo(double num, char* str) {
void Foo(double num, char* str) {
SV* Foo() {
void Foo(SV*, ...) {
long Foo(int i, int j, ...) {

The following definitions would not be recognized:

Foo(int i) { # no return type
int Foo(float f) { # no (default) typemap for float
int Foo(num, str) double num; char* str; {
void Foo(void) { # void only valid for return type

Notice that Inline only looks for function definitions, not function prototypes. Definitions are the syntax directly preceeding a function body. Also Inline does not scan external files, like headers. Only the code passed to Inline is used to create bindings; although other libraries can linked in, and called from C-space.

Libconfig is a simple library for parsing structured configuration files, like this one: test.cfg.

This file format is more compact and more readable than XML. And unlike XML, it is type-aware, so it is not necessary to do string parsing in application code.

libconfigduo library includes bindings for both the C and C++ languages.

SwigSword library is a branch of the SWORD bible software library with enhanced SWIG bindings. This software will periodically be merged with the SWORD trunk.
Example code for using the SharpSword API:
SharpSword.MarkupFilterMgr markup = new SharpSword.MarkupFilterMgr();
markup.Encoding(SharpSword.Sword.ENC_HTML);
markup.Markup(SharpSword.Sword.FMT_HTML);
SharpSword.SWMgr mgr = new SharpSword.SWMgr(null, null, true, markup);
int mgrcount = mgr.moduleCount();
for (int i = 0; i < mgr.moduleCount(); i++)
{
SharpSword.SWModule mod = mgr.getModuleAt(i);
mod.SetKey(new SharpSword.VerseKey("John 3:16"));
string text = mod.text();
//do something with mod
Enhancements:
- Support for functions which use stl maps was added.

RPM::Constants is a Perl module with groups of RPM-defined symbols.

SYNOPSIS

use RPM::Constants qw(:rpmerr :rpmtype);

This package is a collection of the constants defined by rpm itself that may be of use to those developing with the RPM Perl bindings.