patchmaster 0.0.0

data/bin/patchmaster

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+#
+# usage: patchmaster [-i] [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
+# ignored, and no MIDI data is sent/received. That is useful if you want to
+# run PatchMaster without actually talking to any MIDI devices.
+
+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

data/lib/patchmaster.rb

@@ -0,0 +1,15 @@
+require 'patchmaster/consts'
+require 'patchmaster/predicates'
+require 'patchmaster/song_list'
+require 'patchmaster/song'
+require 'patchmaster/patch'
+require 'patchmaster/connection'
+require 'patchmaster/filter'
+require 'patchmaster/io'
+require 'patchmaster/patchmaster'
+require 'patchmaster/dsl'
+require 'patchmaster/app/main'
+
+def message(str)
+  PM::Main.instance.message(str)
+end

data/lib/patchmaster/app/info_window.rb

@@ -0,0 +1,32 @@
+require 'curses'
+
+module PM
+class InfoWindow
+
+  CONTENTS = File.join(File.dirname(__FILE__), 'info_window_contents.txt')
+
+  include Curses
+
+  attr_reader :win
+
+  TITLE = ' PatchMaster '
+
+  def initialize(rows, cols, row, col)
+    @win = Window.new(rows, cols, row, col)
+  end
+
+  def draw
+    @win.setpos(0, (@win.maxx() - TITLE.length) / 2)
+    @win.attron(A_REVERSE) {
+      @win.addstr(TITLE)
+    }
+    @win.addstr("\n")
+    IO.foreach(CONTENTS) { |line| @win.addstr(line) }
+  end
+
+  def refresh
+    @win.refresh
+  end
+
+end
+end

data/lib/patchmaster/app/info_window_contents.txt

@@ -0,0 +1,15 @@
+j, down  - next patch
+k, up    - prev patch
+n, left  - next song
+p, right - prev song
+
+g   - goto song
+t   - goto song list
+
+ESC - panic
+F1  - help
+
+l   - load
+s   - save
+
+q   - quit

data/lib/patchmaster/app/list_window.rb

@@ -0,0 +1,26 @@
+require 'patchmaster/app/pm_window'
+
+module PM
+class ListWindow < PmWindow
+
+  attr_reader :list
+
+  def set_contents(title, list)
+    @title, @list = title, list
+    draw
+  end
+
+  def draw
+    super
+    return unless @list
+
+    @list.each_with_index do |thing, i|
+      @win.setpos(i+1, 1)
+      @win.attron(A_REVERSE) if thing == @list.curr
+      @win.addstr(make_fit(" #{thing.name} "))
+      @win.attroff(A_REVERSE) if thing == @list.curr
+    end
+  end
+
+end
+end

data/lib/patchmaster/app/main.rb

@@ -0,0 +1,161 @@
+require 'curses'
+require 'singleton'
+%w(list patch info prompt).each { |w| require "patchmaster/app/#{w}_window" }
+
+module PM
+
+class Main
+
+  DEBUG_FILE = '/tmp/pm_debug.txt'
+
+  include Singleton
+  include Curses
+
+  def initialize
+    @pm = PatchMaster.instance
+  end
+
+  def no_midi!
+    @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
+          refresh_all
+          ch = getch
+          message("ch = #{ch}") if $DEBUG
+          case ch
+          when ?j, Key::DOWN
+            @pm.next_patch
+          when ?k, Key::UP
+            @pm.prev_patch
+          when ?n, Key::LEFT
+            @pm.next_song
+          when ?p, Key::RIGHT
+            @pm.prev_song
+          when ?g
+            name = PromptWindow.new('Go To Song', 'Go to song:').gets
+            @pm.goto_song(name)
+          when ?t
+            name = PromptWindow.new('Go To Song List', 'Go to Song List:').gets
+            @pm.goto_song_list(name)
+          when Key::F1
+            help
+          when 27               # escape
+            @pm.panic
+            message('Panic sent')
+          when ?l
+            file = PromptWindow.new('Load', 'Load file:').gets
+            begin
+              @pm.load(file)
+            rescue => ex
+              message(ex.to_s)
+            end
+          when ?s
+            file = PromptWindow.new('Save', 'Save into file:').gets
+            begin
+              @pm.save(file)
+            rescue => ex
+              message(ex.to_s)
+            end
+          when ?q
+            break
+          end
+        rescue => ex
+          message(ex.to_s)
+          if $DEBUG
+            @debug_file.puts caller.join("\n")
+          end
+        end
+      end
+    ensure
+      close_screen
+      @pm.stop
+      if $DEBUG
+        @debug_file.close
+      end
+    end
+  end
+
+  def config_curses
+    init_screen
+    cbreak                      # unbuffered input
+    noecho                      # do not show typed keys
+    stdscr.keypad(true)         # enable arrow keys
+    curs_set(0)                 # cursor: 0 = invisible, 1 = normal
+  end
+
+  def create_windows
+    top_height = (lines() - 1) * 2 / 3
+    bot_height = (lines() - 1) - top_height
+    top_width = cols() / 3
+
+    sls_height = top_height / 3
+    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)
+
+    @info_win = InfoWindow.new(top_height, cols() - (top_width * 2) - 1, 0, top_width * 2 + 1)
+    @info_win.draw
+  end
+
+  def help
+    message("Help: not yet implemented")
+  end
+
+  def message(str)
+    if @message_win
+      @message_win.clear
+      @message_win.addstr(str)
+      @message_win.refresh
+    else
+      $stderr.puts str
+    end
+    if $DEBUG
+      @debug_file.puts "#{Time.now} #{str}"
+      @debug_file.flush
+    end
+  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)
+  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
+    if song
+      @song_win.set_contents(song.name, song.patches)
+      patch = song.curr_patch
+      @patch_win.patch = patch
+    else
+      @song_win.set_contents(nil, nil)
+      @patch_win.patch = nil
+    end
+  end
+
+end
+end

data/lib/patchmaster/app/patch_window.rb

@@ -0,0 +1,61 @@
+require 'patchmaster/app/pm_window'
+
+module PM
+class PatchWindow < PmWindow
+
+  attr_reader :patch
+
+  def patch=(patch)
+    @title = patch ? patch.name : nil
+    @patch = patch
+    draw
+  end
+
+  def draw
+    super
+    @win.setpos(1, 1)
+    draw_headers
+    return unless @patch
+
+    max_len = @win.maxx - 3     # minus 2 for borders
+    @patch.connections.each_with_index do |connection, i|
+      @win.setpos(i+2, 1)
+      draw_connection(connection, max_len)
+    end
+  end
+
+  def draw_headers
+    @win.attron(A_REVERSE) {
+      str = " Input          Chan | Output         Chan | Prog | Zone      | Xpose | Filter"
+      str << ' ' * (@win.maxx - 2 - str.length)
+      @win.addstr(str)
+    }
+  end
+
+  def draw_connection(connection, max_len)
+    str =  " #{'%16s' % connection.input.name}"
+    str << " #{connection.input_chan ? ('%2d' % (connection.input_chan+1)) : '  '} |"
+    str << " #{'%16s' % connection.output.name}"
+    str << " #{'%2d' % (connection.output_chan+1)} |"
+    str << if connection.pc?
+             "  #{'%3d' % connection.pc_prog} |"
+           else
+             "      |"
+           end
+    str << if connection.zone
+             " #{'%3s' % connection.note_num_to_name(connection.zone.begin)}" +
+             " - #{'%3s' % connection.note_num_to_name(connection.zone.end)} |"
+           else
+             '           |'
+           end
+    str << if connection.xpose && connection.xpose > 0
+             "    #{'%2d' % connection.xpose.to_i} |"
+           else
+             "       |"
+           end
+    str << " #{connection.filter}"
+    @win.addstr(make_fit(str))
+  end
+
+end
+end

data/lib/patchmaster/app/pm_window.rb

@@ -0,0 +1,41 @@
+require 'curses'
+
+module PM
+class PmWindow
+
+  include Curses
+
+  attr_reader :win, :title_prefix
+  attr_accessor :title
+
+  # If title is nil then list's name will be used
+  def initialize(rows, cols, row, col, title_prefix)
+    @win = Window.new(rows, cols, row, col)
+    @title_prefix = title_prefix
+    @max_contents_len = @win.maxx - 3 # 2 for borders
+  end
+
+  def refresh
+    @win.refresh
+  end
+
+  def draw
+    @win.clear
+    @win.box(?|, ?-)
+    return unless @title_prefix || @title
+
+    @win.setpos(0, 1)
+    @win.attron(A_REVERSE) {
+      @win.addch(' ')
+      @win.addstr("#{@title_prefix}: ") if @title_prefix
+      @win.addstr(@title) if @title
+      @win.addch(' ')
+    }
+  end
+
+  def make_fit(str)
+    str = str[0..@max_contents_len] if str.length > @max_contents_len
+    str
+  end
+end
+end

data/lib/patchmaster/app/prompt_window.rb

@@ -0,0 +1,61 @@
+require 'curses'
+
+module PM
+class PromptWindow
+
+  MAX_WIDTH = 30
+
+  include Curses
+
+  def initialize(title, prompt)
+    @title, @prompt = title, prompt
+    width = cols() / 2
+    width = MAX_WIDTH if width > MAX_WIDTH
+    @win = Window.new(4, width, lines() / 3, (cols() - width) / 2)
+  end
+
+  def gets
+    draw
+    str = read_string
+    cleanup
+    str
+  end
+
+  def draw
+    @win.box(?|, ?-)
+    @win.setpos(0, 1)
+    @win.attron(A_REVERSE) {
+      @win.addstr(" #@title ")
+    }
+
+    @win.setpos(1, 1)
+    @win.addstr(@prompt)
+
+    @win.setpos(2, 1)
+    @win.attron(A_REVERSE) {
+      @win.addstr(' ' * (@win.maxx() - 2))
+    }
+
+    @win.setpos(2, 1)
+    @win.refresh
+  end
+
+  def read_string
+    nocbreak
+    echo
+    curs_set(1)
+    str = nil
+    @win.attron(A_REVERSE) {
+      str = @win.getstr
+    }
+    curs_set(0)
+    noecho
+    cbreak
+    str
+  end
+
+  def cleanup
+    @win.close
+  end
+end
+end

data/lib/patchmaster/connection.rb

@@ -0,0 +1,90 @@
+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.
+class Connection
+
+  attr_accessor :input, :input_chan, :output, :output_chan,
+    :pc_prog, :zone, :xpose, :filter
+
+  # If input_chan is nil than all messages from input will be sent to
+  # output.
+  #
+  # All channels (input_chan, output_chan, etc.) are 1-based here but are
+  # turned into 0-based channels for later use.
+  def initialize(input, input_chan, output, output_chan, filter=nil, opts={})
+    @input, @input_chan, @output, @output_chan, @filter = input, input_chan, output, output_chan, filter
+    @pc_prog, @zone, @xpose = opts[:pc_prog], opts[:zone], opts[:xpose]
+
+    @input_chan -= 1 if @input_chan
+    @output_chan -= 1 if @output_chan
+  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?
+    @input.add_connection(self)
+  end
+
+  def stop
+    @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
+  end
+
+  # Returns true if the +@zone+ is nil (allowing all notes throught) or if
+  # +@zone+ is a Range and +note+ is inside +@zone+.
+  def inside_zone?(note)
+    @zone == nil || @zone.include?(note)
+  end
+
+  def midi_in(bytes)
+    return unless accept_from_input?(bytes)
+
+    # TODO handle running bytes
+    high_nibble = bytes[0] & 0xf0
+    case high_nibble
+    when NOTE_ON, NOTE_OFF, POLY_PRESSURE
+      return unless inside_zone?(bytes[1])
+      bytes[0] = high_nibble + @output_chan
+      bytes[1] = ((bytes[1] + @xpose) & 0xff) if @xpose
+    when CONTROLLER, PROGRAM_CHANGE, CHANNEL_PRESSURE, PITCH_BEND
+      bytes[0] = high_nibble + @output_chan
+    end
+
+    bytes = @filter.call(self, bytes) if @filter
+    if bytes && bytes.size > 0
+      midi_out(@output, bytes)
+    end
+  end
+
+  def midi_out(device, bytes)
+    device.midi_out(bytes)
+  end
+
+  def pc?
+    @pc_prog != nil
+  end
+
+  def note_num_to_name(n)
+    oct = (n / 12) - 1
+    note = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B'][n % 12]
+    "#{note}#{oct}"
+  end
+
+  def to_s
+    str = "#{@input.name} ch #{@input_chan ? @input_chan+1 : 'all'} -> #{@output.name} ch #{@output_chan+1}"
+    str << "; pc #@pc_prog" if pc?
+    str << "; xpose #@xpose" if @xpose
+    str << "; zone #{note_num_to_name(@zone.begin)}..#{note_num_to_name(@zone.end)}" if @zone
+  end
+end
+
+end # PM