zgomot 1.0.2 → 1.0.3

data/README.rdoc

@@ -164,6 +164,22 @@ Percussion supports the following transformations,
 
 * <tt>bpm!(bpm)</tt>: change the bits per minute at which the note is played.
 
+== Note List
+
+A Note List is a set of notes or percussive notes that start playing simultaneously. The Note List may contain any number of notes and its duration is the duration of the longest note in the list. It is defined by,
+
+    nl(n1, n2, ..., nN)
+
+where <tt>nN</tt> is the <tt>N'th</tt> note in the list.
+
+==== Transforms
+
+* <tt>shift</tt>: Remove and return the first note from the progression.
+* <tt>unshift</tt>: Add a note to the beginning of the progression.
+* <tt>pop</tt>: Remove and return the last note from the progression.
+* <tt>push</tt>: Add a note to the end of the progression.
+* <tt>reverse!</tt>: Reverse the notes in the progression.
+
 == Chord Progressions
 
 Chord Progressions or Roman Numeral Notation permit the definition of a melody that is independent of key. Using Chord progressions it is possible to iteratively shift the key of a specified sequence of chords.
@@ -188,15 +204,18 @@ A chord progression in a key of F# dorian at octave 5 with notes of half note le
 * <tt>tonic!(tonic)</tt>: Change the tonic pitch of the progression.
 * <tt>mode!(mode)</tt>: Change the mode of the progression
 * <tt>[](*args)</tt>: By default when a progression is created it only consists of one each of the notes in the key played sequentially. Using this transformation it is possible to change the the notes played in the progression. For example <tt>cp([:Fs, 5], :dorian)[1,5,5,7]</tt> will play the sequence <tt>1, 5, 5, 7</tt> instead of <tt>1, 2, 3, 4, 5, 6, 7</tt>.
-* <tt>velocity=(v)</tt>: Change the velocity of all notes in the progression.
-* <tt>length=(v)</tt>: Change the length of all notes in the progression.
+* <tt>velocity!(v)</tt>: Change the velocity of all notes in the progression.
+* <tt>length!(v)</tt>: Change the length of all notes in the progression.
 * <tt>bpm!(bpm)</tt>: change the bits per minute at which the chord is played.
 * <tt>octave!(ocatve)</tt>: change the octave of all notes in the progression.
 * <tt>arp!(length)</tt>: arpeggiate the chords in the progression using the specified length in units of note length. Accepted values are 1, 2, 4, 8, ... resolution, representing arpeggiation by a whole note, half note, quarter note, eighth note up to the specified clock resolution.
 * <tt>inv!(number)</tt>: The inversion number. A value of zero will leave the chord unchanged, 1 is the first inversion and 2 is the second. Higher inversions just shift the chord to a higher octave.
 * <tt>rev!</tt>: Reverse the order in which the notes are played. Only noticeable if the chords in the progression are also arpeggiated.
-
-Progressions internally are arrays of notes. The following array methods are supported: <tt>reverse!, shift, pop, push, unshift</tt>
+* <tt>shift</tt>: Remove and return the first chord from the progression.
+* <tt>unshift</tt>: Add a chord to the beginning of the progression.
+* <tt>pop</tt>: Remove and return the last chord from the progression.
+* <tt>push</tt>: Add a chord to the end of the progression.
+* <tt>reverse!</tt>: Reverse the chords in the progression.
 
 == Note Progressions
 
@@ -220,12 +239,15 @@ An note progression in a key of F# dorian at octave 5 with notes of half note le
 * <tt>tonic!(tonic)</tt>: Change the tonic pitch of the progression.
 * <tt>mode!(mode)</tt>: Change the mode of the progression
 * <tt>[](*args)</tt>: By default when a progression is created it only consists of one each of the notes in the key played sequentially using this transformation it is possible to change the the notes played in the progression. For example <tt>np([:Fs, 5], :dorian)[1,5,5,7]</tt> will play the sequence 1, 5, 5, 7 instead of 1, 2, 3, 4, 5, 6, 7.
-* <tt>velocity=(v)</tt>: Change the velocity of all notes in the progression.
-* <tt>length=(v)</tt>: Change the length of all notes in the progression.
-* <tt>bpm!(bpm)</tt>: change the bits per minute at which the chord is played.
-* <tt>octave!(ocatve)</tt>: change the octave of all notes in the progression.
-
-Progressions internally are arrays of notes. The following array methods are supported: <tt>reverse!, shift, pop, push, unshift</tt>
+* <tt>velocity!(v)</tt>: Change the velocity of all notes in the progression.
+* <tt>length!(v)</tt>: Change the length of all notes in the progression.
+* <tt>bpm!(bpm)</tt>: Change the bits per minute at which the chord is played.
+* <tt>octave!(ocatve)</tt>: Change the octave of all notes in the progression.
+* <tt>shift</tt>: Remove and return the first note from the progression.
+* <tt>unshift</tt>: Add a note to the beginning of the progression.
+* <tt>pop</tt>: Remove and return the last note from the progression.
+* <tt>push</tt>: Add a note to the end of the progression.
+* <tt>reverse!</tt>: Reverse the notes in the progression.
 
 == Progression with Defined Length and Velocity by Note
 
@@ -237,6 +259,12 @@ Different durations and velocities for each note in a progression can be defined
 
 Patterns are heterogeneous arrays of notes, chords, Chord Progressions and Note Progressions. Operations applied to the pattern will be delegated to the appropriate elements of the pattern array.
 
+Also, custom transformations can be applied to the items of a pattern using <tt>map</tt>,
+
+  pattern.map do |item|
+    transform(item)
+  end
+
 == Streams
 
 A stream is used to define iteration on a pattern and outputs a stream of MIDI data.
@@ -357,13 +385,21 @@ where <tt>name</tt> is the name of the <tt>input</tt>. There can be only one MID
 
 MIDI CC messages can be used to assign values to variables that can be read by programs. To assign a CC message to a variable use,
 
-    add_cc(name, ch, options)
+    add_cc(name, cc, options)
 
-Where <tt>name</tt> is the variable name, ,<tt>ch</tt> is the MIDI CC identifier, a number between 0 and 255 and options are the following,
+Where <tt>name</tt> is the variable name, ,<tt>cc</tt> is the MIDI CC identifier, a number between 0 and 255 and options are the following,
 
 * <tt>:max</tt>: The maximum value of the CC message. The default is 1.
 * <tt>:min</tt>: The minimum value of the CC message. The default is 0.
+* <tt>:channel</tt>: The CC channel number. The default is 1.
 * <tt>:type</tt>: The CC message type. Accepted values are <tt>:cont</tt> and <tt>:switch</tt>. <tt>:cont</tt> type varies continuously between <tt>:max</tt> and <tt>:min</tt>. <tt>:switch</tt> type is boolean.
+* <tt>:init</tt>: The initial value of the CC message. The default is 0 if type is <tt>:cont</tt> and <tt>false</tt> if type is <tt>:switch</tt>.
+
+A block can also be passed to <tt>add_cc</tt> which is yielded the updated cc parameters. For example a CC which pauses a stream would look like,
+
+    add_cc('pause', 17, :type => :switch) do
+      pause('my_stream')
+    end
 
 To read a variable assigned to a CC message use,
 
@@ -391,7 +427,7 @@ All commands and objects described previously are available and can be typed dir
 * <tt>pause name</tt>: Pause the named stream. If no name is given pause all <tt>playing</tt> streams.
 * <tt>stop name</tt>: An alias for <tt>pause</tt>.
 * <tt>tog name</tt>: Toggle the status of the named stream. <tt>name</tt> is required.
-
+* <tt>watch dir</tt>: Automatically load any new or updated files in <tt>dir</tt>. The default value of <tt>dir</tt> is the current directory.
 
 === Dashboard
 
@@ -401,7 +437,9 @@ and defined CCs. The time, stream and CC status are updated every beat. Also, st
 * <tt>q</tt>: Quit <tt>dash</tt>.
 * <tt>p</tt>: Play all streams.
 * <tt>s</tt>: Stop all streams.
-* <tt>t</tt>: Toggle the <tt>playing/paused</tt> status of a stream. When <tt>t</tt> is entered use the up/down keys to traverse the list of streams and type return to select a stream. Type <tt>t</tt> again to exit without selecting a stream.
+* <tt>t</tt>: Toggle the <tt>playing/paused</tt> status of selected streams. When <tt>t</tt> is entered use the <tt>up/down</tt> keys to traverse the list of streams and type <tt>return</tt> to select a stream. Multiple streams can be selected. Type <tt>t</tt> again to toggle the status of the selected streams.
+* <tt>d</tt>: Delete selected streams. When <tt>d</tt> is entered use the <tt>up/down</tt> keys to traverse the list of streams and type <tt>return</tt> to select a stream. Multiple streams can be selected. Type <tt>d</tt> again to delete the selected streams.
+
 
 == Callbacks
 

data/Rakefile

@@ -18,6 +18,7 @@ require 'jeweler'
     gem.add_dependency('ffi', '~> 1.0.9')
     gem.add_dependency('rainbow', '~> 1.1.4')
     gem.add_dependency('pry', '~> 0.9.12.2')
+    gem.add_dependency('fssm', '~> 0.2.10')
   end
 rescue LoadError
   abort "jeweler is not available. In order to run test, you must: sudo gem install technicalpickles-jeweler --source=http://gems.github.com"

data/VERSION

@@ -1 +1 @@
-1.0.2
+1.0.3

data/examples/cycle.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require "#{File.dirname(__FILE__)}/../lib/zgomot"
+
+before_start do
+  Zgomot.logger.level = Logger::DEBUG
+end
+
+str 'cycle', np([:Fs, 4], :dorian, :l=>4)[3,1,3,5] do |pattern|
+  pattern.push(pattern.shift.first)
+end
+
+play
+

data/examples/cycle_note_list.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+require "#{File.dirname(__FILE__)}/../lib/zgomot"
+
+before_start do
+  Zgomot.logger.level = Logger::DEBUG
+end
+
+str 'cycle', [nl(n([:C,5]), n(:B)), nl(n(:G), n(:C,))] do |pattern|
+  notes = pattern.shift
+  pattern.map{|n| n.push(notes.shift)}
+end
+
+play
+

data/examples/dynamic_length.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require "#{File.dirname(__FILE__)}/../lib/zgomot"
+
+before_start do
+  Zgomot.logger.level = Logger::DEBUG
+end
+
+if sources.include?("nanoKONTROL")
+  add_input("nanoKONTROL")
+  add_cc(:mult, 33, :type => :cont, :min => 0, :max => 3, :init => 0)
+  len = 4
+  str 'dynamic', np([:A,4],2,:l=>len)[7,5,3,1] do |pattern|
+    pattern.length!((2**cc(:mult).to_i)*len)
+  end
+  play
+end
+
+

data/examples/dynamic_length_perc.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+require "#{File.dirname(__FILE__)}/../lib/zgomot"
+
+before_start do
+  Zgomot.logger.level = Logger::DEBUG
+end
+
+if sources.include?("nanoKONTROL")
+  add_input("nanoKONTROL")
+  add_cc(:mult, 33, :type => :cont, :min => 0, :max => 4, :init => 0)
+  len = 4
+  str 'perc', [pr(:low_floor_tom, :l => len),
+                 pr(:low_tom, :l => len),
+                 n(:R, :l=> len),
+                 pr(:high_mid_tom, :l => len)], :ch=>0 do |pattern|
+    pattern.length!((2**cc(:mult).to_i)*len)
+  end
+  play
+end
+
+
+

data/examples/geco_input.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require "#{File.dirname(__FILE__)}/../lib/zgomot"
+
+before_start do
+  Zgomot.logger.level = Logger::DEBUG
+end
+
+if sources.include?("GECO")
+  add_input("GECO")
+  add_cc(:mode, 17, :type => :cont, :min => 0, :max => 6, :init => 0)
+  str 'simple_input', np([:A,4],2,:l=>4)[7,5,3,1] do |pattern|
+    pattern.mode!(cc(:mode).to_i)
+  end
+  play
+end
+

data/examples/simple_input.rb

@@ -9,11 +9,15 @@ if sources.include?("nanoKONTROL")
   add_input("nanoKONTROL")
   add_cc(:mode, 17, :type => :cont, :min => 0, :max => 6, :init => 0)
   add_cc(:reverse, 13, :type => :switch)
+  add_cc(:turn_off, 12, :type => :switch)
+  add_cc(:turn_off, 12, :type => :switch) do
+    tog(:simple_input)
+  end
   str 'simple_input', np([:A,4],2,:l=>4)[7,5,3,1] do |pattern|
     if cc(:reverse)
-      pattern.mode!(cc(:mode).to_i).reverse!
+      pattern.mode!(mode.to_i).reverse!
     else
-      pattern.mode!(cc(:mode).to_i)
+      pattern.mode!(mode.to_i)
     end
   end
   play

data/examples/simple_note_list.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require "#{File.dirname(__FILE__)}/../lib/zgomot"
+
+before_start do
+  Zgomot.logger.level = Logger::DEBUG
+end
+
+str 'notes' do
+  [nl(n([:C,5]), n(:B)), nl(n(:G), n(:C,))]
+end
+
+play

data/examples/zgomot_streams.rb

@@ -1,11 +1,15 @@
 set_config(:beats_per_minute=>120, :time_signature=>"4/4", :resolution=>"1/64")
 
-add_input("nanoKONTROL") if sources.include?("nanoKONTROL")
+if sources.include?("nanoKONTROL")
+  add_input("nanoKONTROL")
+end
 add_cc(:mode, 17, :type => :cont, :min => 0, :max => 6, :init => 0)
 add_cc(:reverse, 13, :type => :switch)
+add_cc(:toggle_input, 12, :type => :switch) do
+  tog(:input)
+end
 
-
-str 'input', np([:A,4],2,:l=>4)[7,5,3,1], :ch=>0 do |pattern|
+str 'input', np([:A,4],6,:l=>4)[1,3,7,2], :ch=>0 do |pattern|
   if cc(:reverse)
     pattern.mode!(cc(:mode).to_i).reverse!
   else

data/lib/zgomot.rb

@@ -9,6 +9,7 @@ require 'monitor'
 require 'ffi'
 require 'rainbow'
 require 'curses'
+require 'fssm'
 
 require 'zgomot/config'
 require 'zgomot/boot'

data/lib/zgomot/boot.rb

@@ -1,3 +1,5 @@
+Thread.abort_on_exception = true
+
 module Zgomot
 
   class Boot

data/lib/zgomot/comp.rb

@@ -7,5 +7,6 @@ require 'zgomot/comp/perc'
 require 'zgomot/comp/progression'
 require 'zgomot/comp/pitch_class'
 require 'zgomot/comp/markov'
+require 'zgomot/comp/note_list'
 
 

data/lib/zgomot/comp/chord.rb

@@ -36,8 +36,8 @@ module Zgomot::Comp
       attr_reader :chord_intervals
     end
 
-    attr_reader :tonic, :chord, :clock, :intervals, :arp, :time_scale, :items, :inversion, :reverse
-    attr_accessor :length, :velocity
+    attr_reader :tonic, :chord, :clock, :intervals, :arp, :time_scale, :items, :inversion, :reverse,
+                :length, :velocity
 
     def initialize(args)
       @length, @velocity, @chord = args[:length], args[:velocity], args[:chord]
@@ -82,6 +82,12 @@ module Zgomot::Comp
     def octave!(v)
       @notes = nil; @octave = v; self
     end
+    def length!(v)
+      @length = v; self
+    end
+    def valocity!(v)
+      @length = v; self
+    end
     def length_to_sec
       time_scale*Zgomot::Midi::Clock.whole_note_sec*(1.0/length + (arp.to_f.eql?(0.0) ? 0.0 : intervals.length.to_f/arp.to_f))
     end

data/lib/zgomot/comp/mode.rb

@@ -19,7 +19,7 @@ module Zgomot::Comp
     def initialize(mode = 1)
       @mode = case mode
                  when Symbol then self.class.modes.index(mode)+1
-                 when Fixnum then mode
+                 when Fixnum then mode % 7
                  when nil then 1
                  else raise(Zgomot::Error, "#{mode.inspect} is invalid mode")
                end

data/lib/zgomot/comp/note_list.rb

@@ -0,0 +1,68 @@
+module Zgomot::Comp
+
+  class NoteList
+
+    def self.nl(*args)
+      NoteList.new(*args)
+    end
+
+    attr_reader :notes, :clock
+
+    def initialize(*notes)
+      unless notes.all?{|n| n.class == Zgomot::Midi::Note or n.class == Zgomot::Comp::Perc}
+        raise(Zgomot::Error, "all arguments must be class Zgomot::Midi::Note Zgomot::Comp::Perc")
+      end
+      @notes = notes
+    end
+    def <<(note)
+      notes << note
+    end
+    def length_to_sec
+      notes.map(&:length_to_sec).max
+    end
+    def to_midi
+      notes.map{|n| n.to_midi}
+    end
+    def channel=(chan)
+      notes.each{|n| n.channel = chan}
+    end
+    def offset=(time)
+      notes.each{|n| n.offset = time}
+    end
+    def velocity!(v)
+      notes.each{|n| n.velocity!(v)}; self
+    end
+    def length!(v)
+      notes.each{|n| n.length!(v)}; self
+    end
+    def bpm!(bpm)
+      notes.each{|n| n.bpm!(bpm)}; self
+    end
+    def octave!(oct)
+      notes.each{|n| n.octave!(oct)}; self
+    end
+    def shift
+      @notes.shift
+    end
+    def unshift(n)
+      @notes.unshift(n); self
+    end
+    def pop
+      @notes.pop
+    end
+    def push(n)
+      @notes.push(n); self
+    end
+    def reverse!
+      @notes.reverse!; self
+    end
+    def time=(time)
+      @clock = Zgomot::Midi::Clock.new
+      clock.update(time)
+      notes.each{|n| n.time = clock.current_time}
+    end
+
+  end
+
+end
+

data/lib/zgomot/comp/pattern.rb

@@ -21,9 +21,9 @@ module Zgomot::Comp
         Progression.new(:item => Chord::Progression.new(:scale), :tonic => tonic, :mode => mode, :length => l, :velocity => v)
       end
 
-      def pr(percs = acoustic_bass_drum, opts = {})
+      def pr(perc = :acoustic_bass_drum, opts = {})
         l = opts[:l] || 4; v = opts[:v] || 0.6
-        Perc.new(:percs => percs, :length => l, :velocity => v)
+        Perc.new(:perc => perc, :length => l, :velocity => v)
       end
     end
     attr_reader :seq
@@ -31,10 +31,18 @@ module Zgomot::Comp
       @seq = [seq].flatten
     end
     def method_missing(meth, *args, &blk)
-      @seq = seq.map do |p|
+      result = seq.map do |p|
                p.respond_to?(meth) ? p.send(meth, *args, &blk) : p
              end
-      self
+      if [:shift, :pop].include?(meth)
+        result
+      else
+        @seq = result
+        self
+      end
+    end
+    def map(&blk)
+      @seq = seq.map(&blk); self
     end
   end
 end

data/lib/zgomot/comp/perc.rb

@@ -1,94 +1,64 @@
-##############################################################################################################
 module Zgomot::Comp
-
-  #####-------------------------------------------------------------------------------------------------------
   class Perc
-    
-    #.........................................................................................................
+
     PERC_MAP = {
-        :acoustic_bass_drum => [:B,1], 
+        :acoustic_bass_drum => [:B,1],
         :bass_drum_1        => [:C,2],  :side_stick     => [:Cs,2], :acoustic_snare => [:D,2],
         :hand_clap          => [:Ds,2], :electric_snare => [:E,2],  :low_floor_tom  => [:F,2],
         :closed_hi_hat      => [:Fs,2], :high_floor_tom => [:G,2],  :pedal_hi_hat   => [:Gs,2],
         :low_tom            => [:A,2],  :open_hi_hat    => [:As,2], :low_mid_tom    => [:B,2],
-        :high_mid_tom       => [:C,3],  :crash_cymbal_1 => [:Cs,3], :high_tom       => [:D,3], 
-        :ride_cymbal_1      => [:Ds,3], :chinese_cymbal => [:E,3],  :ride_bell      => [:F,3], 
-        :tambourine         => [:Fs,3], :splash_cymbal  => [:G,3],  :cowbell        => [:Gs,3], 
+        :high_mid_tom       => [:C,3],  :crash_cymbal_1 => [:Cs,3], :high_tom       => [:D,3],
+        :ride_cymbal_1      => [:Ds,3], :chinese_cymbal => [:E,3],  :ride_bell      => [:F,3],
+        :tambourine         => [:Fs,3], :splash_cymbal  => [:G,3],  :cowbell        => [:Gs,3],
         :crash_cymbal_2     => [:A,3],  :vibraslap      => [:As,3], :ride_cymbal_2  => [:B,3],
-        :high_bongo         => [:C,4],  :low_bongo      => [:Cs,4], :mute_hi_conga  => [:D,4], 
-        :open_hi_conga      => [:Ds,4], :low_conga      => [:E,4],  :high_timbale   => [:F,4], 
-        :low_timbale        => [:Fs,4], :high_agogo     => [:G,4],  :low_agogo      => [:Gs,4], 
+        :high_bongo         => [:C,4],  :low_bongo      => [:Cs,4], :mute_hi_conga  => [:D,4],
+        :open_hi_conga      => [:Ds,4], :low_conga      => [:E,4],  :high_timbale   => [:F,4],
+        :low_timbale        => [:Fs,4], :high_agogo     => [:G,4],  :low_agogo      => [:Gs,4],
         :cabasa             => [:A,4],  :maracas        => [:As,4], :short_whistle  => [:B,4],
-        :long_whistle       => [:C,5],  :short_guiro    => [:Cs,5], :long_guiro     => [:D,5],  
-        :claves             => [:Ds,5], :hi_woodblock   => [:E,5],  :low_woodblock  => [:F,5], 
-        :mute_cuica         => [:Fs,5], :open_cuica     => [:G,5],  :mute_triangle  => [:Gs,5], 
+        :long_whistle       => [:C,5],  :short_guiro    => [:Cs,5], :long_guiro     => [:D,5],
+        :claves             => [:Ds,5], :hi_woodblock   => [:E,5],  :low_woodblock  => [:F,5],
+        :mute_cuica         => [:Fs,5], :open_cuica     => [:G,5],  :mute_triangle  => [:Gs,5],
         :open_triangle      => [:A,5],
-        :R                  => :R,      
+        :R                  => :R,
         }
 
-    #####-------------------------------------------------------------------------------------------------------
     class << self
-
-    #### self
-    end
-    
-    #.........................................................................................................
-    attr_reader :percs, :length, :velocity, :time_scale
-  
-    #.........................................................................................................
-    def initialize(args)
-      @length, @velocity, @percs = args[:length], args[:velocity], [args[:percs]].flatten
-      @time_scale = 1.0
     end
 
-    #.........................................................................................................
-    def pitches
-      percs.inject([]){|p,r| (m = Perc::PERC_MAP[r]).nil? ? p : p << m}
+    attr_reader :perc, :length, :velocity, :time_scale
+
+    def initialize(args)
+      @length, @velocity, @perc = args[:length], args[:velocity], args[:perc]
     end
-    
-    #.........................................................................................................
-    def notes
-      @notes ||= pitches.map do |p| 
-                   Zgomot::Midi::Note.new(:pitch => p, :length => length, :velocity => velocity)
-                 end                          
+    def note
+      @note ||= Zgomot::Midi::Note.new(:pitch => Perc::PERC_MAP[perc],
+                                       :length => length,
+                                       :velocity => velocity)
     end
-
-    #.........................................................................................................
-    # transforms
-    #.........................................................................................................
-    def bpm_scale!(v)
-      @time_scale = 1.0/v.to_f; self
+    def bpm!(v)
+      note.bpm!(v); self
     end
-    
-    #.........................................................................................................
-    # channel and dispatch interface
-    #.........................................................................................................
     def channel=(chan)
-      notes.each{|n| n.channel = chan}
+      note.channel = chan
     end
-
-    #.........................................................................................................
     def offset=(time)
-      notes.each{|n| n.offset = time}
+      note.offset = time
     end
-    
-    #.........................................................................................................
     def time=(time)
-      notes.each{|n| n.time = time}
+      note.time = time
+    end
+    def velocity!(v)
+      note.velocity!(v); self
+    end
+    def length!(v)
+      note.length!(v); self
     end
-
-    #.........................................................................................................
     def length_to_sec
-      time_scale*Zgomot::Midi::Clock.whole_note_sec/length
+      note.length_to_sec
     end
-
-    #.........................................................................................................
     def to_midi
-      notes.map{|n| n.to_midi}
+      note.to_midi
     end
-      
-  #### Scale
-  end
 
-#### Zgomot::Comp 
+  end
 end