patchmaster 0.0.0 → 0.0.1

data/bin/patchmaster

@@ -1,20 +1,28 @@
 #!/usr/bin/env ruby
 #
-# usage: patchmaster [-i] [pm_file]
+# usage: patchmaster [-n] [-d] [pm_file]
 #
 # Starts PatchMaster and optionally loads pm_file.
 #
 # The -n flag tells PatchMaster to not use MIDI. All MIDI errors such as not
-# being able to connect to the MIDI devices speicified in pm_file are
+# being able to connect to the MIDI instruments specified in pm_file are
 # ignored, and no MIDI data is sent/received. That is useful if you want to
-# run PatchMaster without actually talking to any MIDI devices.
+# run PatchMaster without actually talking to any MIDI instruments.
 
+require 'optparse'
+
+use_midi = true
+OptionParser.new do |opts|
+  opts.banner = "usage: patchmaster [options] [pm_file]"
+  opts.on("-d", "--debug", "Turn on debug mode") { $DEBUG = true }
+  opts.on("-n", "--no-midi", "Turn off MIDI processing") { use_midi = false }
+end.parse!(ARGV)
+
+# Must require patchmaster here, after handling options, because Singleton
+# initialze code checks $DEBUG.
 require 'patchmaster'
 
-pm = PM::Main.instance
-if ARGV[0] == '-n'
-  pm.no_midi!
-  ARGV.shift
-end
-pm.load(ARGV[0]) if ARGV[0]
-pm.run
+app = PM::Main.instance
+app.no_midi! if !use_midi
+app.load(ARGV[0]) if ARGV[0]
+app.run

data/lib/patchmaster.rb

@@ -5,11 +5,8 @@ require 'patchmaster/song'
 require 'patchmaster/patch'
 require 'patchmaster/connection'
 require 'patchmaster/filter'
-require 'patchmaster/io'
+require 'patchmaster/instrument'
 require 'patchmaster/patchmaster'
+require 'patchmaster/trigger'
 require 'patchmaster/dsl'
 require 'patchmaster/app/main'
-
-def message(str)
-  PM::Main.instance.message(str)
-end

data/lib/patchmaster/app/info_window.rb

@@ -7,12 +7,13 @@ class InfoWindow
 
   include Curses
 
-  attr_reader :win
+  attr_reader :win, :text
 
   TITLE = ' PatchMaster '
 
   def initialize(rows, cols, row, col)
     @win = Window.new(rows, cols, row, col)
+    @text = IO.read(CONTENTS)
   end
 
   def draw
@@ -21,7 +22,7 @@ class InfoWindow
       @win.addstr(TITLE)
     }
     @win.addstr("\n")
-    IO.foreach(CONTENTS) { |line| @win.addstr(line) }
+    @text.each_line { |line| @win.addstr(line) }
   end
 
   def refresh

data/lib/patchmaster/app/info_window_contents.txt

@@ -1,7 +1,7 @@
-j, down  - next patch
-k, up    - prev patch
-n, left  - next song
-p, right - prev song
+j, down, space  - next patch
+k, up           - prev patch
+n, left         - next song
+p, right        - prev song
 
 g   - goto song
 t   - goto song list
@@ -11,5 +11,6 @@ F1  - help
 
 l   - load
 s   - save
+e   - edit
 
 q   - quit

data/lib/patchmaster/app/list_window.rb

@@ -5,8 +5,10 @@ class ListWindow < PmWindow
 
   attr_reader :list
 
-  def set_contents(title, list)
-    @title, @list = title, list
+  # +curr_item_method_sym+ is a method symbol that is sent to
+  # PM::PatchMaster to obtain the current item so we can highlight it.
+  def set_contents(title, list, curr_item_method_sym)
+    @title, @list, @curr_item_method_sym = title, list, curr_item_method_sym
     draw
   end
 
@@ -14,11 +16,12 @@ class ListWindow < PmWindow
     super
     return unless @list
 
+    curr_item = PM::PatchMaster.instance.send(@curr_item_method_sym)
     @list.each_with_index do |thing, i|
       @win.setpos(i+1, 1)
-      @win.attron(A_REVERSE) if thing == @list.curr
+      @win.attron(A_REVERSE) if thing == curr_item
       @win.addstr(make_fit(" #{thing.name} "))
-      @win.attroff(A_REVERSE) if thing == @list.curr
+      @win.attroff(A_REVERSE) if thing == curr_item
     end
   end
 

data/lib/patchmaster/app/main.rb

@@ -1,13 +1,11 @@
 require 'curses'
 require 'singleton'
-%w(list patch info prompt).each { |w| require "patchmaster/app/#{w}_window" }
+%w(list patch info trigger prompt).each { |w| require "patchmaster/app/#{w}_window" }
 
 module PM
 
 class Main
 
-  DEBUG_FILE = '/tmp/pm_debug.txt'
-
   include Singleton
   include Curses
 
@@ -19,20 +17,15 @@ class Main
     @pm.no_midi!
   end
 
-  # File must be a Ruby file that returns an array of song lists.
   def load(file)
     @pm.load(file)
   end
 
   def run
-    if $DEBUG
-      @debug_file = File.open(DEBUG_FILE, 'a')
-    end
     @pm.start
     begin
       config_curses
       create_windows
-      message("Welcome to PatchMaster")
 
       loop do
         begin
@@ -40,55 +33,68 @@ class Main
           ch = getch
           message("ch = #{ch}") if $DEBUG
           case ch
-          when ?j, Key::DOWN
+          when 'j', Key::DOWN, ' '
             @pm.next_patch
-          when ?k, Key::UP
+          when 'k', Key::UP
             @pm.prev_patch
-          when ?n, Key::LEFT
+          when 'n', Key::LEFT
             @pm.next_song
-          when ?p, Key::RIGHT
+          when 'p', Key::RIGHT
             @pm.prev_song
-          when ?g
+          when 'g'
             name = PromptWindow.new('Go To Song', 'Go to song:').gets
             @pm.goto_song(name)
-          when ?t
+          when 't'
             name = PromptWindow.new('Go To Song List', 'Go to Song List:').gets
             @pm.goto_song_list(name)
+          when 'e'
+            close_screen
+            @pm.edit
           when Key::F1
             help
-          when 27               # escape
-            @pm.panic
+          when 27        # "\e" doesn't work here
+            # Twice in a row sends individual note-off commands
+            message('Sending panic note off messages...')
+            @pm.panic(@prev_cmd == 27)
             message('Panic sent')
-          when ?l
+          when 'l'
             file = PromptWindow.new('Load', 'Load file:').gets
             begin
               @pm.load(file)
+              message("Loaded #{file}")
             rescue => ex
               message(ex.to_s)
             end
-          when ?s
+          when 's'
             file = PromptWindow.new('Save', 'Save into file:').gets
             begin
               @pm.save(file)
+              message("Saved #{file}")
             rescue => ex
               message(ex.to_s)
             end
-          when ?q
+          when '?'
+            if $DEBUG
+              require 'pp'
+              out = ''
+              str = pp(@pm, out)
+              message("pm = #{out}")
+            end
+          when 'q'
             break
           end
+          @prev_cmd = ch
         rescue => ex
           message(ex.to_s)
-          if $DEBUG
-            @debug_file.puts caller.join("\n")
-          end
+          @pm.debug caller.join("\n")
         end
       end
     ensure
+      clear
+      refresh
       close_screen
       @pm.stop
-      if $DEBUG
-        @debug_file.close
-      end
+      @pm.close_debug_file
     end
   end
 
@@ -109,14 +115,22 @@ class Main
     sl_height = top_height - sls_height
     
     @song_lists_win = ListWindow.new(sls_height, top_width, 0, 0, nil)
-    @song_lists_win.set_contents('Song Lists', @pm.song_lists)
     @song_list_win = ListWindow.new(sl_height, top_width, sls_height, 0, 'Song List')
     @song_win = ListWindow.new(top_height, top_width, 0, top_width, 'Song')
     @patch_win = PatchWindow.new(bot_height, cols(), top_height, 0, 'Patch')
     @message_win = Window.new(1, cols(), lines()-1, 0)
+    @message_win.scrollok(false)
+
+    third_height = top_height / 3
+    width = cols() - (top_width * 2) - 1
+    left = top_width * 2 + 1
 
-    @info_win = InfoWindow.new(top_height, cols() - (top_width * 2) - 1, 0, top_width * 2 + 1)
+    @trigger_win = TriggerWindow.new(third_height, width, third_height * 2, left)
+    @trigger_win.draw
+
+    @info_win = InfoWindow.new(third_height * 2, width, 0, left)
     @info_win.draw
+
   end
 
   def help
@@ -131,28 +145,29 @@ class Main
     else
       $stderr.puts str
     end
-    if $DEBUG
-      @debug_file.puts "#{Time.now} #{str}"
-      @debug_file.flush
-    end
+    @pm.debug "#{Time.now} #{str}"
   end
 
   def refresh_all
     set_window_data
-    [@song_lists_win, @song_list_win, @song_win, @patch_win].map(&:draw)
-    [stdscr, @song_lists_win, @song_list_win, @song_win, @info_win, @patch_win, @message_win].map(&:refresh)
+    wins = [@song_lists_win, @song_list_win, @song_win, @patch_win, @info_win, @trigger_win]
+    wins.map(&:draw)
+    ([stdscr] + wins).map(&:refresh)
   end
 
   def set_window_data
-    song_list = @pm.curr_song_list
-    @song_list_win.set_contents(song_list.name, song_list.songs)
-    song = song_list.curr_song
+    @song_lists_win.set_contents('Song Lists', @pm.song_lists, :song_list)
+
+    song_list = @pm.song_list
+    @song_list_win.set_contents(song_list.name, song_list.songs, :song)
+
+    song = @pm.song
     if song
-      @song_win.set_contents(song.name, song.patches)
-      patch = song.curr_patch
+      @song_win.set_contents(song.name, song.patches, :patch)
+      patch = @pm.patch
       @patch_win.patch = patch
     else
-      @song_win.set_contents(nil, nil)
+      @song_win.set_contents(nil, nil, :patch)
       @patch_win.patch = nil
     end
   end

data/lib/patchmaster/app/trigger_window.rb

@@ -0,0 +1,27 @@
+require 'curses'
+
+module PM
+class TriggerWindow < PmWindow
+
+  include Curses
+
+  def initialize(rows, cols, row, col)
+    super(rows, cols, row, col, nil)
+    @title = 'Triggers '
+  end
+
+  def draw
+    super
+    pm = PM::PatchMaster.instance
+    i = 0
+    pm.inputs.each do |sym, instrument|
+      instrument.triggers.each do |trigger|
+        @win.setpos(i+1, 1)
+        @win.addstr(make_fit(":#{sym} #{trigger.to_s}"))
+        i += 1
+      end
+    end
+  end
+end
+end
+

data/lib/patchmaster/connection.rb

@@ -2,9 +2,10 @@ require 'patchmaster/consts'
 
 module PM
 
-# A Connection connects an InputDevice to an OutputDevice. Whenever MIDI
-# data arrives at the InputDevice it is optionally modified or filtered,
-# then the remaining modified data is sent to the OutputDevice.
+# A Connection connects an InputInstrument to an OutputInstrument. Whenever
+# MIDI data arrives at the InputInstrument it is optionally modified or
+# filtered, then the remaining modified data is sent to the
+# OutputInstrument.
 class Connection
 
   attr_accessor :input, :input_chan, :output, :output_chan,
@@ -24,19 +25,20 @@ class Connection
   end
 
   def start(start_bytes=nil)
-    midi_out(@output, start_bytes) if start_bytes
-    midi_out(@output, [PROGRAM_CHANGE + @output_chan, @pc_prog]) if pc?
+    midi_out(start_bytes) if start_bytes
+    midi_out([PROGRAM_CHANGE + @output_chan, @pc_prog]) if pc?
     @input.add_connection(self)
   end
 
-  def stop
+  def stop(stop_bytes=nil)
+    midi_out(stop_bytes) if stop_bytes
     @input.remove_connection(self)
   end
 
   def accept_from_input?(bytes)
     return true if @input_chan == nil
-    return true if bytes[0] >= 0xf0
-    (bytes[0] & 0xf0) >= 0x80 && (bytes[0] & 0x0f) == @input_chan
+    return true unless bytes.channel?
+    bytes.note? && bytes.channel == @input_chan
   end
 
   # Returns true if the +@zone+ is nil (allowing all notes throught) or if
@@ -48,8 +50,8 @@ class Connection
   def midi_in(bytes)
     return unless accept_from_input?(bytes)
 
-    # TODO handle running bytes
-    high_nibble = bytes[0] & 0xf0
+    # TODO handle running bytes if needed
+    high_nibble = bytes.high_nibble
     case high_nibble
     when NOTE_ON, NOTE_OFF, POLY_PRESSURE
       return unless inside_zone?(bytes[1])
@@ -61,12 +63,12 @@ class Connection
 
     bytes = @filter.call(self, bytes) if @filter
     if bytes && bytes.size > 0
-      midi_out(@output, bytes)
+      midi_out(bytes)
     end
   end
 
-  def midi_out(device, bytes)
-    device.midi_out(bytes)
+  def midi_out(bytes)
+    @output.midi_out(bytes)
   end
 
   def pc?

data/lib/patchmaster/cursor.rb

@@ -0,0 +1,174 @@
+module PM
+
+# A PM::Cursor knows the current PM::SongList, PM::Song, and PM::Patch, how
+# to move between songs and patches, and how to find them given name
+# regexes. A Cursor does not start/stop patches or manage connections.
+class Cursor
+
+  attr_reader :song_list, :song, :patch
+
+  def initialize(pm)
+    @pm = pm
+    clear
+  end
+
+  # Set @song_list, @song, and @patch to +nil+.
+  def clear
+    @song_list = @song = @patch = nil
+    # Do not erase names saved by #mark.
+  end
+
+  # Set @song_list to All Songs, @song to first song, and
+  # @patch to song's first patch. Song and patch may be +nil+.
+  def init
+    @song_list = @pm.song_lists.first
+    @song = @song_list.songs.first
+    if @song
+      @patch = @song.patches.first
+    else
+      @patch = nil
+    end
+  end
+
+  def next_song
+    return unless @song_list
+    return if @song_list.songs.last == @song
+
+    @patch.stop if @patch
+    @song = @song_list.songs[@song_list.songs.index(@song) + 1]
+    @patch = @song.patches.first
+    @patch.start
+  end
+
+  def prev_song
+    return unless @song_list
+    return if @song_list.songs.first == @song
+
+    @patch.stop if @patch
+    @song = @song_list.songs[@song_list.songs.index(@song) - 1]
+    @patch = @song.patches.first
+    @patch.start
+  end
+
+  def next_patch
+    return unless @song
+    if @song.patches.last == @patch
+      next_song
+    elsif @patch
+      @patch.stop
+      @patch = @song.patches[@song.patches.index(@patch) + 1]
+      @patch.start
+    end
+  end
+
+  def prev_patch
+    return unless @song
+    if @song.patches.first == @patch
+      prev_song
+    elsif @patch
+      @patch.stop
+      @patch = @song.patches[@song.patches.index(@patch) - 1]
+      @patch.start
+    end
+  end
+
+  def goto_song(name_regex)
+    new_song_list = new_song = new_patch = nil
+    new_song = @song_list.find(name_regex) if @song_list
+    new_song = @@pm.all_songs.find(name_regex) unless new_song
+    new_patch = new_song ? new_song.patches.first : nil
+
+    if (new_song && new_song != @song) || # moved to new song
+        (new_song == @song && @patch != new_patch) # same song but not at same first patch
+
+      @patch.stop if @patch
+
+      if @song_list.songs.include?(new_song)
+        new_song_list = @song_list
+      else
+        # Not found in current song list. Switch to @pm.all_songs list.
+        new_song_list = @@pm.all_songs
+      end
+
+      @song_list = new_song_list
+      @song = new_song
+      @patch = new_patch
+      @patch.start
+    end
+  end
+
+  def goto_song_list(name_regex)
+    name_regex = Regexp.new(name_regex.to_s, true) # make case-insensitive
+    new_song_list = @pm.song_lists.detect { |song_list| song_list.name =~ name_regex }
+    return unless new_song_list
+
+    @song_list = new_song_list
+
+    new_song = @song_list.songs.first
+    new_patch = new_song ? new_song.patches.first : nil
+
+    if new_patch != @patch
+      @patch.stop if @patch
+      new_patch.start if new_patch
+    end
+    @song = new_song
+    @patch = new_patch
+  end
+
+  # Remembers the names of the current song list, song, and patch.
+  # Used by #restore.
+  def mark
+    @song_list_name = @song_list ? @song_list.name : nil
+    @song_name = @song ? @song.name : nil
+    @patch_name = @patch ? @patch.name : nil
+  end
+
+  # Using the names saved by #save, try to find them now.
+  #
+  # Since names can change we use Damerau-Levenshtein distance on lowercase
+  # versions of all strings.
+  def restore
+    return unless @song_list_name   # will be nil on initial load
+
+    @song_list = find_nearest_match(@pm.song_lists, @song_list_name) || @pm.all_songs
+    @song = find_nearest_match(@song_list.songs, @song_name) || @song_list.songs.first
+    if @song
+      @patch = find_nearest_match(@song.patches, @patch_name) || @song.patches.first
+    else
+      @patch = nil
+    end
+  end
+
+  # List must contain objects that respond to #name. If +str+ is nil or
+  # +list+ is +nil+ or empty then +nil+ is returned.
+  def find_nearest_match(list, str)
+    return nil unless str && list && !list.empty?
+
+    str = str.downcase
+    distances = list.collect { |item| dameraulevenshtein(str, item.name.downcase) }
+    min_distance = distances.min
+    list[distances.index(distances.min)]
+  end
+
+  # https://gist.github.com/182759 (git://gist.github.com/182759.git)
+  # Referenced from http://en.wikipedia.org/wiki/Damerau%E2%80%93Levenshtein_distance
+  def dameraulevenshtein(seq1, seq2)
+    oneago = nil
+    thisrow = (1..seq2.size).to_a + [0]
+    seq1.size.times do |x|
+      twoago, oneago, thisrow = oneago, thisrow, [0] * seq2.size + [x + 1]
+      seq2.size.times do |y|
+        delcost = oneago[y] + 1
+        addcost = thisrow[y - 1] + 1
+        subcost = oneago[y - 1] + ((seq1[x] != seq2[y]) ? 1 : 0)
+        thisrow[y] = [delcost, addcost, subcost].min
+        if (x > 0 and y > 0 and seq1[x] == seq2[y-1] and seq1[x-1] == seq2[y] and seq1[x] != seq2[y])
+          thisrow[y] = [thisrow[y], twoago[y-2] + 1].min
+        end
+      end
+    end
+    return thisrow[seq2.size - 1]
+  end
+
+end
+end