Free binding software for linux

octave-g2 bindings is an Octave interface to G2 library.

INSTALL:

1: ./autogen.sh
2: ./configure
3: make
4: make install
#test the package by
5: cd ./examples && ./simple_x11.m #you must see a 45degree line on X11 window.

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

The amaroK bindings for Python is a fairly complete amaroK remote control class. It is extremely useful for amaroK scripts and other applications. Basically, you can remote control amaroK by calling methods from an amaroKProxy instance.

In addition, it implements the Observer/Observable pattern so you can deal with events in an object-oriented, loosely coupled fashion. Even better, you can call an amaroKProxy instances collection.getSong(filename) method to get a Song object, with track, artist, album name, and elegant "Artist - Track name" strings.

Nearly all DCOP functions for communication with amaroK are implemented.

It will use KDE bindings DCOP module if available, otherwise it will default to the command-line DCOP dcop command, through python-commandsplus. If using KDE bindings, a slave process is spawned, and IPC is used to marshal and unmarshal function calls, so as to not contaminate your applications sys.modules with KDEs Python modules. This all happens automatically in the background.

To use it, you import the module in your script and instantiate an amaroKProxy instance, then call your instances startMonitoring() method, which will start reading from standard input, monitoring for amaroKs events. You can then sleep(1) until your instances .isAlive() method returns False (which means amaroK is now gone.

amaroKProxy is an Observable class, and so are its members:

- player
- contextBrowser

This means that you can implement Observer objects or Threads in your amaroK script, and have them be notified of amaroK events, instead of having to read standard input and act accordingly (plus error-prone exceptional condition handling).

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.

ypbind-mt is a multi-threaded implementation of a NIS binding daemon. ypbind-mt compiles and works on Linux with glibx 2.x (libc6).
It should work on every System with POSIX threads and glibc 2.x. ypbind-mt works under Linux with libc5 and linuxthreads 0.7.1, but this C library isnt really thread safe and shouldnt be used with threads.
Main features:
- Supports bindings to multiple domains.
- Supports /var/yp/binding/* file for Linux libc 4/5 and glibc 2.x.
- Supports a list of known secure NIS server (/etc/yp.conf)
- Binds to the server which answered as first if the old one is down.
- Check all 15 minuts, if the current server is really the fastest.
Enhancements:
- ypbind has now DBUS support to watch network status messages from NetworkManager (if NetworkManager is used).

RenderMan is a RenderMan binding as a Perl 5.6 module.

SYNOPSIS

use RenderMan;

This RenderMan module implements a Perl 5.6 binding for the BMRT client library (libribout). It fully supports the client library. Therefore, this module has the following limitations: Error Handling callbacks are not implemented, Filter function callbacks are not implemented, and the TransformPoints function does nothing. Also, Blobby is not yet supported by BMRT 2.5.0.8.

The full RenderMan specification is way beyond the scope of this man page. Please refer to the documents below for more information about RenderMan. The Perl binding is identical to the C binding except a few minor points: All "parameterlist"s are passed as a reference to a hash (i.e. %params).

Anywhere that a functions arguments can be terminated by RI_NULL, you can simply choose to not include that RI_NULL argument, which is incredibly nice.
All array, matrix, and basis types are single-dimension arrays of doubles in this Perl binding. The order for 2-dimension types is first-row followed by second-row, etc.

You will typically want to run your RenderMan Perl script and pipe the results into any RenderMan-compliant renderer, such as "rgl", "rendribv", or "rendrib", which all come with the excellent BMRT backage by Larry Gritz.

If using the WinNT version of BMRT, you can specify a filename, "rgl" or "rendrib" as the argument to Begin(); and the output will be sent to a file or automatically piped to "rgl" or "rendrib" since the piping mechanism (and general functionality) of WinNTs command line parser is, uh, limited.

Ruby-BDD is a BDD Binding for Ruby.
BDDs [bry86,and97] (or more precisely ROBDDs) are efficient data structures for representing boolean formula. They are widely used in formal verification, in particular symbolic model-checking. The idea of symbolic model-checking is to represent sets of states transition relations as formula (and to compute the fix-point of the set of all reachable states for reachability analysis).
Buddy is a BDD library written in C with an API both in C and C++. It is developer friendly with a simple interface. It supports all standard BDD operations, variable ordering, printing, has automated garbage collection, and is compilable on Unix and Windows platforms.
Ruby, despite being a scripting language, is a powerful and clean object-oriented language that is very easy to learn and use. In particular it is well-suited for quick prototyping and education purposes. Ruby-BDD is a binding for Ruby based on Buddy that provides BDD classes to create and manipulate BDDs in Ruby.
Enhancements:
- This release adds support for bit vectors and finite domains.
- Most of the Buddy library is now available through a Ruby style API.

PyORBit is a Python binding for the ORBit2 CORBA ORB. It was developped to suit the needs of the bonobo bindings in GNOME-Python, but is usable for other purposes as well. PyORBit aims to follow the standard Python language mapping for CORBA.

It can generate stubs at runtime from typelibs, IDL files, or by introspecting remote objects using ORBit2s IModule typelib capabilities.