Free moosic 0.09 software for linux

moosicWebGUI is a stand alone client program for controlling the moosic jukebox system. moosicWebGUI implements not only basic basic player functions but also more sophisticated functions for manipulating the playlist. It incorporates a small Web server based on Pythons SimpleHTTPServer library.
Main features:
- general player commands:
start, stop, next, previous, pause, skip +10/-10, repeat (loop), ...
- playlist commands:
shuffle, sort, reverse, delete duplicates, clear, save to file, load from file
- browse and search modes:
browse/search playlist, browse/search history, browse/search local files, tree view
- insert options:
single files or all music files in single directory or whole directory tree;
- add to top or bottom of playlist or mixin
Enhancements:
- Startup was accelerated.
- An online handbook was started.
- Links to the online handbook and to the manual page were added to the template.
- The man page was improved.

Moosic is a music player for Unix systems. It focuses on convenient and powerful playlist management. This project consists of a server process that maintains a queue of songs to be played and one or more client programs which sends commands to the server.

The server continually runs through its song queue, popping songs off the top of the list and playing each with an external program. The client is a simple command-line utility which allows you to easily perform powerful operations upon the servers queue, including the addition of whole directory trees, automatic shuffling, and song removal according to regular expressions.

The server comes configured to play MP3, Ogg, MIDI, MOD, and WAV files, but can be configured to also play any other file format you want.

MoosicApplet is a GNOME panel applet which displays the current status of the Moosic jukebox server.

It also provides some basic features for controlling the song player. MoosicApplet features a configurable layout and the ability to rewrite the song name in various ways to make it easier to read.

Math::Combinatorics is a Perl module that can perform combinations and permutations on lists.

SYNOPSIS

Available as an object oriented API.

use Math::Combinatorics;

my @n = qw(a b c);
my $combinat = Math::Combinatorics->new(count => 2,
data => [@n],
);

print "combinations of 2 from: ".join(" ",@n)."n";
print "------------------------".("--" x scalar(@n))."n";
while(my @combo = $combinat->next_combination){
print join( , @combo)."n";
}

print "n";

print "permutations of 3 from: ".join(" ",@n)."n";
print "------------------------".("--" x scalar(@n))."n";
while(my @permu = $combinat->next_permutation){
print join( , @permu)."n";
}

output:

Or available via exported functions permute, combine, and factorial.

use Math::Combinatorics;

my @n = qw(a b c);
print "combinations of 2 from: ".join(" ",@n)."n";
print "------------------------".("--" x scalar(@n))."n";
print join("n", map { join " ", @$_ } combine(2,@n)),"n";
print "n";
print "permutations of 3 from: ".join(" ",@n)."n";
print "------------------------".("--" x scalar(@n))."n";
print join("n", map { join " ", @$_ } permute(@n)),"n";

Output:

combinations of 2 from: a b c
------------------------------
a b
a c
b c

permutations of 3 from: a b c
------------------------------
a b c
a c b
b a c
b c a
c a b
c b a

Output from both types of calls is the same, but the object-oriented approach consumes much less memory for large sets.

Games::3D is a package containing an object system for (not only) 3D games.

SYNOPSIS

use Games::3D::World;

my $world = Games::3D::World->new();

$world->save_to_file( $filename );

my $loaded = Games::3D::world->load_from_file( $filename );

my $thing1 = $world->add ( Games::3D::Thingy->new( ... ) );
my $thing2 = $world->add ( Games::3D::Thingy->new( ... ) );

$world->link($thing1, $thing2);

Games::3D::World provides you with a container class that will contain every object in your game object system. This are primarily objects that have states, change these states and need to announce the states to other objects.

The Games::3D::World container also enables you to save and restore snapshots of your objects system.

Basic things that you object system contains are derived from a class called Games::3D::Thingy. These can represent physical objects (buttons, levers, doors, lights etc) as well as virtual objects (trigger, sensors, links, markers, sound sources etc).

You can link Thingys together, either directly or via Games::3D::Links. The links have some more features than direct linking, which are explained below.

This package also provides you with Games::3D::Sensor, a class for objects that sense state changes and act upon them. Or not, depending on the sensor. Sensors are primarily used to watch for certain conditions and then act when they are met. Examples are the death of an object, values that go below a certain threshold etc.

State changes are transported in the object system with signals.

VCShell is a command line interface for VCS::Lite::Repository.

SYNOPSIS

B< add > element|repository [element|repository...]
B< remove > name [name...]
B< ci >|check_in name [name...]
B< co >|check_out parent_repository
B< commit >
B< update >
B< cd > repository
B< fetch > name@@gen [>outfile]
B< diff > file1[@@gen1] [file2[@@gen2]] [>outfile]

VCShell provides a command line interface to the VCS Lite Repository. This aims to be usable by non-Perl programmers, as it provides a wrapper to the functionality in the module.

COMMANDS

add

The add command adds something to a repository: an element or a repository. If the parameter given is a directory, it makes it a repository, otherwise an element. An empty file is created for the element if none exists.

remove

Remove breaks the association between a repository and something it contains. It does not delete any files.

ci

This command is used to check in changes to one or more elements and repositories. Each repository checked in is also recursively checked in.

clone

This makes a clone of one repository into another, and recursively for everything in it. The new repository contains a parent link which points at the original.

commit

If the repository is a clone of a parent repository, this propagates any changes to the parent. Note, a check in (ci) is needed on the parent, for this change to be applied.

update

This command is used to apply any changes that have happened to the parent. Three way merging occurs for any change that has happened in the mean time.

diff

This command outputs a udiff listing for two generations of an element, or for two different elements. The default generation used is the latest, and the default generation for the "from" file is the predecessor to the "to" generation if comparing the same element.

The output is in diff -u format.

Tk::ToolBar is a toolbar widget for Perl/Tk.

SYNOPSIS

use Tk;
use Tk::ToolBar;

my $mw = new MainWindow;
my $tb = $mw->ToolBar(qw/-movable 1 -side top
-indicatorcolor blue/);

$tb->ToolButton (-text => Button,
-tip => tool tip,
-command => sub { print "hin" });
$tb->ToolLabel (-text => A Label);
$tb->Label (-text => Another Label);
$tb->ToolLabEntry(-label => A LabEntry,
-labelPack => [-side => "left",
-anchor => "w"]);

my $tb2 = $mw->ToolBar;
$tb2->ToolButton(-image => navback22,
-tip => back,
-command => &back);
$tb2->ToolButton(-image => navforward22,
-tip => forward,
-command => &forward);
$tb2->separator;
$tb2->ToolButton(-image => navhome22,
-tip => home,
-command => &home);
$tb2->ToolButton(-image => actreload22,
-tip => reload,
-command => &reload);

MainLoop;

This module implements a dockable toolbar. It is in the same spirit as the "short-cut" toolbars found in most major applications, such as most web browsers and text editors (where you find the "back" or "save" and other shortcut buttons).

Buttons of any type (regular, menu, check, radio) can be created inside this widget. You can also create Label, Entry and LabEntry widgets. Moreover, the ToolBar itself can be made dockable, such that it can be dragged to any edge of your window. Dragging is done in "real-time" so that you can see the contents of your ToolBar as you are dragging it. Furthermore, if you are close to a stickable edge, a visual indicator will show up along that edge to guide you.

ToolBars can be made "floatable" such that if they are dragged beyond their associated window, they will detach and float on the desktop. Also, multiple ToolBars are embeddable inside each other.

If you drag a ToolBar to within 15 pixels of an edge, it will stick to that edge. If the ToolBar is further than 15 pixels away from an edge and still inside the window, but you release it over another ToolBar widget, then it will be embedded inside the second ToolBar. You can "un-embed" an embedded ToolBar simply by dragging it out. You can change the 15 pixel limit using the -close option.

Various icons are built into the Tk::ToolBar widget. Those icons can be used as images for ToolButtons (see "SYNOPSIS"). A demo program is bundled with the module that should be available under the User Contributed Demonstrations when you run the widget program. Run it to see a list of the available images.

Tk::ToolBar attempts to use Tk::CursorControl if its already installed on the system. You can further control this using the -cursorcontrol option. See "PREREQUISITES".
The ToolBar is supposed to be created as a child of a Toplevel (MainWindow is a Toplevel widget) or a Frame. You are free to experiment otherwise, but expect the unexpected.