Free architectural record software for linux

ResearchMaster project has been designed to make working a little easier. Specifically, the application can be either a storage facility for all of your precious, miscellaneous digital information, or for just some of it. The project began as a way for the author to [1] have a centralized library for all the papers and various snippets he collects, and [2] to have some powerful, built-in support for BibTeX, the LaTeX bibliography system ( The LaTeX bibliography system, as described in the Leslie Lamport book. ISBN 0-201-52983-1).
When the application starts up, it creates a virtual filesystem (vfs) from information contained in records. Each record appends itself under at least one folder in the vfs, and the vfs is represented by a tree-widget system of folders and records. The application is divided into folder controls (left) and record controls (right).
Each record is actually a set of three python dictionaries, stored in a flat ascii text file. The three dictionaries correspond to [1] BibTex information corresponding to the record, [2] Meta information (eg. isbn, call number, url, membership) and [3] an endless notes file. When a record is selected from the tree widget, the corresponding three dictionaries are presented in a three-tabbed notebook widget on the right side of the application.
New records are created via a button on the records toolbar. When you create a new record the application pops a filechooser and you are given the opportunity to import a single file. Perhaps the imported file is a pdf copy of a research paper that you dont want to lose. ResearchMaster is a good place to store it. First, the record and the imported file now have each other. Now you can keep a log of your involvement with the file in the notes portion of the record. The Meta portion of the record contains non-BibTex information, such as which folders the record is a member of. The application accesses the records BibTex information whenever the record has membership within the subtree of a particular folder for which a recursive bibliography is being generated.
Heres a typical example: Say you create a folder for some project. Lets say that after six months your folder now has several subtrees of folders and records, all arranged according to the scheme that happened. Now imagine there are twenty records with BibTex information strewn throughout the projects subtree, side-by-side with other records that dont have BibTex information (notes, whatever). By pushing the Create Bibliography button on the left toolbar the application will produce a perfectly formatted BibTex file with all twenty records.
Each record can be made a member of any folder simply by adding the folders path to the membership list in the Meta portion of the record. The tree widget is dynamically constructed by recursively examining a directory tree (corresponding to the folders of the tree-widget) and the membership list contained in each record. This is done so that we only have one physical copy of each record, despite the fact that the record might show up in fifty different places throughout the tree widget.
The file that gets imported with a record can be any file of any format. You can tell ResearchMaster to launch the file as an argument to any external application, based on the filenames suffix (.gif, .avi, .mpg, .mp3). Then, select the record from the tree, push the launch button (on the records toolbar), and voila! The associated application brings up your file. Thats one feature that makes working a little easier.
Enhancements:
- Small correction was needed on line 1140 of ResearchMaster_wxuser.py, where "researchmaster" needed to be "ReseaerchMaster" for preferences initialization.

Midirecord is a simple command-line application to record a MIDI file with your MIDI keyboard.

Midirecord project also features automatic recording to a MIDI file when you play electric piano, and thus it may be used as a "recording daemon".

QARecord is a simple multithreaded stereo recording tool. QARecord project can record both 16 bit and 32 bit WAVs.

By using a large ringbuffer for the captured data, buffer overruns are avoided. QARecord can also be used as JACK client.

MARC::Errorchecks is a Perl module with a collection of MARC 21/AACR2 error checks.

Module for storing MARC error checking subroutines, based on MARC 21, AACR2, and LCRIs. These are used to find errors not easily checked by the MARC::Lint and MARC::Lintadditions modules, such as those that cross field boundaries.

Each subroutine should generally be passed a MARC::Record object.
Returned warnings/errors are generated as follows: push @warningstoreturn, join , ($field->tag(), ": [ERROR TEXT]t"); return @warningstoreturn;

SYNOPSIS

use MARC::Batch;
use MARC::Errorchecks;

#See also MARC::Lintadditions for more checks
#use MARC::Lintadditions;

#change file names as desired
my $inputfile = marcfile.mrc;
my $errorfilename = errors.txt;
my $errorcount = 0;
open (OUT, ">$errorfilename");
#initialize $infile as new MARC::Batch object
my $batch = MARC::Batch->new(USMARC, "$inputfile");
my $errorcount = 0;
#loop through batch file of records
while (my $record = $batch->next()) {
#if $record->field(001) #add this if some records in file do not contain an 001 field
my $controlno = $record->field(001)->as_string(); #call MARC::Errorchecks subroutines

my @errorstoreturn = ();

# check everything

push @errorstoreturn, (@{MARC::Errorchecks::check_all_subs($record)});

# or only a few
push @errorstoreturn, (@{MARC::Errorchecks::check_010($record)});
push @errorstoreturn, (@{MARC::Errorchecks::check_bk008_vs_bibrefandindex($record)});

# report results
if (@errorstoreturn){
#########################################
print OUT join( "t", "$controlno", @errorstoreturn, "tn");

$errorcount++;
}

} #while

KRecord is a KDE sound recorder. Easy to use. It can just record and playback wav-files, nothing else.

Can handle multiple files, you can drop files (from the file manager) to it, it can handle large sound files without problems. Has a input level display.

KRecord is much easier to use than "krec", which is an enigma in itself.

Compiles and Installs perfectly on Slackware 10.1 with KDE 3.4.1 and qt 3.3.4.

Just Click Record button and you can record...

EnsEMBL::Web::Record is a family of modules used for managing a users persistant data in a database.

SYNOPSIS

Many web sites now encourage users to register and login to access more advanced features, and to customise a site to their needs.

The EnsEMBL::Web::Record group of Perl modules is design to manage any arbitrary type of user created data in an SQL database. This module follows the Active Record design pattern, in that each new instantiated Record object represents a single row of a database.

That object can be manipulated programatically, and any changes made can be stored in the database with a single record->save function call.

Because arbitrary Perl data structures can be stored in this manner, EnsEMBL::Web::Record allows user preferences to be easily saved, and allows developers to implement new featurs quickly.

This module was first used (and has been abstracted from) the Ensembl genome browser (http://www.ensembl.org).

New user data can be added to the database:

use EnsEMBL::Web::Record;

my $bookmark = EnsEMBL::Web::Record->new();
$bookmark->url(http://www.ensembl.org);
$bookmark->name(Ensembl);
$bookmark->save;
...

The Record can be associated with an user id:

$record->user($id);

The same record can also be removed:

$bookmark->delete;

EnsEMBL::Web::Record also provides a number of methods for getting collections of records from the database, using a field selector.

EnsEMBL::Web::Record::find_bookmarks_by_user_id($id).

XML::SAX::ByRecord can record oriented processing of (data) documents.
SYNOPSIS
use XML::SAX::Machines qw( ByRecord ) ;
my $m = ByRecord(
"My::RecordFilter1",
"My::RecordFilter2",
...
{
Handler => $h, ## optional
}
);
$m->parse_uri( "foo.xml" );
XML::SAX::ByRecord is a SAX machine that treats a document as a series of records. Everything before and after the records is emitted as-is while the records are excerpted in to little mini-documents and run one at a time through the filter pipeline contained in ByRecord.
The output is a document that has the same exact things before, after, and between the records that the input document did, but which has run each record through a filter. So if a document has 10 records in it, the per-record filter pipeline will see 10 sets of ( start_document, body of record, end_document ) events. An example is below.
This has several use cases:
- Big, record oriented documents
Big documents can be treated a record at a time with various DOM oriented processors like XML::Filter::XSLT.
- Streaming XML
Small sections of an XML stream can be run through a document processor without holding up the stream.
- Record oriented style sheets / processors
Sometimes its just plain easier to write a style sheet or - SAX filter that applies to a single record at at time, rather than having to run through a series of records.