tabscroll 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a07da9616f2254f2fd9bd14e11a5e8f327c132df
+  data.tar.gz: 854189ab82e34c155233f7b5b9b8ac0768105761
+SHA512:
+  metadata.gz: 00977e49cde6a2ccf4666510585224a82fdd4efbc0d38b9e3f38008eced4f969d0d63b0b693285bea776feb6aa2589be7decd1ebba1346365c1ede6e80df4e86
+  data.tar.gz: d1a0f44480d736aa8f1c9a7b2f171d873d79b3d66c9a4d715b85eabee982552606c9d1aaa23cba8e37795b0136a7a11a6086f15b7be804154d5e68a437187ef6

data/bin/tabscroll

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+#
+# The main `tabscroll` executable
+
+require 'tabscroll'
+
+begin
+  filename = ARGV[0]
+  if not filename
+    puts "Usage:"
+    puts "	$ #{PROGRAM_NAME} (filename)"
+    exit 666
+  end
+
+  $engine = Engine.new
+  if not $engine
+    puts 'Failed to start curses!'
+    exit 1337
+  end
+  $engine.timeout 10
+
+  win = Screen.new(0, 1, $engine.width, $engine.height - 2)
+  track = Track.new win
+  track.load filename
+  track.auto_scroll true
+
+  titlebar  = Screen.new(0, 0, $engine.width, 1)
+  statusbar = Screen.new(0, ($engine.height - 1), $engine.width, 1)
+
+  bars_hidden = false
+  finished = false
+  while not finished
+    # WHY DOES GETCH CLEARS UP THE WHOLE SCREEN?
+    # IT DOESNT MAKE ANY SENSE
+    c = $engine.getchar
+    case c
+    when 'e'
+      track.end
+    when 'a'
+      track.begin
+    when 'h'
+      show_help_window
+    when 'o'
+      bars_hidden = (bars_hidden ? false : true)
+      Curses::clear
+    when '<'
+      track.scroll -5
+    when '>'
+      track.scroll 5
+    when Curses::KEY_LEFT
+      track.speed -= 1
+    when Curses::KEY_RIGHT
+      track.speed += 1
+    when Curses::KEY_DOWN, Curses::KEY_UP
+      track.speed = 0
+    when 'q'
+      quit
+    end
+
+    track.update
+    track.show
+    if not bars_hidden
+      titlebar.mvaddstr(0, 0, "#{filename} (#{track.percent_completed}%) ", Engine::Colors[:cyan])
+      titlebar.mvaddstr_right(0, "  Speed: #{track.speed}", Engine::Colors[:cyan])
+
+      statusbar.mvaddstr_left(0, "#{PROGRAM_NAME} v#{PROGRAM_VERSION} - press `h` for help", Engine::Colors[:green])
+    end
+  end
+
+  quit
+end
+

data/lib/tabscroll/engine.rb

@@ -0,0 +1,95 @@
+
+require 'curses'
+
+# The main interface with Curses.
+#
+# This acts as a middleman, abstracting away curses' details.
+class Engine
+
+  # All possible colors.
+  Colors = {
+    :black   => 1,
+    :white   => 2,
+    :red     => 3,
+    :yellow  => 4,
+    :magenta => 5,
+    :blue    => 6,
+    :green   => 7,
+    :cyan    => 8
+  }.freeze
+
+  # Initializes Ncurses with minimal +width+ and +height+.
+  #
+  def initialize(min_width=nil, min_height=nil)
+    @has_colors = nil
+
+    @screen = Curses::init_screen
+    return nil if not @screen
+
+    if min_width and min_height
+      cur_width  = @screen.maxx
+      cur_height = @screen.maxy
+
+      if cur_width < @width or cur_height < @height
+        self.exit
+        $stderr << "Error: Screen size too small (#{cur_width}x#{cur_height})\n"
+        $stderr << "Please resize your terminal to at least #{@width}x#{@height}\n"
+        return nil
+      end
+    end
+
+    @has_colors = Curses.has_colors?
+    if @has_colors
+      Curses.start_color
+      Curses.use_default_colors # will use default background
+
+      # Initializes:   constant          foreground             bg
+      Curses.init_pair(Colors[:white],   Curses::COLOR_BLACK,   -1)
+      Curses.init_pair(Colors[:blue],    Curses::COLOR_BLUE,    -1)
+      Curses.init_pair(Colors[:red],     Curses::COLOR_RED,     -1)
+      Curses.init_pair(Colors[:green],   Curses::COLOR_GREEN,   -1)
+      Curses.init_pair(Colors[:magenta], Curses::COLOR_MAGENTA, -1)
+      Curses.init_pair(Colors[:yellow],  Curses::COLOR_YELLOW,  -1)
+      Curses.init_pair(Colors[:cyan],    Curses::COLOR_CYAN,    -1)
+    end
+
+    Curses::cbreak
+    Curses::curs_set 0
+    Curses::noecho
+    Curses::nonl
+    Curses::stdscr.keypad = true # extra keys
+  end
+
+  def width
+    return Curses::cols
+  end
+
+  def height
+    return Curses::lines
+  end
+
+  def exit
+    Curses::refresh
+    Curses::close_screen
+  end
+
+  def set_color color
+    if @has_colors
+      @screen.attron Curses::color_pair(color)
+      return self
+    else
+      return nil
+    end
+  end
+
+  def getchar
+    return Curses::getch
+  end
+
+  # +timeout+ says how many milliseconds we wait for a key to be
+  # pressed.
+  def timeout timeout
+    Curses::timeout = timeout
+  end
+end
+

data/lib/tabscroll/popup.rb

@@ -0,0 +1,60 @@
+
+require_relative 'screen.rb'
+
+# A simple centralized popup.
+#
+# It resizes as you place the text on it.
+class Popup < Screen
+
+  def initialize(title, text)
+    @title = title
+    @text = []
+    text.each_line do |line|
+      @text += [line.chomp]
+    end
+
+    max_width  = title.length
+    max_height = 1
+
+    @text.each do |line|
+      max_width   = line.length if line.length > max_width
+      max_height += 1
+    end
+
+    max_width  += 2 # left-right borders
+    max_height += 1 # down border
+
+    x = Curses::cols/2  - max_width/2
+    y = Curses::lines/2 - max_height/2
+
+    super(x, y, max_width, max_height)
+    self.background ' '
+    self.box
+
+    self.mvaddstr_center(0, title, Engine::Colors[:cyan])
+
+    y = 1
+    @text.each do |line|
+      self.mvaddstr(1, y, line)
+      y += 1
+    end
+  end
+
+  def show
+    finished = false
+    while not finished
+      c = Curses::getch
+      case c
+      when 'q'
+        return true
+      when 'h'
+        finished = true
+      end
+    end
+
+    Curses::stdscr.clear
+    Curses::stdscr.refresh
+    return false
+  end
+end
+

data/lib/tabscroll/screen.rb

@@ -0,0 +1,125 @@
+
+require 'curses'
+
+# A segment of the terminal screen.
+#
+# BUG WARNING HACK FUCK
+# Whenever I use @win.attrset/@win.setpos/@win.addch
+# it doesn't work at all.
+# Apparently, when I do this, Curses::getch clears up
+# the entire screen.
+#
+# DO NOT DO THIS
+#
+class Screen
+  attr_reader :width, :height
+
+  # Creates a Screen at `x` `y` `w` `h`.
+  def initialize(x, y, w, h)
+    @win = Curses::Window.new(h, w, y, x)
+    @width  = w
+    @height = h
+  end
+
+  # Sets the current color of the Screen.
+  def set_color color
+    Curses::attrset(Curses::color_pair color)
+  end
+
+  # Executes a block of code encapsulated within a color on/off.
+  # Note that the color can be overrided.
+  def with_color(color=nil)
+    Curses::attron(Curses::color_pair color) if color
+    yield
+    Curses::attroff(Curses::color_pair color) if color
+  end
+
+  # Puts a character +c+ on (+x+, +y+) with optional +color+.
+  def mvaddch(x, y, c, color=nil)
+    return if x < 0 or x >= @width
+    return if y < 0 or y >= @height
+
+    self.with_color color do
+      Curses::setpos(@win.begy + y, @win.begx + x)
+      Curses::addch c
+    end
+  end
+
+  # Puts a string +str+ on (+x+, +y+) with optional +color+.
+  def mvaddstr(x, y, str, color=nil)
+    return if x < 0 or x >= @width
+    return if y < 0 or y >= @height
+
+    self.with_color color do
+#      @win.setpos(@win.begy + y, @win.begx + x)
+#      @win.addstr str
+      Curses::setpos(@win.begy + y, @win.begx + x)
+      Curses::addstr str
+    end
+  end
+
+  # Puts a string +str+ centered on +y+ with optional +color+.
+  def mvaddstr_center(y, str, color=nil)
+    x = (@width/2) - (str.length/2)
+    self.mvaddstr(x, y, str, color)
+  end
+
+  def mvaddstr_left(y, str, color=nil)
+    self.mvaddstr(0, y, str, color)
+  end
+
+  def mvaddstr_right(y, str, color=nil)
+    x = @width - str.length
+    self.mvaddstr(x, y, str, color)
+  end
+
+  # Erases all of the Screen's contents
+  def clear
+    @win.clear
+  end
+
+  # Commits the changes on the Screen.
+  def refresh
+    @win.refresh
+  end
+
+  # Moves window so that the upper-left corner is at `x` `y`.
+  def move(x, y)
+    @win.move(y, x)
+  end
+
+  # Resizes window to +width+ and +h+eight.
+  def resize(w, h)
+    @win.resize(h, w)
+    @width  = w
+    @height = h
+  end
+
+  # Set block/nonblocking reads for window.
+  #
+  # * If `delay` is negative, blocking read is used.
+  # * If `delay` is zero, nonblocking read is used.
+  # * If `delay` is positive, waits for `delay` milliseconds and
+  #   returns ERR of no input.
+  def timeout(delay=-1)
+    @win.timeout = delay
+  end
+
+  def background char
+    @win.bkgd char
+    @win.refresh
+  end
+
+  # Sets the Screen border.
+  #
+  # * If all arguments are set, that's ok.
+  # * If only the first 2 arguments are set, they are the vertical
+  #   and horizontal chars.
+  #
+  def box(horizontal=0, vertical=0)
+    @win.box(horizontal, vertical)
+    @win.refresh
+  end
+
+end
+

data/lib/tabscroll/timer.rb

@@ -0,0 +1,89 @@
+# A simple timer that counts in seconds.
+#
+# Usage:
+#     timer = Timer.new
+#     timer.start
+#     ...
+#     if timer.delta > 0.5 # half a second
+#         ...
+#
+class Timer
+
+  def initialize
+    @is_running = false
+    @is_paused  = false
+  end
+
+  # Starts counting.
+  def start
+    return if @is_running
+
+    @start_time  = Time.now
+    @stop_time   = 0.0
+    @paused_time = 0.0
+    @is_running  = true
+    @is_paused   = false
+  end
+
+  # Stops counting.
+  def stop
+    return if not @is_running
+
+    @stop_time  = Time.now
+    @is_running = false
+    @is_paused  = false
+  end
+
+  def restart
+    self.stop
+    self.start
+  end
+
+  def pause
+    return if not @is_running or @is_paused
+
+    @paused_time = (Time.now - @start_time)
+    @is_running  = false
+    @is_paused   = true
+  end
+
+  def unpause
+    return if not @is_paused or @is_running
+
+    @start_time = (Time.now - @paused_time)
+    @is_running = true
+    @is_paused  = false
+  end
+
+  def running?
+    @is_running
+  end
+
+  def paused?
+    @is_paused
+  end
+
+  # Returns the current delta in seconds (float).
+  def delta
+    if @is_running
+      return (Time.now.to_f - @start_time.to_f)
+    end
+
+    return @paused_time.to_f if @is_paused
+
+    return @start_time if @start_time == 0 # Something's wrong
+
+    return (@stop_time.to_f - @start_time.to_f)
+  end
+
+  # Converts the timer's delta to a formatted string.
+  def to_s
+    min  = (self.delta / 60).to_i
+    sec  = (self.delta).to_i
+    msec = (self.delta * 100).to_i
+
+    "#{min}:#{sec}:#{msec}"
+  end
+
+end
+

data/lib/tabscroll/track.rb

@@ -0,0 +1,203 @@
+
+require_relative 'screen.rb'
+require_relative 'timer.rb'
+
+# A full guitar tab, as shown on the screen.
+# Note that it depends on an already-existing window to exist.
+#
+class Track
+  COMMENT_CHAR = '#'
+  attr_reader :screen, :percent_completed
+  attr_accessor :speed
+
+  # Creates a Track that will be shown on `screen`.
+  # See Screen.
+  def initialize(screen)
+    @offset = 0
+    @timer  = Timer.new
+    @timer.start
+    @speed  = 0
+    @screen = screen
+    @percent_completed = 0
+
+    @raw_track = []
+    @raw_track[0] = ""
+    @raw_track[1] = ""
+    @raw_track[2] = ""
+    @raw_track[3] = ""
+    @raw_track[4] = ""
+    @raw_track[5] = ""
+    @raw_track[6] = ""
+  end
+
+  # Loads and parses +filename+'s contents into Track.
+  def load filename
+    if not File.exist? filename
+      raise "Error: File '#{filename}' doesn't exist!"
+    end
+    if not File.file? filename
+      raise "Error: '#{filename}' is not a file!"
+    end
+
+    file = File.new filename
+
+    # The thing here is there's no way I can know in
+    # advance how many lines the tab track will have.
+    #
+    # People put lots of strange things on them like
+    # timing, comments, etecetera.
+    #
+    # So I will read all non-blank lines, creating a
+    # counter. Then I will use it to display the track
+    # onscreen.
+    #
+    # I will also make every line have the same width
+    # as of the biggest one.
+
+    # Any tab line MUST have EITHER ---1---9--| OR |---3----0
+    tab_line = /[-[:alnum:]]\||\|[-[:alnum:]]/
+
+    # Duration of each note only has those chars.
+    # So we look for anything BUT these chars.
+    not_duration_line = /[^WHQESTX \.]/
+
+    count = 0
+    max_width = 0
+
+    file.readlines.each do |line|
+      next if line[0] == COMMENT_CHAR
+
+      line.chomp!
+      if line.empty?
+
+        # Making sure everything will have the same width
+        @raw_track.each_with_index do |t, i|
+          if t.length < max_width
+            @raw_track[i] += (' ' * (max_width - t.length))
+          end
+        end
+
+        count = 0
+        max_width = 0
+
+      # Lines must be EITHER a tab_line OR a duration_line.
+      # not not duration line means that
+      # (I should find a better way of expressing myself on regexes)
+      elsif (line =~ tab_line) or (not line =~ not_duration_line)
+        @raw_track[count] += line
+
+        if @raw_track[count].length > max_width
+          max_width = @raw_track[count].length
+        end
+
+        count += 1
+
+      end # Ignoring any other kind of line
+
+      if count > 7
+        raise "Error: Invalid format on '#{filename}'"
+      end
+
+    end
+  end
+
+  # Prints the track on the screen, along with string indicators
+  # on the left.
+  #
+  # It is shown at the vertical center of the provided Screen,
+  # spanning it's whole width.
+  def show
+    x = 1
+    y = (@screen.height/2) - (@raw_track.size/2)
+
+    # This both prints EADGBE and clears the whole screen,
+    # printing spaces where the track was.
+    #
+    # Also, if we have only 5 tracks, we leave the sixth
+    # indicator out of the screen.
+    if not @raw_track[6] =~ /[:blank:]/
+      @screen.mvaddstr(0, y,     "E" + (' ' * (@screen.width - 1)))
+      @screen.mvaddstr(0, y + 1, "B" + (' ' * (@screen.width - 1)))
+      @screen.mvaddstr(0, y + 2, "G" + (' ' * (@screen.width - 1)))
+      @screen.mvaddstr(0, y + 3, "D" + (' ' * (@screen.width - 1)))
+      @screen.mvaddstr(0, y + 4, "A" + (' ' * (@screen.width - 1)))
+      @screen.mvaddstr(0, y + 5, "E" + (' ' * (@screen.width - 1)))
+    else
+      @screen.mvaddstr(0, y,     ' ' * @screen.width)
+      @screen.mvaddstr(0, y + 1, "E" + (' ' * (@screen.width - 1)))
+      @screen.mvaddstr(0, y + 2, "B" + (' ' * (@screen.width - 1)))
+      @screen.mvaddstr(0, y + 3, "G" + (' ' * (@screen.width - 1)))
+      @screen.mvaddstr(0, y + 4, "D" + (' ' * (@screen.width - 1)))
+      @screen.mvaddstr(0, y + 5, "A" + (' ' * (@screen.width - 1)))
+      @screen.mvaddstr(0, y + 6, "E" + (' ' * (@screen.width - 1)))
+    end
+
+    (0...@raw_track.size).each do |i|
+      str = @raw_track[i]
+      str = str[@offset..(@offset + @screen.width - 2)]
+      @screen.mvaddstr(x, y + i, str)
+    end
+  end
+
+  # Scrolls the guitar tab by `n`.
+  #
+  # * If `n` is positive, scroll forward.
+  # * If `n` is negative, scroll backward.
+  def scroll n
+    @offset += n
+
+    left_limit  = 0
+    right_limit = (@raw_track[0].length - @screen.width + 1).abs
+
+    if @offset < left_limit  then @offset = left_limit  end
+    if @offset > right_limit then @offset = right_limit end
+  end
+
+  # Goes to the beginning of the Track.
+  def begin
+    @offset = 0
+    @speed  = 0
+  end
+
+  # Goes to the end of the Track.
+  def end
+    @offset = (@raw_track[0].length - @screen.width + 1).abs
+    @speed  = 0
+  end
+
+  # Turns on/off Track's auto scroll functionality.
+  #
+  # Note that it won't work anyways if you don't keep calling
+  # +update+ method.
+  def auto_scroll option
+    if option == true
+      @timer.start if not @timer.running?
+    else
+      @timer.stop
+    end
+  end
+
+  # Updates Track's auto scroll functionality.
+  def update
+    return if not @timer.running?
+
+    current_completed = @offset + @screen.width - 1
+    @percent_completed = ((100.0 * current_completed)/@raw_track[0].length).ceil
+
+    if @timer.running? and @speed != 0
+      if @timer.delta > (1/(@speed*0.5)).abs
+        if @speed > 0
+          self.scroll 1
+          self.show
+        else
+          self.scroll -1
+          self.show
+        end
+
+        @timer.restart
+      end
+    end
+  end
+
+end
+

data/lib/tabscroll.rb

@@ -0,0 +1,40 @@
+# The main executable file.
+
+require_relative 'tabscroll/engine'
+require_relative 'tabscroll/screen'
+require_relative 'tabscroll/track'
+require_relative 'tabscroll/popup'
+
+# Global vars
+$engine = nil
+PROGRAM_NAME    = "tabscroll"
+PROGRAM_VERSION = "0.0.1"
+
+# Terminates program's execution normally, finishing the engine.
+def quit
+  $engine.exit
+  exit 0
+end
+
+# Displays a help window, waiting for a keypress.
+def show_help_window
+  title = 'Help'
+  text  = <<END_OF_TEXT
+         q  quit
+         h  help/go back
+left/right  auto-scroll left/right
+   up/down  stop auto-scrolling
+       </>  step scroll left/right
+         o  toggle status/title bars
+
+
+#{PROGRAM_NAME} v#{PROGRAM_VERSION}
+homepage  alexdantas.net/projects/tabscroll
+author    Alexandre Dantas <eu@alexdantas.net>
+END_OF_TEXT
+
+  pop = Popup.new(title, text)
+  will_quit = pop.show
+  quit if will_quit
+end
+

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: tabscroll
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Alexandre Dantas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-13 00:00:00.000000000 Z
+dependencies: []
+description: Scrolls a textual guitar tab on the terminal.
+email:
+- eu@alexdantas.net
+executables:
+- tabscroll
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/tabscroll.rb
+- lib/tabscroll/engine.rb
+- lib/tabscroll/screen.rb
+- lib/tabscroll/track.rb
+- lib/tabscroll/popup.rb
+- lib/tabscroll/timer.rb
+- bin/tabscroll
+homepage: http://www.alexdantas.net/projects/tabscroll
+licenses:
+- GPL-3.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.7
+signing_key: 
+specification_version: 4
+summary: Guitar tab scroller on the terminal
+test_files: []