Free web front end access database software for linux

The CSound Front-End provides CSound users with a GUI with a clean and efficient layout.

The main window has been redesigned. The engine input frame is a mutant widget that can accomodate different styles of input selection (in the picture we have orc/sco pair, all-in-one .csd file and orc/generator) as well as most kinds of orc/sco pre-processing.

At the moment you switch from between the input frames using the +/- buttons (ugly!). Settings are saved separately for each frame. From the programmers point of view, writing a pre-processing plug-in now means to write a new engine input frame class.

The option window is still the same. As general GUI design guide line, Im trying to use few complex windows instead of 10s of little windows.

As side effect of the routing re-design, the logger window as been simplified. From the only menu available you can still start an external generator, assigning the logged engine as default route.

LDAP Mailing Lists Access Policy Daemon (MLAPD) is a mailing list manager that uses LDAP (instead of BDB or GDBM) to control list access. Its designed to work in conjunction with Postfix as an access policy delegation daemon. It manages electronic mail discussion and e-newsletter lists. Its goal is to store/read list data on/from LDAP.
It works as a Postfix access policy delegation agent, so it can be installed one time and used by multiple Postfix instances, or installed multiple times and not suffer database access concurrency issues (because it uses LDAP).
Enhancements:
- This can be considered the first stable and usable release.

Jamendo Lyrics is a lyrics script for Amarok audio player accessing the lyrics database for Jamendo.com music.

er2code is a tool to automatically generate code to make it easier to access a database from your program. The script takes a database description file as input and generates a directory full of database wrapper files.


The code is generated based on an XML file, and should be pretty database and language neutral. Right now, though, only PHP with a MySQL database is supported.

If you are lucky enough to be using Python for your application, i really recommend SQLObject over er2code, it is much cleaner and works with all kinds of databases.

The project is based on a Database Idea i once had, i thought it was revolutionary then, but i was later proved wrong, again, by the SQLObject guys.

Overview

The focus of this project is to take some of the boring work of off the programmers shoulders. Writing database wrappers is boring and tedious, and as such can be the course of many "sleeping-while-typing" errors.

But on the bright side, boring and tedious often means that the process can be automated, hence this tool.

The main idea of er2code is that each relation (also called table by some people) in the database, is mapped to a class of the same name. This class then contains a number of methods for manipulating the attributes contained in the relation.

The approach taken by er2code is to have a long list of methods (these are called Function in er2code), these functions have some requirements regarding an attribute that must be satisfied in order for the code of the function to generated.

The code of the function contains plain text mixed with identifiers. Each of these identifiers can generate their "value" (a text string) based on the specific attribute they are applied on.

Of course it is not as simple as that, we havent considered constructs, how to delete rows in the table, and how to handle foreign relations, e.g. 1-to-many.

The layout of the a file is a bit like C structs, and a bit like SQL.

Each relation is defined inside its own struct block:

User {
... attributes go here ...
}

This statement will cause a User class to be created.
Each attribute is defined by the name of the attribute, followed by one or more whitespace separated attribute type definers, and terminated by a semicolon.

User {
id serial;
username string(30) default(noname) sort unique index;
password string(40);
email string(100);
}

This will cause the User relation to contain four attributes:
id which is of type serial, an automatically incremented integer that is defined as the primary key.

username which is a 30-character long string, it is defined as sort which means that when a method which lists Users is called, the result should be sorted by this attribute. It also is of type index, which means that it should be possible to find a User based on the value of this attribute.

password is a 40-character string.
email is a 100-character string.

This is all er2code needs to know to create a class for the User relation, and the DataBase class, which is the one you use to connect to the database, and to list and find relations.

If the description above is used with er2code to generate PHP code, it should make it possible to write code like the following:

// Connect to the database.
$db = new DataBase ();

$halfdan = $db->findUserByUsername ( halfdan );
if ( $halfdan != null ) {
print $halfdan->getUsername() . < . $halfdan->getEmail() . >;
}

// List is automatically sorted by username
foreach ( $db->listUser() as $user ) {
print < a href="user.php?id= . $user->getId() . " > . $user->getName() . < /a >;
}

PHP Database Access Through Arrays project can be used to access data stored in MySQL tables like accessing arrays. It uses SPL to implement several classes and iterators interfaces to access MySQL databases.

Examples:

$DB[test_table][] = array(
name => first,
value => the first row
);

foreach ($DB[test_table] as $i => $row) {
...
}

$DB[test_table][first][value] = 1st;

unset($DB[test_table][first]);

file*HANDLER project is primarily a Perl script which coordinates some free media conversion packages (cited later) with a PostgreSQL back end accessing server to index and serve binary and text files direct from the database. A simple CGI file with embedded AJAX makes calls to this server which is also constantly looking for other alive f*H servers on the Internet.
Since the server caches media into the SQL database on demand, as the network grows, the network improves.
Its gridded directory sharing/browsing/searching with streaming audio/video as well as flat text/doc/pdf/image display for everyone. Its written with a few hooks for tags that would be included in your actual front page so that the UI is discard-able -- anyone can quickly rewrite a whole new [GT]UI without having to worry about the syntax of the newest version of dojo.licio.r or whatever.
If you wanted to ignore the JS/HTML/CSS hooks then you can easily use the system to make direct requests that just return lists formatted as HTML table-bodies. In other words, the markup IS the markup.
As such, Ive whipped up a Dojo 0.2 Widget that coordinates the serving backend with a UI so anyone can embed f*H functionality anywhere, or easily customize a provided default page.
A file*HANDLER server is really a few constituent parts Ive tied up for you (top down):
- A local web page providing the UI(served by an HTTP server of your choice) that is generated by a cgi script with embedded AJAX.
- A secondary portion of the same CGI script, acting as middle-ware, which communicates, via AJAX, with the local front page to reconcile asynchronous JavaScript requests with the file*HANDLER sub-network back-end.
- An always-on network server written in PERL that serves to the front and end communicates laterally with everyone elses file*HANDLER back-end PERL server additionally, it manages indexing of content directories you choose to serve.
- A PostgreSQL database that is accessed only via internal PERL routines called from your front page.
So for example, a remote user comes to your site. First, not only can they browse and search your files, but they can also browse and search the files of anyone else hosting a file*HANDLER server that your local server knows about. (file*HANDLER identifies other servers on the network automatically). The user can now read/view/listen/watch by stream any content they find from whomevers server. Theres no download, so theres so actual sharing, just direct streaming to the users browser.