Free gobject introspection software for linux

pygobject archive contains bindings for the GObject, to be used in Python.

It is a fairly complete set of bindings, its already rather useful, and is usable to write moderately complex programs. (see the examples directory for some examples of the simpler programs you could write).

Neutrino is a GNOME based GUI for managing your Creative Nomad / DAP Jukeboxes.
Neutrino is a GNOME based GUI for managing your Creative Nomad / DAP Jukeboxes. Support for accessing jukeboxes from other applications is planned by utilizing DBUS.
Additionally the backend of Neutrino is fully separated from the GUI, and is implemented as a separate GObject for easy integration into other applications.
Main features:
- Author/Album cataloguing system
- Create/Delete/Edit playlists via drag and drop
- Multiple attached Jukeboxes can be switched between on the fly
- Playback support with repeat and shuffle features
- Edit track information held on the jukebox (artist, album, genre etc,)
- Regular expression based search mechanism for search by artist, album, year, genre, and title.
- Transfer wav / mp3 files to / from the jukebox
- Support for ID3 V1.x and basic ID3 V2 tags for setting track information on mp3s
- Track information can be obtained from the filename of uploaded files
- Supports uploading from an mpu file (local uris only)
- Drop files onto the main window to upload
- Display jukebox statistics
- Tasks requiring access to the jukebox are queued so you arent slowed down too much by the jukebox itself
- Playback does not block most operations

Moose::Cookbook::FAQ is a frequenty asked questions about Moose.

Is Moose "production ready"?

Yes and No. Currently I have one web application in production using Moose, and at $work we are re-writing our core offering to use Moose. Several other people on #moose either have sites in production which use Moose, or are in the process of deploying sites which use Moose.

The biggest barrier to widespread use of Moose in production right now is speed of development and speed of execution.

Since development is still happening, regular upgrades are a fact of life. This can be hairy in production, so if this makes you quake with fear, you might want to wait a few months.

Then comes speed of execution. Moose is actually pretty fast, and makes great effort to stay out of your way when you dont want it there. However, certain parts of Moose are slow, such as compile time setup, introspection and object construction (only because it uses introspection). See "Is Moose slow?" below for a deeper discussion on the subject.

Is Mooses API stable?

Yes and No. The external API, the one 90% of users will interact with, is very stable and any changes will be 100% backwards compatible. The introspection API is mostly stable, I still reserve the right to tweak that if needed, but I will do my absolute best to maintain backwards comptability here as well.

Is Moose slow?

Again, this one is tricky, so Yes and No.

First let me say that nothing in life is free, and that some Moose features do cost more than others. It is also the policy of Moose to only charge you for the features you use, and to do our absolute best to not place any extra burdens on the execution of your code for features you are not using.

Next, I will point out again that we are still in the "early adopter" phase, so speed it not that important yet. We are actually optimizing for "theoretical correctness" first, and we will optimize for speed later. It has been our experience that taking this approach allows for greater optimization capacity.

And lastly, I want to reassure the speed junkies out there that we are working on it.
We have the immutable classes in Class::MOP, but which are not yet integrated with Moose. These allow you to "close" a class and then for many of its more expensive methods to me memoized. Our tests indicated a performance comparable (and in some instances exceeding) that of hand-coded Perl.

We are also discussing and experimenting with Module::Compile, and the idea of compiling highly optimized .pmc files. And we have also mapped out some core methods as canidates for conversion to XS.

Glib::CodeGen is a code generation utilities for Glib-based bindings.

SYNOPSIS

# usually in Makefile.PL
use Glib::CodeGen;

# most common, use all defaults
Glib::CodeGen->parse_maps (myprefix);
Glib::CodeGen->write_boot;

# more exotic, change everything
Glib::CodeGen->parse_maps (foo,
input => foo.maps,
header => foo-autogen.h,
typemap => foo.typemap,
register => register-foo.xsh);
Glib::CodeGen->write_boot (filename => bootfoo.xsh,
glob => Foo*.xs,
ignore => ^(Foo|Foo::Bar)$);

# add a custom type handler (rarely necessary)
Glib::CodeGen->add_type_handler (FooType => ≥n_foo_stuff);
# (see the section EXTENDING TYPE SUPPORT for more info.)

This module packages some of the boilerplate code needed for performing code generation typically used by perl bindings for gobject-based libraries, using the Glib module as a base.

The default output filenames are in the subdirectory build, which usually will be present if you are using ExtUtils::Depends (as most Glib-based extensions probably should).

GTK-Doc is used to document C code. It is typically used to document the public API of libraries, such as the GTK+ and GNOME libraries, but it can also be used to document application code.

Note that GTK-Doc wasnt originally intended to be a general-purpose documentation tool, so it can be a bit awkward to setup and use. For a more polished general-purpose documentation tool you may want to look at Doxygen (http://www.doxygen.org/). However GTK-Doc has some special code to document the signals and properties of GTK+ widgets and GObject classes which other tools may not have.

GTK-Doc allows your documentation to be written in 2 ways:

a) Embedded inside the source code in specially-formatted comments.

or

b) Added to the template files which gtk-doc outputs after scanning all the header files and parsing the declarations.

From these source code comments and template files GTK-Doc generates a Docbook XML (or SGML) document, which is then transformed into HTML. The generated HTML documentation can be browsed in an ordinary web browser or by using the special Devhelp API browser (see http://developer.imendio.com/wiki/Devhelp).

Joeq is a virtual machine and compiler infrastructure designed to facilitate research in virtual machine technologies such as Just-In-Time and Ahead-Of-Time compilation, advanced garbage collection techniques, distributed computation, sophisticated scheduling algorithms, and advanced run time techniques.
Joeq is entirely implemented in Java, leading to reliability, portability, maintainability, and efficiency. It is also language-independent, so code from any supported language can be seamlessly compiled, linked, and executed -- all dynamically.
Each component of the virtual machine is written to be independent with a general but well-defined interface, making it easy to experiment with new ideas.
Joeq is released as open source software, and is being used as a framework by researchers on five continents on topics ranging from automatic distributed virtual machines to whole-program pointer analysis.
Joeq is a virtual machine and compiler infrastructure designed to be a platform for research in compilation and virtual machine technologies. We had three main goals in designing the system. First and foremost, we wanted the system to be flexible. We are interested in a variety of compiler and virtual machine research topics, and we wanted a system that would not be specific to researching a particular area.
For example, we have interest in both static and dynamic compilation techniques, and in both type-safe and unsafe languages. We wanted a system that would be as open and general as possible, without sacrificing usability or performance.
Second, we wanted the system to be easy to experiment with. As its primary focus is research, it should be straightforward to prototype new ideas in the framework. With this in mind, we tried to make the system as modular as possible, so that each component is easily replaceable. Learning from our experience with Jalapeno, another virtual machine written in Java, we decided to implement the entire system in Java.
This makes it easy to quickly implement and prototype new ideas, and features like garbage collection and exception tracebacks ease debugging and improve productivity. Java, being a dynamic language, is also a good consumer for many of our dynamic compilation techniques; the fact that our dynamic compiler can compile the code of the virtual machine itself means that it can dynamically optimize the virtual machine code with respect to the application that is running on it. Javas object-oriented nature also facilitates modularity of the design and implementation.
Third, we wanted the system to be useful to a wide audience. The fact that the system is written in Java means that much of the system can be used on any platform that has an implementation of a Java virtual machine. The fact that Joeq supports popular input languages like Java, C, C++, Fortran, and even x86 binary code increases the scope of input programs. We released the system on the SourceForge web site as open source under the Library GNU Public License.
It has been picked up by researchers on five continents for various purposes, among them: automatic extraction of component interfaces, static whole-program pointer analysis, context-sensitive call graph construction, automatic distributed computation, versioned type systems for operating systems, sophisticated profiling of applications, advanced dynamic compilation techniques, system checkpointing, anomaly detection, secure execution platforms and autonomous systems. In addition, Joeq is now used as the basis of the Advanced Compilation Techniques class taught at Stanford University.
Joeq supports two modes of operation: native execution and hosted execution. In native execution, the Joeq code runs directly on the hardware. It uses its own run-time routines, thread package, garbage collector, etc. In hosted execution, the Joeq code runs on top of another virtual machine. Operations to access objects are translated into calls into the reflection library of the host virtual machine.
The user code that executes is identical, and only a small amount of functionality involving unsafe operations is not available when running in hosted execution mode. Hosted execution is useful for debugging purposes and when the underlying machine architecture is not yet directly supported by Joeq. We also use hosted execution mode to bootstrap the system and perform checkpointing, a technique for optimizing application startup times.
Joeq system consists of seven major parts:
- Front-end: Handles the loading and parsing of input files, such as Java class files, SUIF files, and binary object files.
- Compiler: A framework for performing analyses and optimizations on code. This includes the intermediate representation (IR) of our compiler.
- Back-end: Converts the compilers intermediate representation into native, executable code. This code can be output to an object file or written into memory to be executed. In addition, it generates metadata about the generated code, such as garbage collection maps and exception handling information.
- Interpreter: Directly interprets the various forms of compiler intermediate representations.
- Memory Manager: Organizes and manages memory. Joeq supports both explicitly-managed and garbage-collected memory.
- Dynamic: Provides profile data to the code analysis and optimization component, makes compilation policy decisions, and drives the dynamic compiler.
- Run-time Support: Provides runtime support for introspection, thread scheduling, synchronization, exception handling, interfacing to external code, and language-specific features such as dynamic type checking.

Clutter is a simple GL-based canvas library.

SYNOPSIS

use Clutter qw( :init );

# create the main stage
my $stage = Clutter::Stage->get_default();
$stage->set_color(Clutter::Color->parse(DarkSlateGray));
$stage->signal_connect(key-press-event => sub { Clutter->main_quit() });
$stage->set_size(800, 600);

# add an actor and place it right in the middle
my $label = Clutter::Label->new("Sans 30", "Hello, Clutter!");
$label->set_color(Clutter::Color->new(0xff, 0xcc, 0xcc, 0xdd));
$label->set_position(($stage->get_width() - $label->get_width()) / 2,
($stage->get_height() - $label->get_height()) / 2);
$stage->add($label);

$stage->show_all();

Clutter->main();

0;

Clutter is a GObject based library for creating fast, visually rich graphical user interfaces. It is intended for creating single window heavily stylised applications such as media box uis, presentations or kiosk style programs in preference to regular desktop style applications.

Clutters underlying graphics rendering is OpenGL (version 1.2+) based. The clutter API is intended to be easy to use, attempting to hide many of the GL complexities. It targets mainly 2D based graphics and is definetly not intended to be a general interface for all OpenGL functionality.

As well as OpenGL Clutter depends on and uses Glib, Glib::Object, Gtk2::Pango, Gtk2::Gdk::Pixbuf and GStreamer.