Free structure software for linux

NOC 3.01 is a program to visualize and analyze protein structure, for crystallographic modeling and mapping, for Gromacs/Amber MD trajectories viewing and analysis. NOC is an open source project and is distributed with precompiled binaries for MS Windows, MacOSX, Linux/Unix.

GLib is the low-level core library that forms the basis for projects
such as GTK+ and GNOME.

GLib2 provides data structure handling for C, portability wrappers, and interfaces for such runtime functionality as an event loop, threads, dynamic loading, and an object system.

gjots marshals and organizes text notes in a convenient, hierarchical way.

You can use gjots2 to organise your jottings into a tree structure, adding thoughts and miscellany as you go. You can get it to spit out HTML, XML, postscript, pdf, man etc etc (see the online manual for an example of the HTML conversion).

You can use it to "mind-map" your compositions - write down all your thoughts and then start organising them into a tree. By manipulating the tree you can easily reorder your thoughts and structure them appropriately.

Its a bit like the KDE program kjots but it supports a hierarchy of folders and the folder hierarchy is always visible. Of course, its also written primarily for gnome/GTK-2 rather than KDE.

GChemPaint is a 2D chemical structures editor for the Gnome desktop.

GChemPaint should enable embedding some chemistry in files from other programs using Bonobo.

Any::Renderer::XML Perl module can render a data structure as element-only XML.

SYNOPSIS

use Any::Renderer;

my %xml_options = ();
my %options = ( XmlOptions => %xml_options );
my $format = "XML";
my $r = new Any::Renderer ( $format, %options );

my $data_structure = [...]; # arbitrary structure code
my $string = $r->render ( $data_structure );
You can get a list of all formats that this module handles using the following syntax:
my $list_ref = Any::Renderer::XML::available_formats ();

Also, determine whether or not a format requires a template with requires_template:

my $bool = Any::Renderer::XML::requires_template ( $format );

Any::Renderer::XML renders any Perl data structure passed to it as element-only XML. For example:

perl -MAny::Renderer -e "print Any::Renderer->new(XML)->render({a => 1, b => [2,3]})"
results in:

< ?xml version="1.0" encoding="ISO-8859-1" standalone="yes"? >
< output >
< a >1< /a >
< b >2< /b >
< b >3< /b >
< /output >

The rendering process comes with all the caveats cited in the XML::Simple documentation. For example if your data structure contains binary data or ASCII control characters, then the XML document that is generated may not be well-formed.

GLib is the low-level core library that forms the basis for projects
such as GTK+ and GNOME.

GLib2 provides data structure handling for C, portability wrappers, and interfaces for such runtime functionality as an event loop, threads, dynamic loading, and an object system.

Data::Diff is a data structure comparison module.

SYNOPSIS

use Data::Diff qw(diff);

# simple procedural interface to raw difference output
$out = diff( $a, $b );

# OO usage
$diff = Data::Diff->new( $a, $b );

$new = $diff->apply();
$changes = $diff->diff_a();

Data::Diff computes the differences between two abirtray complex data structures.

METHODS

Creation

new Data::Diff( $a, $b, $options )

Creates and retruns a new Data::Diff object with the differences between $a and $b.

Access

apply( $options )

Returns the result of applying one side over the other.

raw()

Returns the internal data structure that describes the differences at all levels within.

Functions

Diff( $a, $b, $options )

Compares the two arguments $a and $b and returns the raw comparison between the two.

EXPORT

Nothing by default but you can choose to export the non-OO function Diff().

Tk_CreateImageType is a Perl module to define new kind of image.

SYNOPSIS

#include < tk.h >

Tk_CreateImageType(typePtr) ClientData

Tk_GetImageMasterData(interp, name, typePtrPtr)

ARGUMENTS

Tk_ImageType *typePtr (in)

Structure that defines the new type of image. Must be static: a pointer to this structure is retained by the image code.

Tcl_Interp *interp (in)

Interpreter in which image was created.

char *name (in)

Name of existing image.

Tk_ImageType **typePtrPtr (out)

Points to word in which to store a pointer to type information for the given image, if it exists.

Tk_CreateImageType is invoked to define a new kind of image. An image type corresponds to a particular value of the type argument for the image create command. There may exist any number of different image types, and new types may be defined dynamically by calling Tk_CreateImageType. For example, there might be one type for 2-color bitmaps, another for multi-color images, another for dithered images, another for video, and so on.

The code that implements a new image type is called an image manager. It consists of a collection of procedures plus three different kinds of data structures. The first data structure is a Tk_ImageType structure, which contains the name of the image type and pointers to five procedures provided by the image manager to deal with images of this type:

typedef struct Tk_ImageType {
char *name;
Tk_ImageCreateProc *createProc;
Tk_ImageGetProc *getProc;
Tk_ImageDisplayProc *displayProc;
Tk_ImageFreeProc *freeProc;
Tk_ImageDeleteProc *deleteProc;
} Tk_ImageType;

The fields of this structure will be described in later subsections of this entry.
The second major data structure manipulated by an image manager is called an image master; it contains overall information about a particular image, such as the values of the configuration options specified in an image create command. There will usually be one of these structures for each invocation of the image create command.

The third data structure related to images is an image instance. There will usually be one of these structures for each usage of an image in a particular widget. It is possible for a single image to appear simultaneously in multiple widgets, or even multiple times in the same widget. Furthermore, different instances may be on different screens or displays. The image instance data structure describes things that may vary from instance to instance, such as colors and graphics contexts for redisplay. There is usually one instance structure for each -image option specified for a widget or canvas item.