Free attention recorder 0.65 software for linux

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...

gtk-recordMyDesktop is a GUI frontend for recordMyDesktop desktop capture application to be used on the GNOME desktop.

recordMyDesktop is a desktop session recorder for linux that attemps to be easy to use, yet also effective at its primary task. As such, the program is separated in two parts; a simple command line tool that performs the basic tasks of capturing and encoding and an interface that exposes the program functionality in a usable way.

The commandline tool (which essentially is recordMyDesktop), is written in C, while the frontend (gtk-recordMyDesktop), is written in python and pyGtk.

recordMyDesktop offers also the ability to record audio, along with video, without the need of any later proccesing or mixing.

Ardour project is a digital audio workstation. You can use it to record, edit and mix multi-track audio. Produce your own CDs. Mix video soundtracks. Experiment with new ideas about music and sound. Generate sound installations for 12 speaker gallery shows. Have Fun.

Ardour capabilities include: multichannel recording, non-linear, non-destructive region based editing with unlimited undo/redo, full automation support, a mixer whose capabilities rival high end hardware consoles, lots of plugins to warp, shift and shape your music, and controllable from hardware control surfaces at the same time as it syncs to timecode.

If youve been looking for a tool similar to ProTools, Nuendo, Cubase SX, Digital Performer, Samplitude or Sequoia, you might have found it.

Config::Properties is a Perl module to read and write property files.

SYNOPSIS

use Config::Properties;

# reading...

open PROPS, "< my_config.props"
or die "unable to open configuration file";

my $properties = new Config::Properties();
$properties->load(*PROPS);

$value = $properties->getProperty( $key );


# saving...

open PROPS, "> my_config.props"
or die "unable to open configuration file for writing";

$properties->setProperty( $key, $value );

$properties->format( %s => %s );
$properties->store(*PROPS, $header );

Config::Properties is a near implementation of the java.util.Properties API. It is designed to allow easy reading, writing and manipulation of Java-style property files.

The format of a Java-style property file is that of a key-value pair seperated by either whitespace, the colon (:) character, or the equals (=) character. Whitespace before the key and on either side of the seperator is ignored.
Lines that begin with either a hash (#) or a bang (!) are considered comment lines and ignored.

A backslash () at the end of a line signifies a continuation and the next line is counted as part of the current line (minus the backslash, any whitespace after the backslash, the line break, and any whitespace at the beginning of the next line).

The official references used to determine this format can be found in the Java API docs for java.util.Properties at http://java.sun.com/j2se/1.5.0/docs/api/java/util/Properties.html.
When a property file is saved it is in the format "key=value" for each line. This can be changed by setting the format attribute using either $object->format( $format_string ) or $object->setFormat( $format_string ) (they do the same thing). The format string is fed to printf and must contain exactly two %s format characters. The first will be replaced with the key of the property and the second with the value. The string can contain no other printf control characters, but can be anything else. A newline will be automatically added to the end of the string. You an get the current format string either by using $object->format() (with no arguments) or $object->getFormat().

If a recent version of module Text::Wrap is available, long lines are conveniently wrapped when saving.

KChords is a guitar chords dsplay and displays chords in graphical form. Now its much clearer how you should put your fingers to paly the chord. The program has a huge list of chords - around 900. If its not enough for you or you want to create a list of your favourite chords you can use chords file editor.

If for some reason you chose to download the source code then you should first extarct
it from the tarball, then run configure, then make install, the usual way:
tar -xzf kchords-0.1.tar.gz
cd kchords-0.1
./configure --prefix=/usr
make install

Attention! You have to use the --prefix, otherwise the program wont find its files
If you encounter any errors or problems during installation proccess please contact me.

Gtk2::Ex::FormFactory is a Perl module that makes building complex GUIs easy.

SYNOPSIS

#-- Refer to http://www.exit1.org/ for
#-- a comprehensive online documentation.

#-- Read Gtk2::Ex::FormFactory::Intro

use Gtk2::Ex::FormFactory;

my $context = Gtk2::Ex::FormFactory::Context->new;

$context->add_object (
name => "worksheet",
object => My::Worksheet->new,
);

# derived from Gtk2::Ex::FormFactory::Layout
my $layouter = My::Layout->new;

# derived from Gtk2::Ex::FormFactory::Rules
my $rule_checker = My::Rules->new;

my $ff = Gtk2::Ex::FormFactory->new (
context => $context,
layouter => $layouter,
rule_checker => $rule_checker,
content => [
Gtk2::Ex::FormFactory::Window->new (
title => "Worksheet Editor",
content => [
Gtk2::Ex::FormFactory::Form->new (
title => "Main data",
content => [
Gtk2::Ex::FormFactory::Entry->new (
label => "Worksheet title",
attr => "worksheet.title",
tip => "Title of this worksheet",
),
#-- More widgets...
],
),
Gtk2::Ex::FormFactory->DialogButtons->new,
],
),
],
);

$ff->open;
$ff->update;

Gtk2->main;

ABSTRACT

With Gtk2::Ex::FormFactory you can build a GUI which consistently represents the data of your application.

This is a framework which tries to make building complex GUIs easy, by offering these two main features:

* Consistent looking GUI without the need to code resp. tune each widget by hand. Instead you declare the structure of your GUI, connect it to the data of your program (which should be a well defined set of objects) and control how this structure is transformed into a specific layout in a very generic way.

* Automatically keep widget and object states in sync (in both directions), even with complex data structures with a lot of internal dependencies, object nesting etc.

This manpage describes the facilities of Gtk2::Ex::FormFactory objects which are only a small part of the whole framework. To get a full introduction and overview of how this framework works refer to Gtk2::Ex::FormFactory::Intro.