Free matter what type software for linux

Play What I Mean project allows a user to, from a single commandline or terminal, enter a string, or list of strings, that represent what he/she wishes to have played by whatsoever media player he chooses, the default being MPlayer, and then having that particular item be found and played.
What this essentially means is that if I were to have a sudden hankering to listen to a particular song or video, lets say Ice Pick by The Pillows, which happens to be the song to a particular music video that I enjoy watching. Under the traditional methods of video viewing I would be stuck with two potential courses of action for playing this particular file:
- Change directories several times to that one folder somewhere that I "know" its in, or
- Point and Click my mouse until I find that same directory and then search through what could be countless files to find it.
Each of these prospective choices have their own inherent difficulties and ire. Using the commandline often requires alot of typing to arrive at the desired directory, often times nestled deep within the tree.
Once there your problems only multiply by the number of files you actually store in your "media" folder, try ls | moreing through a heavily populated folder looking for the name of that file you wanted to play sometime, it isnt too fun and further is a waste of my valuable time.
You may be thinking at this point that the second option, the graphical one, must be easier since its exciting, full of pictures, and frankly novel, I disagree. I may not be the best judge on this matter, seeing as how I cant see out of my right eye however, I feel that scanning through a large folder, or folders, full of files is quite a strain on the vision, and more importantly an unnescesary burden on what should be a simple matter.
Main features:
- Nestable Playlist support
- Multi-string arguments
- Transparent command option passing
- Cache for faster access of frequently played files
- Graphical configure

Data::Type is a Perl module with versatile data and value types.

SYNOPSIS

use Data::Type qw(:all);
use Error qw(:try);

try
{
verify $email , EMAIL;
verify $homepage , URI(http);
verify $cc , CREDITCARD( MASTERCARD, VISA );
verify $answer_a , YESNO;
verify $gender , GENDER;
verify one , ENUM( qw(one two three) );
verify [qw(two six)], SET( qw(one two three four five six) ) );
verify $server_ip4 , IP(v4);
verify $server_ip6 , IP(v6);

verify A35231AH1 , CINS;
verify 14565935 , ISSN;
verify DE , LANGCODE;
verify German , LANGNAME;

verify 012345678905, UPC();
verify 5276440065421319, CREDITCARD( MASTERCARD ) );

verify ATGCAAAT , BIO::DNA;
verify AUGGGAAAU , BIO::RNA;

verify 01001001110110101, BINARY;
verify 0F 0C 0A, HEX;

verify 0 , DEFINED;
verify 234 , NUM( 20 );
verify 1 , BOOL( true );
verify 100 , INT;
verify 1.1 , REAL;

my $foo = bless( 123, SomeThing );

verify $foo , REF;
verify $foo , REF( qw(SomeThing Else) );
verify [ bar ] , REF( ARRAY );

verify x 20 , VARCHAR( 20 );
verify 2001-01-01 , DATE( MYSQL );
verify 16 Nov 94 22:28:20 PST , DATE( DATEPARSE );
verify 9999-12-31 23:59:59, DATETIME;
verify 1970-01-01 00:00:00, TIMESTAMP;
verify -838:59:59 , TIME;
verify 2155 , YEAR;
verify 69 , YEAR(2);
verify 0 x 20 , TINYTEXT;
verify 0 x 20 , MEDIUMTEXT;
verify 0 x 20 , LONGTEXT;
verify 0 x 20 , TEXT;

verify 80 , PORT;
verify www.cpan.org, DOMAIN;
}
catch Type::Exception with
{
my $e = shift;

printf "Expected %s %s at %s line %sn",
$e->value,
$e->type->info,
$e->was_file,
$e->was_line;

foreach my $entry ( testplan( $e->type ) )
{
printf "texpecting it %s %s ", $entry->[1] ? is : is NOT, $entry->[0]->info();
}
};

# believe it or not, this really works

foreach ( EMAIL, WORD, CREDITCARD( MASTERCARD, VISA ), BIO::DNA, HEX )
{
print $_->info;
print $_->usage;
print $_->export; # does it have other names
print $_->param; # what are my choice i.e. [yes,no]
print $_->isa( IType::Business ); # is it a Business related type ?
print $_->VERSION; # first apperance in Data::Type release
}

# tied interface (alias typ)

try
{
typ ENUM( qw(DNA RNA) ), ( my $a, my $b );

print "a is typed" if istyp( $a );

$a = DNA; # $alias only accepts DNA or RNA
$a = RNA;
$a = xNA; # throws exception

untyp( $alias );
}
catch Type::Exception ::with
{
printf "Expected %s %s at %s line %sn",
$e->value,
$e->type->info,
$e->was_file,
$e->was_line;
};

dverify( $email, EMAIL ) or die $!;

my $g = Data::Type::Guard->new(

allow => [ Human, Others ], # blessed objects of that type

tests =>
{
email => EMAIL( 1 ), # mxcheck ON ! see Email::Valid
firstname => WORD,
social_id => [ NUM, VARCHAR( 10 ) ],
contacts => sub { my %args = @_; exists $args{lucy} },
}
);

$g->inspect( $h );

# compact version

overify { email => EMAIL( 1 ), firstname => WORD }, $object_a, $object_b;

print toc();

print catalog();

This module supports versatile data and value types. Out of the ordinary it supports parameterised types (like databases have i.e. VARCHAR(80) ). When you try to feed a typed variable against some odd data, this module explains what he would have expected.

Hash::Type module contains pseudo-hashes as arrays tied to a "type" (list of fields).

SYNOPSIS

use Hash::Type;

# create a Hash::Type
my $personType = new Hash::Type(qw(firstname lastname city));

# create and populate some hashes tied to $personType
tie %wolfgang, $personType, "wolfgang amadeus", "mozart", "salzburg";
$ludwig = new $personType ("ludwig", "van beethoven", "vienna");
$jsb = new $personType;
$jsb->{city} = "leipzig";
@{$jsb}{qw(firstname lastname)} = ("johann sebastian", "bach");

# add fields dynamically
$personType->add("birth", "death") or die "fields not added";
$wolfgang{birth} = 1750;

# More complete example : read a flat file with headers on first line
my ($headerline, @datalines) = map {chomp; $_} ;
my $ht = new Hash::Type(split /t/, $headerline);
foreach my $line (@datalines) {
my $data = new $ht(split /t/, $line);
work_with($data->{someField}, $data->{someOtherField});
}

# an alternative to Time::gmtime and Time::localtime
my $timeType = new Hash::Type qw(sec min hour mday mon year wday yday);
my $localtime = new $timeType (localtime);
my $gmtime = new $timeType (gmtime);
print $localtime->{hour} - $gmtime->{hour}, " hours difference to GMT";

# comparison functions
my $byAge = $personType->cmp("birth : -num, lastname, firstname");
my $byNameLength = $personType->cmp(lastname => {length($b) length($a)},
lastname => alpha,
firstname => alpha);
showPerson($_) foreach (sort $byAge @people);
showPerson($_) foreach (sort $byNameLength @people);

# special comparisons : dates
my $US_DateCmp = $myHashType->cmp("someDateField : m/d/y");
my $FR_InverseDateCmp = $myHashType->cmp("someDateField : -d.m.y");

BoomBasster is a music player that runs under DirectFB.

BoomBasster plays any type of music file that is supported by FusionSound.

The user interface uses alpha blending and works well with touchscreens.

BoomBasster is supposed to be used with the mouse.

Class::Meta::Type is a Perl module for data type validation and accessor building.

SYNOPSIS

package MyApp::TypeDef;

use strict;
use Class::Meta::Type;
use IO::Socket;

my $type = Class::Meta::Type->add( key => io_socket,
desc => IO::Socket object,
name => IO::Socket Object );

This class stores the various data types used by Class::Meta. It manages all aspects of data type validation and method creation. New data types can be added to Class::Meta::Type by means of the add() constructor. This is useful for creating custom types for your Class::Meta-built classes.

Note:This class manages the most advanced features of Class::Meta. Before deciding to create your own accessor closures as described in add(), you should have a thorough working knowledge of how Class::Meta works, and have studied the add() method carefully. Simple data type definitions such as that shown in the SYNOPSIS, on the other hand, are encouraged.

Data::Type::Docs is a Perl module with the manual overview.

MANUALS

Data::Type::Docs::FAQ

Frequently asked questions.

Data::Type::Docs::FOP

Frequently occuring problems.

Data::Type::Docs::Howto

Point to point recipes how to get things done.

Data::Type::Docs::RFC

Exact API description. Startpoint for datatype developers.

NAVIGATION

First read the following paragraphs and then you may start study the Data::Type API.

Makin Bakon Typing Tutor project is a terminal-based typing tutor game written in C++ (with STL) and Curses.

It contains both structured and fortune-based lessons.

Learn to type to a professional standard while youre saving Pigs bacon!

Warning: Includes material that may offend.