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

Data::Inherited is a Perl module with hierarchy-wide accumulation of list and hash results.

SYNOPSIS

package Foo;
use base Data::Inherited;
use constant PROPERTIES => (qw/name address/);

package Bar;
use base Foo;
use constant PROPERTIES => (qw/age/);

package main;
my $bar = Bar->new;
print "$_n" for $bar->every_list(PROPERTIES);
prints
name
address
age

This is a mixin class. By inheriting from it you get two methods that are able to accumulate hierarchy-wide list and hash results.

every_list(String $method_name, Bool ?$override_cache = 0)

Takes as arguments a method name (mandatory) and a boolean indicating whether to override the cache (optional, off by default)

Causes every method in the objects hierarchy with the given name to be invoked. The resulting list is the combined set of results from all the methods, pushed together in top-to-bottom order (hierarchy-wise).

every_list() returns a list in list context and an array reference in scalar context.
The result is cached (per calling package) and the next time the method is called from the same package with the same method argument, the cached result is returned.

This is to speed up method calls, because internally this module uses NEXT, which is quite slow. It is expected that every_list() is used for methods returning static lists (object defaults, static class definitions and such). If you want to override the caching mechanism, you can provide the optional second argument. The result is cached in any case.

PLWM is a Python package, containing classes suitable for implementing a window manager. PLWM is also a window manager, using the PLWM package.
Enhancements:
- This is mostly a bug fix release, to get the latest set of fixes out the door.
- Distutils is now used to build and install plwm.
- We now require Python 2.0 or later. Python 1.5 is no longer supported.
Mike Meyer (mwm@mired.org) is now administering PLWM.
New mixin: mixer.py.
- This is a new mixin for controlling the audio mixer. Currently, it only supports "rexima", but it should be easy to extend to "aumix" etc.
Menu screen mixin is now configurable.
- The menu screen mixin has been extended to use menu_font, menu_foreground, menu_background, menu_bordercolor, and menu_borderwidth when it draws menus on the screen. The default is 9x15Bold, black, white, black and 3. menu_seconds is the number of seconds the menu will be onscreen before it vanishes of its own accord. The default value is 0, which means to stay until a selection is made or the menu is cancelled.
Message screen mixin is now configurable.
- The message screen mixin can now be configured with message_font, message_foreground, message_background, message_bordercolor and message_borderwidth. message_seconds controls how long the message is displayed for, with a default value of 5 seconds.
Screen.system now allows i/o redirection.
- The Screen.system method now takes an extra argument, redirect. This argument should either be a single integer between 0 and 2 inclusive, or a tuple of such integers. These fds are redirected to pipes, and the resulting pipes are returned as a three-tuple. Supplying redirect implies that the command will be run in the background.

Spiffy is a Spiffy Perl Interface Framework For You.

SYNOPSIS

package Keen;
use Spiffy -Base;
field mirth;
const mood => :-);

sub happy {
if ($self->mood eq :-() {
$self->mirth(-1);
print "Cheer up!";
}
super;
}

"Spiffy" is a framework and methodology for doing object oriented (OO) programming in Perl. Spiffy combines the best parts of Exporter.pm, base.pm, mixin.pm and SUPER.pm into one magic foundation class. It attempts to fix all the nits and warts of traditional Perl OO, in a clean, straightforward and (perhaps someday) standard way.

Spiffy borrows ideas from other OO languages like Python, Ruby, Java and Perl 6. It also adds a few tricks of its own.

If you take a look on CPAN, there are a ton of OO related modules. When starting a new project, you need to pick the set of modules that makes most sense, and then you need to use those modules in each of your classes. Spiffy, on the other hand, has everything youll probably need in one module, and you only need to use it once in one of your classes. If you make Spiffy.pm the base class of the basest class in your project, Spiffy will automatically pass all of its magic to all of your subclasses. You may eventually forget that youre even using it!

The most striking difference between Spiffy and other Perl object oriented base classes, is that it has the ability to export things. If you create a subclass of Spiffy, all the things that Spiffy exports will automatically be exported by your subclass, in addition to any more things that you want to export. And if someone creates a subclass of your subclass, all of those things will be exported automatically, and so on. Think of it as "Inherited Exportation", and it uses the familiar Exporter.pm specification syntax.

To use Spiffy or any subclass of Spiffy as a base class of your class, you specify the -base argument to the use command.

use MySpiffyBaseModule -base;

You can also use the traditional use base MySpiffyBaseModule; syntax and everything will work exactly the same. The only caveat is that Spiffy.pm must already be loaded. Thats because Spiffy rewires base.pm on the fly to do all the Spiffy magics.

Spiffy has support for Ruby-like mixins with Perl6-like roles. Just like base you can use either of the following invocations:

use mixin MySpiffyBaseModule;
use MySpiffyBaseModule -mixin;

The second version will only work if the class being mixed in is a subclass of Spiffy. The first version will work in all cases, as long as Spiffy has already been loaded.

To limit the methods that get mixed in, use roles. (Hint: they work just like an Exporter list):

use MySpiffyBaseModule -mixin => qw(:basics x y !foo);

In object oriented Perl almost every subroutine is a method. Each method gets the object passed to it as its first argument. That means practically every subroutine starts with the line:

my $self = shift;

Spiffy provides a simple, optional filter mechanism to insert that line for you, resulting in cleaner code. If you figure an average method has 10 lines of code, thats 10% of your code! To turn this option on, you just use the -Base option instead of the -base option, or add the -selfless option. If source filtering makes you queazy, dont use the feature. I personally find it addictive in my quest for writing squeaky clean, maintainable code.

A useful feature of Spiffy is that it exports two functions: field and const that can be used to declare the attributes of your class, and automatically generate accessor methods for them. The only difference between the two functions is that const attributes can not be modified; thus the accessor is much faster.
One interesting aspect of OO programming is when a method calls the same method from a parent class. This is generally known as calling a super method. Perls facility for doing this is butt ugly:

sub cleanup {
my $self = shift;
$self->scrub;
$self->SUPER::cleanup(@_);
}

Spiffy makes it, er, super easy to call super methods. You just use the super function. You dont need to pass it any arguments because it automatically passes them on for you. Heres the same function with Spiffy:

sub cleanup {
$self->scrub;
super;
}

Spiffy has a special method for parsing arguments called parse_arguments, that it also uses for parsing its own arguments. You declare which arguments are boolean (singletons) and which ones are paired, with two special methods called boolean_arguments and paired_arguments. Parse arguments pulls out the booleans and pairs and returns them in an anonymous hash, followed by a list of the unmatched arguments.

Finally, Spiffy can export a few debugging functions WWW, XXX, YYY and ZZZ. Each of them produces a YAML dump of its arguments. WWW warns the output, XXX dies with the output, YYY prints the output, and ZZZ confesses the output. If YAML doesnt suit your needs, you can switch all the dumps to Data::Dumper format with the -dumper option.

Class::Spiffy is a Spiffy Framework with No Source Filtering.

SYNOPSIS

package Keen;
use strict;
use warnings;
use Class::Spiffy -base;
field mirth;
const mood => :-);

sub happy {
my $self = shift;
if ($self->mood eq :-() {
$self->mirth(-1);
print "Cheer up!";
}
super;
}

1;

"Class::Spiffy" is a framework and methodology for doing object oriented (OO) programming in Perl. Class::Spiffy combines the best parts of Exporter.pm, base.pm, mixin.pm and SUPER.pm into one magic foundation class. It attempts to fix all the nits and warts of traditional Perl OO, in a clean, straightforward and (perhaps someday) standard way.

Class::Spiffy borrows ideas from other OO languages like Python, Ruby, Java and Perl 6. It also adds a few tricks of its own.

If you take a look on CPAN, there are a ton of OO related modules. When starting a new project, you need to pick the set of modules that makes most sense, and then you need to use those modules in each of your classes. Class::Spiffy, on the other hand, has everything youll probably need in one module, and you only need to use it once in one of your classes. If you make Class::Spiffy the base class of the basest class in your project, Class::Spiffy will automatically pass all of its magic to all of your subclasses. You may eventually forget that youre even using it!

The most striking difference between Class::Spiffy and other Perl object oriented base classes, is that it has the ability to export things. If you create a subclass of Class::Spiffy, all the things that Class::Spiffy exports will automatically be exported by your subclass, in addition to any more things that you want to export. And if someone creates a subclass of your subclass, all of those things will be exported automatically, and so on. Think of it as "Inherited Exportation", and it uses the familiar Exporter.pm specification syntax.
To use Class::Spiffy or any subclass of Class::Spiffy as a base class of your class, you specify the -base argument to the use command.

use MySpiffyBaseModule -base;

You can also use the traditional use base MySpiffyBaseModule; syntax and everything will work exactly the same. The only caveat is that Class::Spiffy must already be loaded. Thats because Class::Spiffy rewires base.pm on the fly to do all the Spiffy magics.

Class::Spiffy has support for Ruby-like mixins with Perl6-like roles. Just like base you can use either of the following invocations:

use mixin MySpiffyBaseModule;
use MySpiffyBaseModule -mixin;

The second version will only work if the class being mixed in is a subclass of Class::Spiffy. The first version will work in all cases, as long as Class::Spiffy has already been loaded.

To limit the methods that get mixed in, use roles. (Hint: they work just like an Exporter list):

use MySpiffyBaseModule -mixin => qw(:basics x y !foo);

A useful feature of Class::Spiffy is that it exports two functions: field and const that can be used to declare the attributes of your class, and automatically generate accessor methods for them. The only difference between the two functions is that const attributes can not be modified; thus the accessor is much faster.

One interesting aspect of OO programming is when a method calls the same method from a parent class. This is generally known as calling a super method. Perls facility for doing this is butt ugly:

sub cleanup {
my $self = shift;
$self->scrub;
$self->SUPER::cleanup(@_);
}

Class::Spiffy makes it, er, super easy to call super methods. You just use the super function. You dont need to pass it any arguments because it automatically passes them on for you. Heres the same function with Class::Spiffy:

sub cleanup {
my $self = shift;
$self->scrub;
super;
}

Class::Spiffy has a special method for parsing arguments called parse_arguments, that it also uses for parsing its own arguments. You declare which arguments are boolean (singletons) and which ones are paired, with two special methods called boolean_arguments and paired_arguments. Parse arguments pulls out the booleans and pairs and returns them in an anonymous hash, followed by a list of the unmatched arguments.

Finally, Class::Spiffy can export a few debugging functions WWW, XXX, YYY and ZZZ. Each of them produces a YAML dump of its arguments. WWW warns the output, XXX dies with the output, YYY prints the output, and ZZZ confesses the output. If YAML doesnt suit your needs, you can switch all the dumps to Data::Dumper format with the - dumper option.

Sprog is a graphical tool that anyone can use to build programs by plugging parts together. In Sprog jargon, the parts are known as gears and they are assembled to make a machine.
Gears are selected from a palette and dragged onto the Sprog workbench, where they can be connected together.
Options can be set using a properties dialog on each gear. When assembly is complete, the machine can be run, reconfigured, or re-run.
Enhancements:
- fix bug: machine not stopping after syntax error in Perl gear
- fix bug: broken cancel button in tools/prefs dialog
- fix bug: extra file_end events from command_filter
- fix Enter for default in file dialogs
- add ability to rename gears
- make gear title and text window fonts configurable
- make right click menu stay visible on click-release
- implement filename = - for STDIN in ReadFile.pm
- rename mixin classes from Sprog::Gear::* to Sprog::Mixin::*

Scala is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way.
Scala smoothly integrates features of object-oriented and functional languages including mixins, algebraic datatypes with pattern matching, genericity, and more.
It is well integrated with Java and .NET: the Scala compiler produces standard Java class files or .NET assemblies, and Java/.NET libraries and frameworks can be used without glue code or additional declarations.
Scala is a pure object-oriented language in the sense that every value is an object. Types and behavior of objects are described by classes and traits. Class abstractions are extended by subclassing and a flexible mixin-based composition mechanism as a clean replacement for multiple inheritance.
Whats New in 2.6.0 RC1 Development Release:
- This version introduces some language changes (existential types, lazy values, structural types, etc.) and fixes many bugs.