patchmaster 0.0.3 → 0.0.4

data/bin/patchmaster

@@ -12,17 +12,20 @@
 require 'optparse'
 
 use_midi = true
+use_gui = 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 }
+  opts.on("-t", "--text", "--nw", "--no-window", "No windows") { use_gui = false }
 end.parse!(ARGV)
 
 # Must require patchmaster here, after handling options, because Singleton
-# initialze code checks $DEBUG.
+# initialize code checks $DEBUG.
 require 'patchmaster'
 
-app = PM::Main.instance
+app = use_gui ? PM::Main.instance : PM::PatchMaster.instance
+app.no_gui! if !use_gui
 app.no_midi! if !use_midi
 app.load(ARGV[0]) if ARGV[0]
 app.run

data/lib/patchmaster/app/info_window_contents.txt

@@ -6,8 +6,8 @@ p, right        - prev song
 g   - goto song
 t   - goto song list
 
+h   - help
 ESC - panic
-F1  - help
 
 l   - load
 s   - save

data/lib/patchmaster/app/main.rb

@@ -9,18 +9,21 @@ class Main
   include Singleton
   include Curses
 
+  FUNCTION_KEY_SYMBOLS = {}
+  12.times do |i|
+    FUNCTION_KEY_SYMBOLS["f#{i+1}".to_sym] = Key::F1 + i
+    FUNCTION_KEY_SYMBOLS["F#{i+1}".to_sym] = Key::F1 + i
+  end
+
   def initialize
     @pm = PatchMaster.instance
+    @message_bindings = {}
   end
 
   def no_midi!
     @pm.no_midi!
   end
 
-  def load(file)
-    @pm.load(file)
-  end
-
   def run
     @pm.start
     begin
@@ -49,8 +52,9 @@ class Main
             @pm.goto_song_list(name)
           when 'e'
             close_screen
-            @pm.edit
-          when Key::F1
+            file = @loaded_file || PromptWindow.new('Edit', 'Edit file:').gets
+            edit(file)
+          when 'h'
             help
           when 27        # "\e" doesn't work here
             # Twice in a row sends individual note-off commands
@@ -60,7 +64,7 @@ class Main
           when 'l'
             file = PromptWindow.new('Load', 'Load file:').gets
             begin
-              @pm.load(file)
+              load(file)
               message("Loaded #{file}")
             rescue => ex
               message(ex.to_s)
@@ -68,7 +72,7 @@ class Main
           when 's'
             file = PromptWindow.new('Save', 'Save into file:').gets
             begin
-              @pm.save(file)
+              save(file)
               message("Saved #{file}")
             rescue => ex
               message(ex.to_s)
@@ -88,6 +92,9 @@ class Main
           message(ex.to_s)
           @pm.debug caller.join("\n")
         end
+
+        msg_name = @message_bindings[ch]
+        @pm.send_message(msg_name) if msg_name
       end
     ensure
       clear
@@ -98,6 +105,10 @@ class Main
     end
   end
 
+  def bind_message(name, key_sym)
+    @message_bindings[FUNCTION_KEY_SYMBOLS[key_sym]] = name
+  end
+
   def config_curses
     init_screen
     cbreak                      # unbuffered input
@@ -133,6 +144,40 @@ class Main
 
   end
 
+  def load(file)
+    @pm.load(file)
+    @loaded_file = file
+  end
+
+  def save(file)
+    @pm.save(file)
+    @loaded_file = file
+  end
+
+  # Opens the most recently loaded/saved file name in an editor. After
+  # editing, the file is re-loaded.
+  def edit(file)
+    editor_command = find_editor
+    unless editor_command
+      message("Can not find $VISUAL, $EDITOR, vim, or vi on your path")
+      return
+    end
+
+    cmd = "#{editor_command} #{file}"
+    @pm.debug(cmd)
+    system(cmd)
+    load(file)
+    @loaded_file = file
+  end
+
+  # Return the first legit command from $VISUAL, $EDITOR, vim, vi, and
+  # notepad.exe.
+  def find_editor
+    @editor ||= [ENV['VISUAL'], ENV['EDITOR'], 'vim', 'vi', 'notepad.exe'].compact.detect do |cmd|
+      system('which', cmd) || File.exist?(cmd)
+    end
+  end
+
   def help
     message("Help: not yet implemented")
   end

data/lib/patchmaster/app/trigger_window.rb

@@ -14,10 +14,10 @@ class TriggerWindow < PmWindow
     super
     pm = PM::PatchMaster.instance
     i = 0
-    pm.inputs.each do |sym, instrument|
+    pm.inputs.each do |instrument|
       instrument.triggers.each do |trigger|
         @win.setpos(i+1, 1)
-        @win.addstr(make_fit(":#{sym} #{trigger.to_s}"))
+        @win.addstr(make_fit(":#{instrument.sym} #{trigger.to_s}"))
         i += 1
       end
     end

data/lib/patchmaster/dsl.rb

@@ -14,6 +14,8 @@ class DSL
 
   def load(file)
     contents = IO.read(file)
+    @inputs = {}
+    @outputs = {}
     @triggers = []
     @filters = []
     @songs = {}                 # key = name, value = song
@@ -23,21 +25,39 @@ class DSL
   end
 
   def input(port_num, sym, name=nil)
-    @pm.inputs[sym] = InputInstrument.new(name || sym.to_s, port_num, @no_midi)
+    raise "input: two inputs can not have the same symbol (:#{sym})" if @inputs[sym]
+
+    input = InputInstrument.new(sym, name, port_num, @no_midi)
+    @inputs[sym] = input
+    @pm.inputs << input
   rescue => ex
     raise "input: error creating input instrument \"#{name}\" on input port #{port_num}: #{ex}"
   end
   alias_method :in, :input
 
   def output(port_num, sym, name=nil)
-    @pm.outputs[sym] = OutputInstrument.new(name || sym.to_s, port_num, @no_midi)
+    raise "output: two outputs can not have the same symbol (:#{sym})" if @outputs[sym]
+
+    output = OutputInstrument.new(sym, name, port_num, @no_midi)
+    @outputs[sym] = output
+    @pm.outputs << output
   rescue => ex
     raise "output: error creating output instrument \"#{name}\" on output port #{port_num}: #{ex}"
   end
   alias_method :out, :output
 
+  def message(name, bytes)
+    @pm.messages[name] = bytes
+  end
+
+  def message_key(name, key_sym)
+    if !@pm.no_gui              # TODO get rid of double negative
+      PM::Main.instance.bind_message(name, key_sym)
+    end
+  end
+
   def trigger(instrument_sym, bytes, &block)
-    instrument = @pm.inputs[instrument_sym]
+    instrument = @inputs[instrument_sym]
     raise "trigger: error finding instrument #{instrument_sym}" unless instrument
     t = Trigger.new(bytes, block)
     instrument.triggers << t
@@ -65,10 +85,10 @@ class DSL
   end
 
   def connection(in_sym, in_chan, out_sym, out_chan)
-    input = @pm.inputs[in_sym]
+    input = @inputs[in_sym]
     in_chan = nil if in_chan == :all || in_chan == :any
     raise "can't find input instrument #{in_sym}" unless input
-    output = @pm.outputs[out_sym]
+    output = @outputs[out_sym]
     raise "can't find outputput instrument #{out_sym}" unless output
 
     @conn = Connection.new(input, in_chan, output, out_chan)
@@ -130,19 +150,19 @@ class DSL
   end
 
   def save_instruments(f)
-    @pm.inputs.each do |sym, instr|
-      f.puts "input #{instr.port_num}, :#{sym}, #{quoted(instr.name)}"
+    @pm.inputs.each do |instr|
+      f.puts "input #{instr.port_num}, :#{instr.sym}, #{quoted(instr.name)}"
     end
-    @pm.outputs.each do |sym, instr|
-      f.puts "output #{instr.port_num}, :#{sym}, #{quoted(instr.name)}"
+    @pm.outputs.each do |instr|
+      f.puts "output #{instr.port_num}, :#{instr.sym}, #{quoted(instr.name)}"
     end
     f.puts
   end
 
   def save_triggers(f)
-    @pm.inputs.each do |sym, instrument|
+    @pm.inputs.each do |instrument|
       instrument.triggers.each do |trigger|
-        str = "trigger :#{sym}, #{trigger.bytes.inspect} #{trigger.text}"
+        str = "trigger :#{instrument.sym}, #{trigger.bytes.inspect} #{trigger.text}"
         f.puts str
       end
     end
@@ -166,11 +186,9 @@ class DSL
   end
 
   def save_connection(f, conn)
-    in_sym = @pm.inputs.key(conn.input)
     in_chan = conn.input_chan ? conn.input_chan + 1 : 'nil'
-    out_sym = @pm.outputs.key(conn.output)
     out_chan = conn.output_chan + 1
-    f.puts "    conn :#{in_sym}, #{in_chan}, :#{out_sym}, #{out_chan} do"
+    f.puts "    conn :#{conn.input.sym}, #{in_chan}, :#{conn.output.sym}, #{out_chan} do"
     f.puts "      prog_chg #{conn.pc_prog}" if conn.pc?
     f.puts "      zone #{conn.note_num_to_name(conn.zone.begin)}, #{conn.note_num_to_name(conn.zone.end)}" if conn.zone
     f.puts "      xpose #{conn.xpose}" if conn.xpose
@@ -197,22 +215,6 @@ class DSL
 
   private
 
-  def input_port(port)
-    if @no_midi
-      MockInputPort.new
-    else
-      UniMIDI::Input.all[port].open
-    end
-  end
-
-  def output_port(port)
-    if @no_midi
-      MockOutputPort.new
-    else
-      UniMIDI::Output.all[port].open
-    end
-  end
-
   def read_triggers(contents)
     read_block_text('trigger', @triggers, contents)
   end

data/lib/patchmaster/instrument.rb

@@ -5,10 +5,11 @@ module PM
 
 class Instrument
 
-  attr_reader :name, :port_num, :port
+  attr_reader :sym, :name, :port_num, :port
 
-  def initialize(name, port_num, port)
-    @name, @port_num, @port = name, port_num, port
+  def initialize(sym, name, port_num, port)
+    @sym, @name, @port_num, @port = sym, name, port_num, port
+    @name ||= @port.name if @port
   end
 
 end
@@ -21,8 +22,8 @@ class InputInstrument < Instrument
   attr_reader :listener
 
   # If +port+ is nil (the normal case), creates either a real or a mock port
-  def initialize(name, port_num, no_midi=false)
-    super(name, port_num, input_port(port_num, no_midi))
+  def initialize(sym, name, port_num, no_midi=false)
+    super(sym, name, port_num, input_port(port_num, no_midi))
     @connections = []
     @triggers = []
   end
@@ -46,7 +47,10 @@ class InputInstrument < Instrument
   def stop
     PatchMaster.instance.debug("instrument #{name} stop")
     @port.clear_buffer
-    @listener.close
+    if @listener
+      @listener.close
+      @listener = nil
+    end
   end
 
   # Passes MIDI bytes on to triggers and to each output connection.
@@ -59,7 +63,7 @@ class InputInstrument < Instrument
 
   def input_port(port_num, no_midi=false)
     if no_midi
-      MockInputPort.new
+      MockInputPort.new(port_num)
     else
       UniMIDI::Input.all[port_num].open
     end
@@ -69,8 +73,8 @@ end
 
 class OutputInstrument < Instrument
 
-  def initialize(name, port_num, no_midi=false)
-    super(name, port_num, output_port(port_num, no_midi))
+  def initialize(sym, name, port_num, no_midi=false)
+    super(sym, name, port_num, output_port(port_num, no_midi))
   end
 
   def midi_out(bytes)
@@ -81,7 +85,7 @@ class OutputInstrument < Instrument
 
   def output_port(port_num, no_midi)
     if no_midi
-      MockOutputPort.new
+      MockOutputPort.new(port_num)
     else
       UniMIDI::Output.all[port_num].open
     end
@@ -90,12 +94,16 @@ end
 
 class MockInputPort
 
+  attr_reader :name
+
   # For MIDIEye::Listener
   def self.is_compatible?(input)
     true
   end
 
-  def initialize(_=nil)
+  # Constructor param is ignored; it's required by MIDIEye.
+  def initialize(arg)
+    @name = "MockInputPort #{arg}"
   end
 
   def gets
@@ -115,6 +123,13 @@ class MockInputPort
 end
 
 class MockOutputPort
+
+  attr_reader :name
+
+  def initialize(port_num)
+    @name = "MockOutputPort #{port_num}"
+  end
+
   def puts(data)
   end
 end

data/lib/patchmaster/patchmaster.rb

@@ -20,7 +20,9 @@ class PatchMaster < SimpleDelegator
 
   include Singleton
 
-  attr_reader :inputs, :outputs, :all_songs, :song_lists, :no_midi
+  attr_reader :inputs, :outputs, :all_songs, :song_lists
+  attr_reader :messages
+  attr_reader :no_midi, :no_gui
 
   # A Cursor to which we delegate incoming position methods (#song_list,
   # #song, #patch, #next_song, #prev_patch, etc.)
@@ -29,11 +31,12 @@ class PatchMaster < SimpleDelegator
   def initialize
     @cursor = Cursor.new(self)
     super(@cursor)
+    @no_midi = false
+    @no_gui = false
 
     if $DEBUG
       @debug_file = File.open(DEBUG_FILE, 'a')
     end
-    @no_midi = false
 
     init_data
   end
@@ -42,6 +45,10 @@ class PatchMaster < SimpleDelegator
     @no_midi = true
   end
 
+  def no_gui!
+    @no_gui = true
+  end
+
   # Loads +file+. Does its best to restore the current song list, song, and
   # patch after loading.
   def load(file)
@@ -51,7 +58,6 @@ class PatchMaster < SimpleDelegator
     @cursor.mark
     init_data
     DSL.new(@no_midi).load(file)
-    @loaded_file = file
     @cursor.restore
 
     if restart
@@ -65,7 +71,6 @@ class PatchMaster < SimpleDelegator
 
   def save(file)
     DSL.new(@no_midi).save(file)
-    @loaded_file = file
   rescue => ex
     raise("error saving #{file}: #{ex}" + caller.join("\n"))
   end
@@ -73,11 +78,12 @@ class PatchMaster < SimpleDelegator
   # Initializes the cursor and all data.
   def init_data
     @cursor.clear
-    @inputs = {}
-    @outputs = {}
+    @inputs = []
+    @outputs = []
     @song_lists = []
     @all_songs = SortedSongList.new('All Songs')
     @song_lists << @all_songs
+    @messages = {}
   end
 
   # If +init_cursor+ is +true+ (the default), initializes current song list,
@@ -86,25 +92,55 @@ class PatchMaster < SimpleDelegator
     @cursor.init if init_cursor
     @cursor.patch.start if @cursor.patch
     @running = true
-    @inputs.values.map(&:start)
+    @inputs.map(&:start)
   end
 
+  # Stop everything, including input instruments' MIDIEye listener threads.
   def stop
     @cursor.patch.stop if @cursor.patch
-    @inputs.values.map(&:stop)
+    @inputs.map(&:stop)
     @running = false
   end
 
+  # Run PatchMaster without the GUI. Don't use this when using PM::Main.
+  #
+  # Call #start, wait for inputs' MIDIEye listener threads to finish, then
+  # call #stop. Note that normally nothing stops those threads, so this is
+  # used as a way to make sure the script doesn't quit until killed by
+  # something like SIGINT.
+  def run
+    start(true)
+    @inputs.each { |input| input.listener.join }
+    stop
+  end
+
   def running?
     @running
   end
 
+  # Send the message with the given name to all outputs.
+  def send_message(name)
+    msg = @messages[name]
+    if !msg
+      message("Message \"#{name}\" not found")
+      return
+    end
+
+    debug("Sending message \"#{name}\"")
+    @outputs.each { |out| out.midi_out(msg) }
+
+    # If the user accidentally calls send_message in a filter at the end,
+    # then the filter will return whatever this method returns. Just in
+    # case, return nil instead of whatever the preceding code would return.
+    nil
+  end
+
   # Sends the +CM_ALL_NOTES_OFF+ controller message to all output
   # instruments on all 16 MIDI channels. If +individual_notes+ is +true+
   # send individual +NOTE_OFF+ messages to all notes as well.
   def panic(individual_notes=false)
     debug("panic(#{individual_notes})")
-    @outputs.values.each do |out|
+    @outputs.each do |out|
       MIDI_CHANNELS.times do |chan|
         out.midi_out([CONTROLLER + chan, CM_ALL_NOTES_OFF, 0])
         if individual_notes
@@ -114,29 +150,6 @@ class PatchMaster < SimpleDelegator
     end
   end
 
-  # Opens the most recently loaded/saved file name in an editor. After
-  # editing, the file is re-loaded.
-  def edit
-    editor_command = find_editor
-    unless editor_command
-      message("Can not find $VISUAL, $EDITOR, vim, or vi on your path")
-      return
-    end
-
-    cmd = "#{editor_command} #{@loaded_file}"
-    debug(cmd)
-    system(cmd)
-    load(@loaded_file)
-  end
-
-  # Return the first legit command from $VISUAL, $EDITOR, vim, vi, and
-  # notepad.exe.
-  def find_editor
-    @editor ||= [ENV['VISUAL'], ENV['EDITOR'], 'vim', 'vi', 'notepad.exe'].compact.detect do |cmd|
-      system('which', cmd) || File.exist?(cmd)
-    end
-  end
-
   # Output +str+ to @debug_file or $stderr.
   def debug(str)
     return unless $DEBUG

data/lib/patchmaster/predicates.rb

@@ -62,6 +62,11 @@ class Integer
   alias_method :rt?, :realtime?
 end
 
+# All the methods here delegate to the first byte in the array, so for
+# example the following two are equivalent:
+#
+#   my_array.note_on?
+#   my_array[0].note_on?
 class Array
 
   def high_nibble

data/test/test_helper.rb

@@ -7,19 +7,15 @@ PM::PatchMaster.instance.no_midi!
 
 module PM
 
-# To help with testing, we replace MockInputPort#gets and
-# MockOutputPort#puts with versions that send what we want and save what is
-# received.
+# To help with testing, we replace PM::MockInputPort#gets and
+# PM::MockOutputPort#puts with versions that send what we want and save what
+# is received.
 class MockInputPort
 
   attr_accessor :data_to_send
-    
-  # For MIDIEye::Listener
-  def self.is_compatible?(input)
-    true
-  end
 
-  def initialize(_=nil)
+  def initialize(arg)
+    @name = "MockInputPort #{arg}"
     @t0 = (Time.now.to_f * 1000).to_i
   end
 
@@ -28,20 +24,14 @@ class MockInputPort
     @data_to_send = []
     [{:data => retval, :timestamp => (Time.now.to_f * 1000).to_i - @t0}]
   end
-    
-  def poll
-    yield gets
-  end
-
-  # add this class to the Listener class' known input types
-  MIDIEye::Listener.input_types << self 
 end
 
 class MockOutputPort
 
   attr_accessor :buffer
 
-  def initialize
+  def initialize(port_num)
+    @name = "MockOutputPort #{port_num}"
     @buffer = []
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: patchmaster
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-09 00:00:00.000000000 Z
+date: 2012-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: unimidi
-  requirement: &2156042600 !ruby/object:Gem::Requirement
+  name: midi-eye
+  requirement: &2156041300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2156042600
+  version_requirements: *2156041300
 description: ! 'PatchMaster is realtime MIDI performance software that alloweds a
   musician