zgomot 1.0.2 → 1.0.3

data/lib/zgomot/comp/progression.rb

@@ -20,9 +20,7 @@ module Zgomot::Comp
       end.unshift(tonic)
     end
     def new_respond_to?(meth, include_private=false)
-      old_respond_to?(meth) or
-      notes.any?{|n| n.respond_to?(meth)} or
-      (items.respond_to?(meth) and [:reverse!, :shift, :pop, :push, :unshift].include?(meth))
+      old_respond_to?(meth) or notes.any?{|n| n.respond_to?(meth)}
     end
     alias_method :old_respond_to?, :respond_to?
     alias_method :respond_to?, :new_respond_to?
@@ -57,15 +55,30 @@ module Zgomot::Comp
     def [](*args)
       @items = args.flatten; self
     end
-    def velocity=(v)
-      notes.each{|n| n.velocity = v}
+    def velocity!(v)
+      notes.each{|n| n.velocity!(v)}; self
     end
-    def length=(v)
-      notes.each{|n| n.length = v}
+    def length!(v)
+      notes.each{|n| n.length!(v)}; self
     end
     def note(number)
       notes.map{|n| n.note(number)}
     end
+    def shift
+      @notes = nil; @items.shift
+    end
+    def unshift(n)
+      @notes = nil; @items.unshift(n); self
+    end
+    def pop
+      @notes = nil; @items.pop
+    end
+    def push(n)
+      @notes = nil; @items.push(n); self
+    end
+    def reverse!
+      @notes = nil; @items.reverse!; self
+    end
 
     #.........................................................................................................
     # midi interface

data/lib/zgomot/drivers/core_midi.rb

@@ -109,14 +109,14 @@ class Zgomot::Drivers
       def load_destinations
         @destinations = (0..(Interface.MIDIGetNumberOfDestinations()-1)).reduce([]) do |dest, i|
                           destination_ptr = Interface.MIDIGetDestination(i)
-                          dest << get_property(:model, destination_ptr)
+                          dest << get_entity_name(destination_ptr)
                         end
       end
 
       def load_sources
         @sources = (0..(Interface.MIDIGetNumberOfSources()-1)).reduce([]) do |src, i|
                      source_ptr = Interface.MIDIGetSource(i)
-                     src << get_property(:model, source_ptr)
+                     src << get_entity_name(source_ptr)
                    end
       end
 
@@ -136,11 +136,20 @@ class Zgomot::Drivers
         @output = @destinations[iac_index]
       end
 
+      def get_entity_name(from)
+        name = get_property(:model, from)
+        name.nil? ? (get_property(:name, from) || 'Unknown') : name
+      end
+
       def get_property(name, from)
         prop = Interface::CFString.CFStringCreateWithCString(nil, name.to_s, 0)
-        val = Interface::CFString.CFStringCreateWithCString(nil, name.to_s, 0)
-        Interface::MIDIObjectGetStringProperty(from, prop, val)
-        Interface::CFString.CFStringGetCStringPtr(val.read_pointer, 0).read_string
+        val_ptr = FFI::MemoryPointer.new(:pointer)
+        Interface::MIDIObjectGetStringProperty(from, prop, val_ptr)
+        if val_ptr.read_pointer.address > 0
+          Interface::CFString.CFStringGetCStringPtr(val_ptr.read_pointer, 0).read_string
+        else
+          nil
+        end
       end
 
       def create_client(name)

data/lib/zgomot/main.rb

@@ -13,7 +13,7 @@ module Zgomot
     end
     delegate Zgomot::Boot, :before_start
     delegate Zgomot::Midi::Clock, :set_config
-    delegate Zgomot::Midi::Stream, :str, :run, :play, :pause, :stop, :tog
+    delegate Zgomot::Midi::Stream, :str, :run, :play, :pause, :stop, :tog, :delete
     delegate Zgomot::Midi::Dispatcher, :clk
     delegate Zgomot::Midi::CC, :cc, :add_cc, :learn_cc
     delegate Zgomot::Comp::Pattern, :np, :cp, :c, :n, :pr
@@ -22,6 +22,55 @@ module Zgomot
              :add_input, :remove_input
     delegate Zgomot::UI::MainWindow, :dash
     delegate Zgomot::UI::Output, :lstr, :lcc, :lconfig
+    delegate Zgomot, :watch
+    delegate Zgomot::Comp::NoteList, :nl
+  end
+
+  def self.last_error
+    @last_error
+  end
+
+  def self.set_last_error(error)
+    @last_error = error
+  end
+
+  def self.watch(dir=nil)
+    dir ||= '.'
+    raise(Zgomot::Error, "Directory '#{dir}' does not exist") unless Dir.exists?(dir)
+    Zgomot.logger.info "WATCHING '#{dir}' FOR UPDATES"
+    Thread.new do
+      FSSM.monitor(dir) do
+        update do |dir, file|
+          unless /.*\.rb$/.match(file).nil?
+            Zgomot.set_last_error(nil)
+            path = File.join(dir, file)
+            Zgomot.logger.info "LOADED UPDATED FILE: #{path}"
+            playing_streams = Zgomot::Midi::Stream.streams.values.select{|s| s.status_eql?(:playing)}
+            playing_streams.each{|s| Zgomot::Midi::Stream.pause(s.name)}
+            sleep(Zgomot::Midi::Clock.measure_sec)
+            begin
+              load path
+            rescue Exception => e
+              Zgomot.set_last_error(e.message)
+            end
+            playing_streams.each{|s| Zgomot::Midi::Stream.play(s.name)}
+          end
+        end
+        create do |dir, file|
+          unless /.*\.rb$/.match(file).nil?
+            Zgomot.set_last_error(nil)
+            path = File.join(dir, file)
+            Zgomot.logger.info "LOADED CREATED FILE: #{path}"
+            begin
+              load path
+            rescue Exception => e
+              Zgomot.set_last_error(e.message)
+            end
+          end
+        end
+      end
+    end
+    dir
   end
 end
 

data/lib/zgomot/midi/cc.rb

@@ -8,7 +8,7 @@ module Zgomot::Midi
 
       attr_reader :ccs, :params
 
-      def add_cc(name, cc, args)
+      def add_cc(name, cc, args, &blk)
         channel = args[:channel].nil? ? 1 : args[:channel]
         min = args[:min].nil? ? 0.0 : args[:min]
         max = args[:max].nil? ? 1.0 : args[:max]
@@ -20,7 +20,8 @@ module Zgomot::Midi
                                            :value       => init,
                                            :type        => type,
                                            :updated_at  => ::Time.now,
-                                           :cc          => cc}
+                                           :cc          => cc,
+                                           :blk         => blk}
         Zgomot.logger.info "ADDED CC #{cc}:#{name}:#{init}:#{channel}"
       end
       def learn_cc(name, cc, args)
@@ -51,13 +52,18 @@ module Zgomot::Midi
         unless name.nil?
           Zgomot.logger.info "UPDATED CC #{cc_num}:#{name}:#{value}:#{channel}"
           p = @params[name][channel]
-          p[:updated_at] = ::Time.now
-          min = p[:min]
-          max = p[:max]
-          if p[:type] == :cont
-            p[:value] = min + (max - min)*value.to_f/127.0
-          else
-            p[:value] = value == 127 ? true : false
+          unless p.nil?
+            p[:updated_at] = ::Time.now
+            min = p[:min]
+            max = p[:max]
+            if p[:type] == :cont
+              p[:value] = min + (max - min)*value.to_f/127.0
+            else
+              p[:value] = value == 127 ? true : false
+            end
+            if p[:blk]
+              p[:blk].call(p)
+            end
           end
         end
       end

data/lib/zgomot/midi/dispatcher.rb

@@ -16,6 +16,14 @@ module Zgomot::Midi
         clock.to_s
       end
 
+      def flush
+        @queue.clear
+      end
+
+      def done?
+        qmutex.synchronize{queue.empty? and playing.empty?}
+      end
+
       def enqueue(ch)
         ch.offset = clock.ceil
         qmutex.synchronize do

data/lib/zgomot/midi/note.rb

@@ -26,9 +26,8 @@ module Zgomot::Midi
 
     end
 
-    attr_reader :pitch_class, :octave, :midi, :time_scale
-    attr_accessor :time, :offset, :global_offset, :channel, :velocity, :length
-
+    attr_reader :pitch_class, :octave, :midi, :time_scale, :velocity, :length
+    attr_accessor :time, :offset, :global_offset, :channel
     def initialize(args)
       @pitch_class, @octave = case args[:pitch]
                                 when Array then args[:pitch]
@@ -43,35 +42,33 @@ module Zgomot::Midi
       raise(Zgomot::Error, "#{args[:pitch].inspect} is invalid") if midi.nil?
       raise(Zgomot::Error, "#{velocity} is invalid velocity") unless velocity < 1.0
     end
-
     def to_s
       "[#{pitch_class.to_s},#{octave}].#{length}.#{midi}.#{velocity}"
     end
-
     def bpm!(bpm)
       @time_scale = 1.0/bpm.to_f; self
     end
-
     def octave!(oct)
       @octave = oct; self
     end
-
+    def length!(v)
+      @length = v; self
+    end
+    def valocity!(v)
+      @length = v; self
+    end
     def note_on
       time + offset
     end
-
     def length_to_sec
       time_scale*Clock.whole_note_sec/length
     end
-
     def note_off
       note_on + length_to_sec
     end
-
     def to_midi
       self
     end
-
     def pitch_to_midi(pitch_class, octave)
       if PITCH_CLASS[pitch_class]
         (midi = 12*(octave+1)+PITCH_CLASS[pitch_class]) <= 127 ? midi : nil

data/lib/zgomot/midi/stream.rb

@@ -43,6 +43,12 @@ module Zgomot::Midi
           stream.status_eql?(:playing) ? pause(name) : play(name)
         end
       end
+      def delete(name)
+        apply_to_stream(name) do |stream|
+          stream.update_status(:paused)
+          streams.delete(name.to_s).name
+        end
+      end
       def apply_to_stream(name)
         stream = streams.values.find{|s| s.name == name.to_s}
         if stream
@@ -96,7 +102,11 @@ module Zgomot::Midi
                     end
                     Zgomot.logger.info "STREAM:#{count}:#{name}"
                     patterns << Zgomot::Comp::Pattern.new(ch.pattern)
-                    sleep(ch.length_to_sec)
+                    if ch.length_to_sec > 0.0
+                      sleep(ch.length_to_sec)
+                    else
+                      break
+                    end
                   end
         Zgomot.logger.info "STREAM FINISHED:#{name}"
         update_status(:paused)

data/lib/zgomot/ui/windows.rb

@@ -2,7 +2,7 @@ module Zgomot::UI
   WIDTH = 80
   GLOBALS_HEIGHT = 6
   STREAMS_HEIGHT = 20
-  CCS_TOP = GLOBALS_HEIGHT + STREAMS_HEIGHT
+  ERROR_WINDOW_HEIGHT = 4
   COLOR_GREY = 100
   COLOR_GOLD = 101
   COLOR_GREEN = 202
@@ -15,6 +15,7 @@ module Zgomot::UI
   COLOR_YELLOW_GREEN = 211
   COLOR_LIGHT_BLUE = 212
   COLOR_ORANGE = 213
+  COLOR_RED = 214
 
   COLOR_STREAM_PLAYING_SELECTED = 205
   COLOR_STREAM_PAUSED_SELECTED = 206
@@ -25,6 +26,7 @@ module Zgomot::UI
   COLOR_BORDER = 201
   COLOR_CC_IDLE = 200
   COLOR_CC_ACTIVE = 199
+  COLOR_ERROR = 198
 
   module Utils
     def set_color(color, &blk)
@@ -37,7 +39,7 @@ module Zgomot::UI
   end
   class MainWindow
     class << self
-      attr_reader :globals_window, :cc_window, :str_window, :main_window
+      attr_reader :globals_window, :cc_window, :str_window, :main_window, :error_window
       def init_curses
         Curses.init_screen
         Curses.noecho
@@ -54,6 +56,7 @@ module Zgomot::UI
         Curses.init_color(COLOR_YELLOW_GREEN, 750, 980, 410)
         Curses.init_color(COLOR_LIGHT_BLUE,600, 1000, 1000)
         Curses.init_color(COLOR_ORANGE,1000 , 600, 0)
+        Curses.init_color(COLOR_RED, 750, 0, 0)
         Curses.init_pair(COLOR_GOLD,COLOR_GOLD,COLOR_BLACK)
         Curses.init_pair(COLOR_GREEN,COLOR_GREEN,COLOR_BLACK)
         Curses.init_pair(COLOR_PINK,COLOR_PINK,COLOR_BLACK)
@@ -67,11 +70,13 @@ module Zgomot::UI
         Curses.init_pair(COLOR_CC_SWITCH_FALSE,COLOR_LIGHT_BLUE,COLOR_BLACK)
         Curses.init_pair(COLOR_CC_IDLE,COLOR_VIOLET,COLOR_BLACK)
         Curses.init_pair(COLOR_CC_ACTIVE,COLOR_BLACK,COLOR_VIOLET)
+        Curses.init_pair(COLOR_ERROR,COLOR_RED,COLOR_BLACK)
       end
       def update
         globals_window.display
         cc_window.display
         str_window.display
+        error_window.display
         Curses.refresh
       end
       def poll
@@ -85,34 +90,45 @@ module Zgomot::UI
       def dash
         init_curses
         @globals_window = GlobalsWindow.new(0)
-        @cc_window = CCWindow.new(Curses.lines - CCS_TOP, CCS_TOP)
-        @str_window = StrWindow.new(GLOBALS_HEIGHT)
+        str_height = 2*(Curses.lines - GLOBALS_HEIGHT - ERROR_WINDOW_HEIGHT)/3
+        @cc_window = CCWindow.new(Curses.lines - str_height - GLOBALS_HEIGHT - ERROR_WINDOW_HEIGHT, str_height + GLOBALS_HEIGHT)
+        @str_window = StrWindow.new(str_height, GLOBALS_HEIGHT)
+        @error_window = ErrorWindow.new(Curses.lines - ERROR_WINDOW_HEIGHT)
         Curses.refresh
         poll
         loop do
-          case Curses.getch
-          when ?t
-            str_window.set_tog_mode
-            update
-          when Curses::Key::UP
-            str_window.dec_selected
-            update
-          when Curses::Key::DOWN
-            str_window.inc_selected
-            update
-          when 10
-            str_window.tog
-            update
-          when ?p
-            Zgomot::Midi::Stream.play
-            update
-          when ?s
-            Zgomot::Midi::Stream.stop
-            update
-          when ?q
-            @thread.kill
-            Curses.close_screen
-            break
+          begin
+            case Curses.getch
+            when ?t
+              str_window.tog
+              str_window.set_select_mode
+              update
+            when ?d
+              str_window.delete
+              str_window.set_select_mode
+              update
+            when Curses::Key::UP
+              str_window.dec_selected
+              update
+            when Curses::Key::DOWN
+              str_window.inc_selected
+              update
+            when 10
+              str_window.select
+              update
+            when ?p
+              Zgomot::Midi::Stream.play
+              update
+            when ?s
+              Zgomot::Midi::Stream.stop
+              update
+            when ?q
+              @thread.kill
+              Curses.close_screen
+              break
+            end
+          rescue Exception => e
+            Zgomot.set_last_error(e.message)
           end
         end
       end
@@ -122,7 +138,7 @@ module Zgomot::UI
   class GlobalsWindow
     ITEM_WIDTH = 32
     TIME_WIDTH = 15
-    attr_reader :time_window, :title_window, :input_window, :output_window, :time_signature_window,
+    attr_reader :time_window, :input_window, :output_window, :time_signature_window,
       :beats_per_minute_window, :seconds_per_beat_window, :resolution_window
     def initialize(top)
       output = Zgomot::Drivers::Mgr.output
@@ -131,7 +147,7 @@ module Zgomot::UI
       time_signature = Zgomot::Midi::Clock.time_signature
       resolution = "1/#{Zgomot::Midi::Clock.resolution.to_i}"
       seconds_per_beat = Zgomot::Midi::Clock.beat_sec.to_s
-      @title_window = TitleWindow.new('zgomot', COLOR_BORDER, 0, COLOR_PINK)
+      TitleWindow.new('zgomot', COLOR_BORDER, 0, COLOR_PINK)
       @input_window = TextWithValueWindow.new('Input', input, COLOR_BORDER, 3, 0, COLOR_IDLE)
       @output_window = TextWithValueWindow.new('Output', output, COLOR_BORDER, 4, 0, COLOR_IDLE)
       @time_signature_window = TextWithValueWindow.new('Time Signature', time_signature, COLOR_BORDER, 5, 0, COLOR_IDLE)
@@ -144,63 +160,86 @@ module Zgomot::UI
       "%#{TIME_WIDTH}s" % /(\d*:\d*)/.match(Zgomot::Midi::Dispatcher.clk).captures.first
     end
     def display
-      title_window.display
       time_window.display(time_to_s)
-      input_window.display
-      output_window.display
-      time_signature_window.display
-      beats_per_minute_window.display
-      seconds_per_beat_window.display
-      resolution_window.display
+      input_window.display(Zgomot::Drivers::Mgr.input || 'None')
+      output_window.display(Zgomot::Drivers::Mgr.output)
+      time_signature_window.display(Zgomot::Midi::Clock.time_signature)
+      beats_per_minute_window.display(Zgomot::Midi::Clock.beats_per_minute.to_i.to_s)
+      seconds_per_beat_window.display(Zgomot::Midi::Clock.beat_sec.to_s)
+      resolution_window.display("1/#{Zgomot::Midi::Clock.resolution.to_i}")
     end
   end
 
   class StrWindow
-    attr_reader :selected, :tog_mode, :window, :rows, :widths
-    def initialize(top)
-      @tog_mode, @selected = false, 0
+    attr_reader :selected, :select_mode, :window, :rows, :widths, :top, :current, :height
+    def initialize(height, top)
+      @select_mode, @selected, @top, @current, @height = false, [], top, 0, height
       @widths = Zgomot::UI::Output::STREAM_OUTPUT_FORMAT_WIDTHS
       TitleWindow.new('Streams', COLOR_BORDER, top, COLOR_BLUE)
       TableRowWindow.new(Zgomot::UI::Output::STREAM_HEADER, widths, COLOR_BORDER, top + 3, COLOR_BORDER)
       add_streams(top + 3)
     end
     def display
-      (0..streams.length-1).each do |i|
-        stream = streams[i]
-        rows[i].display(stream.info, stream_color(stream, i))
+      if streams.length == rows.length
+        (0..streams.length-1).each do |i|
+          stream = streams[i]
+          rows[i].display(stream.info, stream_color(stream, i))
+        end
+      else
+        add_streams(top + 3)
       end
     end
     def inc_selected
-      if tog_mode
-       @selected = (selected + 1) % streams.length
+      if select_mode
+       @current = (current + 1) % streams.length
       end
     end
     def dec_selected
-      if tog_mode
-        @selected = (selected - 1) % streams.length
+      if select_mode
+        @current = (current - 1) % streams.length
       end
     end
-    def set_tog_mode
-      @selected = 0
-      @tog_mode = tog_mode ? false : true
+    def select
+      if selected.include?(current)
+        @selected.delete(current)
+      else
+        @selected << current
+      end
+    end
+    def set_select_mode
+      if select_mode
+        @select_mode = false
+        @selected = []
+        @current = 0
+      else
+        @select_mode = true
+      end
     end
     def tog
-      stream = streams[selected]
-      Zgomot::Midi::Stream.tog(stream.name)
-      set_tog_mode
+      selected.each do |s|
+        stream = streams[s]
+        Zgomot::Midi::Stream.tog(stream.name)
+      end
+    end
+    def delete
+      selected.each do |s|
+        stream = streams[s]
+        Zgomot::Midi::Stream.delete(stream.name)
+      end
     end
     private
       def add_streams(top)
-        @rows = (0..streams.length-1).map do |i|
+        displayed_streams = streams.length > (height - 4) ? (height - 4) : streams.length
+        @rows = (0..displayed_streams-1).map do |i|
                   stream = streams[i]
                   TableRowWindow.new(stream.info, widths, COLOR_BORDER, top += 1, stream_color(stream, i))
                 end
-        (STREAMS_HEIGHT - streams.length - 4).times do
+        (height - displayed_streams - 4).times do
           TableRowWindow.new(nil,  widths, COLOR_BORDER, top += 1)
         end
       end
       def stream_color(stream, i)
-        if tog_mode && i == selected
+        if select_mode && (selected.include?(i) || current == i)
           stream.status_eql?(:playing) ? COLOR_STREAM_PLAYING_SELECTED : COLOR_STREAM_PAUSED_SELECTED
         else
           stream.status_eql?(:playing) ? COLOR_ACTIVE : COLOR_IDLE
@@ -212,9 +251,9 @@ module Zgomot::UI
   end
 
   class CCWindow
-    attr_reader :height, :widths, :rows
+    attr_reader :height, :widths, :rows, :top
     def initialize(height, top)
-      @height = height
+      @height, @top = height, top
       @widths = Zgomot::UI::Output::CC_OUTPUT_FORMAT_WIDTHS
       TitleWindow.new('Input CCs', COLOR_BORDER, top, COLOR_BLUE)
       TableRowWindow.new(Zgomot::UI::Output::CC_HEADER, widths, COLOR_BORDER, top + 3, COLOR_BORDER)
@@ -222,13 +261,17 @@ module Zgomot::UI
     end
     def display
       ccs = get_ccs
-      (0..ccs.length-1).each{|i| rows[i].display(ccs[i], cc_color(ccs[i]))}
+      if ccs.length == rows.length
+        (0..ccs.length-1).each{|i| rows[i].display(ccs[i], cc_color(ccs[i]))}
+      else
+        add_ccs(top + 3)
+      end
     end
     private
       def add_ccs(top)
         ccs = get_ccs
-        @rows = ccs.map do |cc_params|
-          puts cc_color(cc_params)
+        displayed_ccs = ccs.length > (height - 4) ? (height - 4) : ccs.length
+        @rows = ccs[0..(displayed_ccs-1)].map do |cc_params|
                   TableRowWindow.new(cc_params, widths, COLOR_BORDER, top += 1, cc_color(cc_params))
                 end
         (height - ccs.length - 4).times do
@@ -246,17 +289,47 @@ module Zgomot::UI
         cc_mgr = Zgomot::Midi::CC
         cc_mgr.cc_names.reduce([]){|c, cc_name| c + cc_mgr.info(cc_name)}
       end
-      def cc_color(cc)
-        COLOR_IDLE
-        if cc_type(cc).eql?('cont')
-          delta = Time.now - cc_updated_at(cc)
+      def cc_color(cc_params)
+        if cc_type(cc_params).eql?('cont')
+          delta = Time.now - cc_updated_at(cc_params)
           delta > Zgomot::Midi::Clock.beat_sec ? COLOR_CC_IDLE : COLOR_CC_ACTIVE
         else
-          cc_value(cc).eql?('true') ? COLOR_CC_SWITCH_TRUE : COLOR_CC_SWITCH_FALSE
+          cc_value(cc_params).eql?('true') ? COLOR_CC_SWITCH_TRUE : COLOR_CC_SWITCH_FALSE
         end
       end
   end
 
+  class ErrorWindow
+    include Utils
+    attr_reader :top
+    def initialize(top)
+      @top = top
+      display
+    end
+    def display
+      error_message = Zgomot.last_error
+      text, text_color = if error_message.nil?
+                           [["it's cool"], COLOR_BORDER]
+                         else
+                           [error_message.scan(/.{1,#{WIDTH-4}}/), COLOR_ERROR]
+                         end
+      set_color(COLOR_BORDER) {
+        write(top, 0, '-' * WIDTH)
+        write(top + 1, 0, '|')
+        write(top + 1, WIDTH-1, '|')
+        write(top + 2, 0, '|')
+        write(top + 2, WIDTH-1, '|')
+        write(top + 3, 0, '-' * WIDTH)
+      }
+      set_color(text_color) {
+        lines = text.length > 1 ? 2 : 1
+        lines.times{|i| write(top + 1 + i, 2, "%-#{WIDTH-4}s" % text[i])}
+        blank_width = WIDTH - 4
+        (2 - lines).times{|i| write(top + 2 - i, 2, ' ' * blank_width)}
+      }
+    end
+  end
+
   class TextWindow
     include Utils
     attr_reader :text, :top, :color, :left
@@ -336,7 +409,7 @@ module Zgomot::UI
 
   class TitleWindow
     include Utils
-    attr_reader :windows, :text, :top, :color, :text_color
+    attr_reader :text, :top, :color, :text_color
     def initialize(text, color, top, text_color = nil)
       @text_color = text_color || color
       @text, @color, @top = text, color, top