File Coverage

blib/lib/POE/Framework/MIDI/Key.pm

Criterion	Covered	Total	%
statement	17	45	37.7
branch	1	8	12.5
condition			n/a
subroutine	5	12	41.6
pod	0	8	0.0
total	23	73	31.5

# $Id: Key.pm,v 1.2 2004/12/04 18:15:58 root Exp $

package POE::Framework::MIDI::Key;

use strict;
no strict 'refs';
use vars '$VERSION'; $VERSION = '0.02';
use MIDI::Simple;

# a lexcion of key types and a key for building them from a root note
#
my $lexicon = {
    # major scale is tone tone semitone, tone tone tone semitone
    maj => [0,2,2,1,2,2,2,1], major => [0,2,2,1,2,2,2,1],
    # declaring it twice is probably dumb, but we need to be able to refer to it by both
    # key names......there's probaby a more sane way to do this
};

sub new {
    my (  $self, $class ) = ( {}, shift );
    bless $self, $class;
    $self->{cfg} 	= shift;
    #$self->make_root_numeric;
    $self->{intervals} = $lexicon->{$self->{cfg}->{name}}
        or warn "sorry - $self->{cfg}->{name} is not supported yet";
    return $self;
}

# the root note - the tonic of the key
sub root {
    my ( $self, $new_root ) = @_;
    $new_root ?
        $self->{cfg}->{root} = $new_root  : return $self->{cfg}->{root}
}

#chord's name
sub name {
    my ( $self, $new_name ) = @_;
    $new_name ?
        $self->{cfg}->{name} = $new_name : return $self->{cfg}->{name}
}

sub make_root_numeric {
    my $self = shift;
    if ($self->{cfg}->{root} =~ /\D/) {
        $self->{cfg}->{root} = $self->note_to_number($self->{cfg}->{root});
    }
}

sub note_to_number {
    my ( $self,  $note ) = @_;
    my ( $letters, $numbers ) = $note =~ /(\D+)(\d+)/;
    my $position = $MIDI::Simple::Note{$letters};
    my $end_position = $position + ($numbers * 12);
    return $end_position;
}

# what is the position of this note in the key?
sub noteposition {
    my ( $self, $note ) = @_;
    my $numeric_position = $self->note_to_number($note);
    print $self->root . "\n";
    my $scale = $self->numeric_scale;

    # we need to generate a "monster scale" that extends this tonal
    # pattern off to 0 and 127
    for (@$scale) {
        print "$_\n";
    }
}

# use the intervals from the lexicon to make the scale based on the
# root for this key.  For example, if use C4 for the root, (note #)
sub numeric_scale {
    my $self = shift;
    my @scale;
    my $last_note = $self->root;
    for (@{$self->{intervals}}) {
        push @scale, $last_note + $_;
        $last_note = $scale[-1]; # (negative subscripting)++
    }
    return \@scale;
}

sub intervals {
    my $self = shift;
    return $self->{intervals};
}




1;

__END__