Free compound software for linux

PicoStorage allows you to store hierarhical information (similar to "files and directories") inside a single file. The functionality offered is largely equivalent to the one offered by any filesystem, or by the Structured Storage and Compound Files.

PicoStorage can efficiently handle huge numbers of small files, with very economical disk usage; it also allows you to keep open (in RAM) simultaneously a large number of files. Transaction support guarantees data integrity.

Learn more about the distinctive advantages of PicoStorage. or look at the benchmark.

The library is available on a dual-license basis: under GPL for free, and under a commercial license for use in closed-source applications.

Using

The library contains the classes File and Dir to represent files and directories. On a File you can read or write a number of bytes from a given offset, and set/get the file size. On a Dir you can create entries (either files or subdirectories), open entries, delete entries, and iterate over the directorys content.

The storage itself (i.e. the whole hierarchical structure, contained in a filesystem file) is represented by the class Storage. Using this class, you can create or open a storage, obtain the root directory of the storage, close the storage and do commit or rollback.

Gestalter is a free vector drawing program. The user interface is loosely modelled after the famous Illustrator by Adobe. The central element is the Bezier curve used as a base part for almost every other object.

Complex paths are possible, compound paths can be constructed, grouping of elements is enabled and everything can be screened by a mask. Multiple layers are possible, one can choose between two display modes: a antialiased and a wireframe one. The native storage format is a subset of SVG, printing output is Postscript.

You can place pixel images and transform (rotate, skew, scale, etc.) but not edit them (use GIMP for editing pixel image data). You can open the Postscript output of gestalter in GIMP to use your drawings on The Net.

XDrawChem is a two-dimensional molecule drawing program for Unix operating systems. XDrawChem is similar in functionality to other molecule drawing programs such as ChemDraw (TM, CambridgeSoft).
It can read and write MDL Molfiles, and read ChemDraw text and binary files, to allow sharing between XDrawChem and other chemistry applications, and it can create images in popular formats like PNG and EPS. XDrawChem has been tested on Linux, SGI IRIX 6.5, Sun Solaris, Mac OS X, and Windows.
Main features:
- 100% compatible Windows 95/98/NT version
- Fixed length, fixed angle drawing.
- Automatic alignment of figures. Detects structures, text, and arrows and places them automatically.
- Can automatically draw rings and other structures - has all standard amino acids and nucleic acids in built-in library.
- Can retrieve structures from a network database based on CAS number, formula, or name.
- Can draw symbols such as partial charge, radicals, etc.
- Can read MDL Molfiles, CML [Chemical Markup Language, defined in J. Chem. Inf. Comput. Sci.39(1999), 928-942], ChemDraw(TM) binary format, ChemDraw(TM) XML text format.
- Can write MDL Molfiles, CML, ChemDraw(TM) XML text format.
- Can also read and write any format supported by the current release of OpenBabel.
- Can export pictures in PNG, Windows bitmap (*.bmp), Encapsulated PostScript (EPS), and Scalable Vector Graphics (SVG).
- Can generate 3-D structures with the help of the external program BUILD3D.
- Online help, including tool tips.
- 13C-NMR prediction, based on Bremser W, Mag. Res. Chem.23(4):271-275
- 1H-NMR prediction, based on additive rules and functional group lookup methods, described in Pretsch, Clerc, Seibl, Simon, "Tables of Spectral Data for Structure Determination of Organic Compounds", 2ed., 1989, Springer-Verlag
- Simple IR prediction.
- Simple pKa estimation.
- Octanol-water partition coefficient estimation.
- Reaction analysis: gas-phase enthalpy change estimate, 1H NMR and 13C NMR comparison.
- Integration with OpenBabel, allowing XDrawChem to read and write over 20 different chemical file formats.

dotBook reader is a reader for HTML books in .jar and .zip files.

The dotBook application will be a book reader that can download, display and cache books in a special JAR file format.

The format will allow digital signatures with PGP and allow books to have chapters and paragraphs that can be found conveniently from within the application but will link sources outside books by opening the default web browser. Book pages will be HTML pages with some restrictions.

Design Goals

The goal is to have an XML descriptor format to be stored outside the book (JAR file) and an XML content format to be stored inside the JAR file. A compound format that allows to combine descriptor, JAR file and signatures in a single file is being considered. Reading the descriptor should be very easy and not require to read the JAR file, so the JAR file will possibly be compressed and appended to the uncompressed descriptor.

The book layout will honor CSS PrintLayouts.

The XML content will allow for imprints following an independent specification for XML imprints, factored out from the esp.nongnu.org project.

The dotBook editor will allow to edit a limited subset of the MediaWiki syntax and a subset of HTML.

The format is intended to be useful on e-Paper devices that can hibernate between turning pages. A sequential page order will be encouraged, while still allowing to set anchors and links inside pages. Animated content will be discouraged: It will probably only be animated on user request. That means all animated images will be replaced by empty boxes with the text "Animation : [play]" inside, if no still image is provided to take the place.

Pmw project is a toolkit for building high-level compound widgets in Python using the Tkinter module.
It consists of a set of base classes and a library of flexible and extensible megawidgets built on this foundation.
These megawidgets include notebooks, comboboxes, selection widgets, paned widgets, scrolled widgets and dialog windows.
Main features:
- A few base classes, providing a foundation for building megawidgets.
- A library of flexible and extensible megawidgets built on the base classes, such as buttonboxes, notebooks, comboboxes, selection widgets, paned widgets, scrolled widgets and dialog windows.
- A lazy importer/dynamic loader which is automatically invoked when Pmw is first imported. This gives unified access to all Pmw classes and functions through the Pmw. prefix. It also speeds up module loading time by only importing Pmw sub-modules when needed.
- Complete reference documentation, covering all classes and functions including all megawidgets and their options, methods and components. Helpful tutorial material is also available.
- A test framework and tests for Pmw megawidgets.
- A slick demonstration of the megawidgets.
- An interface to the BLT busy, graph and vector commands.

Scheme2Js is a Scheme to Javascript compiler. While some effort has been spent on being as close as possible to R5rs, we concentrated mainly on efficiency.
Usually Scheme2Js produces Javascript code, that is comparable to hand-written code. In order to achieve this performance, Scheme2Js is not completely R5rs compliant. In particular it lacks support for continuations, exact numbers and it treats tail recursion only partially.
Scheme2Js provides several flags, that allow to modify the result:
- --no-js-dot-notation disallows access to JavaScript fields with the dot-notation. This flag disables accesses of the form x.y like in document.getElementById. It is however still possible to access the is a valid expression using the js-field function.
- --mutable-strings: in order to improve the performance of string-operations and to ease the interface between Scheme and JavaScript code, the default implementation maps Scheme strings to JavaScript strings. Contrary to Scheme strings, JavaScript strings are however immutable. This flag maps strings to a JavaScript class, that represents Scheme strings, that are mutable. The resulting code might be slightly slower, and it is more difficult to interface with Javascript code.
- --encapsulate-parts encapsulates the program into an anonymous function. Only global variables are outside of this anonymous function. On one hand this introduces one function call to the anonymous function. But on the other hand most Javascript implementations should run faster with this optimization: usually hashtables are used to represent scopes in JavaScript. By using an anonymous function the programs variables are separated into their own smaller hashtable which (in theory) accelerates accesses to these variables. More importantly the variables are stored in their own hashtable, and not in the global hashtable, which is accessible by the global variable. It is extremely easy to indirectly modify the contents of global variables. Inlining or other common optimizations are hence impossible to do on global variables. By storing the programs variables in an anonymous function these optimizations become again possible.
- --optimize-var-number reduces the number of variables used in the resulting JavaScript code. The code may run faster, but is more difficult to debug, as the variable names are lost and the same variable might be used several times.
- --optimize-while: with this flag Scheme2Js optimizes common while loops. The unoptimized while loops are often of the form:
while(true) {
if(test)
resVar = res;
else {
modify_loop_variable;
continue;
}
break;
}
This optimization looks for these patterns and moves the test into the while loop:
while(!test) {
modify_loop_variable;
}
resVar = res;
This optimization has been implemented only recently and is therefore not yet activated by default.
- --verbose prints some information.
- --no-inlining disables all function inlining (constants might still be inlined).
- --inline-globals lets Scheme2Js inline global functions and constants. This might have two unwanted side-effects: for one, global variables are often used to transfer data between different modules. Some inlined functions are lost if there is no reference to them anymore. If global functions are to be used outside a module, one should not use this flag. (This behavior is likely to change in future versions of Scheme2Js.)
- --unresolved-is-js: if a variable is unbound, the compiler will assume the variable comes from another module, or from JavaScript. See Section Scheme - Javascript for a more detailed discussion of the JavaScript Scheme interface.
- --js-this provides the this variable within Scheme functions. This way, Scheme procedures can be used as methods of JavaScript objects.
- --no-tailrec disables the tailrec to while-loop optimization. If you suspect a bug in the compilers way of translating tail-recs, you could try this flag.
- --no-optimize-calls disables Scheme2Js inlining of binary or unary operations. For instance sci_plus(3, 5) is optimized to (3+5). This optimization is quite important, and theres usually no reason to disable it.
- --no-optimize-consts disables the pre-constant calculation. Unless disabled (with this flag), compound constants are precalculated and their occurrences replaced by a reference to a variable holding the constant. This makes repeated accesses to these constants faster, but introduces new variables.
- --no-optimize-boolify disables the boolify optimization. JavaScripts and Schemes boolify are not equivalent: JavaScript considers false, 0, null and undefined to be false, whereas Scheme only has #f. The unoptimized boolify therefore always adds the test against false: if (test !== false) ... If Scheme2Js can see, that the test itself is a boolean, it can remove the unnecessary !== false test. This flag disables this optimization.
- --d STAGE prints a dot-file (see graphviz) of the AST after stage STAGE. Possible stages are: expand, tree, symbol, node-elim1, tail, inline, constant-propagation, rm-unused-vars, capture, node-elim2, while, (tt "statements"), node-elim3. Usually one doesnt need this flag, unless for debugging purposes.
- --print-locs prints the original locations as comments to the JavaScript file. These locations are currently the character-offset from the beginning of the file.
Enhancements:
- This release adds trampolines.

libbonobo is the non-GUI part of the bonobo component infrastructure, it is most useful for creating aggregate interfaces & doing IPC easily.

libbonobo also contains a rather badly designed & implemented per-system activation system. This needs re-writing & simplifying to be per-display.

Take a look at samples/echo/.

What is Bonobo

Bonobo is a set of language and system independant CORBA interfaces for creating reusable components, controls and creating compound documents.

The Bonobo distribution includes a Gtk+ based implementation of the Bonobo interfaces, enabling developers to create reusable components and applications that can be used to form more complex documents.

If you want to look into a Java implementation of Bonobo, look in the GNOME CVS for the `monkeybeans module (Erdi Gergo is the author), you can browse it at: http://cvs.gnome.org/bonsai