ampv 1.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZTMwNzg3MDNhNjM2ZTk1Njk4MmYyNzllNTYzOTQ4MzQ1OTJiNmJkOQ==
+  data.tar.gz: !binary |-
+    MmFmYTY5YmQ4Zjc0OTQ4NzE3Y2IxNTBmNmZhNGQ5ZTc5M2E5NDBiMQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    YzFkNDdmOTYyOTg1NDdkNjEyZTgwN2NlY2Y0NzU3MjkzODE2OTQ1YWFjZDNm
+    ZTJlMWQyNTUwNTc5ZTVjZTFlZjEzZGZmMjMzY2E1MTRmZDZmOWQ2YzE3MjUx
+    NmU0ZTQyNzA2YWMzMjU2MGI5YzRiMmJjMjk5YjJhYTJmNDcxMDM=
+  data.tar.gz: !binary |-
+    MzE0ZjZhZGYyYzhkNWZmNjhiZDA1ZjAyNDBlMmVmMDQyYWVhNGZkOTk4YmQw
+    MWJiMDU0ZGNmYzBjMDIyNzg1OWI3NDE0MWM1Zjk3ZTgwMzRkY2VlOTE1ZWJj
+    OWNiMjZkOTYzY2YxOWEwMGZiMmZlN2RkYzdiNWQxODYxZTZkZjU=

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 ahoka
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/bin/ampv

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "ampv"
+
+Ampv::MainWindow.new
+

data/input.conf

@@ -0,0 +1,28 @@
+MOUSE_BTN0_DBL  cycle fullscreen
+MOUSE_BTN1      cycle pause
+MOUSE_BTN3      add volume 1
+MOUSE_BTN4      add volume -1
+MOUSE_BTN7      playlist_prev
+MOUSE_BTN8      playlist_next
+MOUSE_BTN9      cycle pause
+
+RIGHT seek  10
+LEFT  seek -10
+UP    add volume 1
+DOWN  add volume -1
+
+PGUP    seek -90 - exact
+PGDWN   seek 90 - exact
+HOME    add chapter -1
+END     add chapter 1
+INS     playlist_prev
+DEL     playlist_next
+
+f       cycle fullscreen
+SPACE   cycle pause
+ESC     quit_watch_later
+
+# ampv commands
+l          cycle playlist
+o          open_file_chooser
+p          cycle progress_bar

data/lib/ampv.rb

@@ -0,0 +1,380 @@
+
+require "gtk2"
+require "ampv/mpvwidget"
+require "ampv/playlist"
+require "ampv/progressbarwidget"
+require "ampv/version"
+require "uri"
+
+module Ampv
+  class MainWindow < Gtk::Window
+
+    MAIN_CONF  = "#{ENV["HOME"]}/.config/ampv.conf"
+    INPUT_CONF = "#{ENV["HOME"]}/.mpv/input.conf"
+    VIDEO_EXTS = [ ".avi", ".mkv", ".mp4", ".mpeg", ".mpg", ".ogm", ".ogv" ]
+    KEY_NAMES  = {
+      "esc"         => "Escape",
+      "space"       => "space",
+      "right"       => "Right",
+      "left"        => "Left",
+      "up"          => "Up",
+      "down"        => "Down",
+      "pgup"        => "Page_Up",
+      "pgdwn"       => "Page_Down",
+      "home"        => "Home",
+      "end"         => "End",
+      "ins"         => "Insert",
+      "del"         => "Delete",
+    }
+    WHEEL_BUTTONS = {
+      Gdk::EventScroll::UP    => 4,
+      Gdk::EventScroll::DOWN  => 5,
+      Gdk::EventScroll::LEFT  => 6,
+      Gdk::EventScroll::RIGHT => 7
+    }
+
+    LEFT_PTR     = Gdk::Cursor.new(Gdk::Cursor::LEFT_PTR)
+    BLANK_CURSOR = Gdk::Cursor.new(Gdk::Cursor::BLANK_CURSOR)
+
+    def initialize
+      load_config
+      super
+      set_title(PACKAGE)
+      set_default_size(@config["width"], @config["height"])
+      set_window_position(Gtk::Window::POS_CENTER)
+      move(@config["x"], @config["y"]) unless @config["x"] == -1 and @config["y"] == -1
+
+      Gtk::Drag.dest_set(self, Gtk::Drag::DEST_DEFAULT_ALL,
+                         [ [ "text/uri-list", 0, 0 ] ],
+                         Gdk::DragContext::ACTION_LINK)
+
+      signal_connect("delete_event") { quit }
+      signal_connect("scroll_event") { |w, e| handle_mouse_event(e) }
+      signal_connect("button_press_event") { |w, e| handle_mouse_event(e) }
+      signal_connect("key_press_event") { |w, e| handle_keyboard_event(e) }
+      signal_connect("drag_data_received") { |w, dc, x, y, sd, type, time|
+        handle_drop_event(sd.data, dc, time, false, true)
+      }
+
+      vbox = Gtk::VBox.new
+      add(vbox)
+
+      args = process_args
+      load_bindings
+
+      @mpv = MPvWidget.new(args, @config["scrobbler"])
+      @mpv.signal_connect("file_changed") { |w, file|
+        @playing = file
+        @mpv.send("show_text ${media-title} 1500") if window.state.fullscreen?
+        @playlist.set_selected(@playing)
+        set_title(File.basename(@playing))
+      }
+      @mpv.signal_connect("length_changed") { |w, len|
+        @length = len
+        @playlist.update_length(@length)
+      }
+      @mpv.signal_connect("time_pos_changed") { |w, pos| @progress_bar.value = pos / @length.to_f }
+      @mpv.signal_connect("stopped") {
+        @progress_bar.value = 0
+        next_file = @playlist.get_next
+        @really_stop = next_file.nil? or @really_stop
+        set_title(PACKAGE)
+        if @really_stop and window.state.fullscreen?
+          toggle_fullscreen
+        elsif not @really_stop
+          load_file(next_file, false)
+        end
+        @really_stop = false
+      }
+
+      vbox.pack_start(@mpv)
+
+      @playlist = Playlist.new(@config["playlist_x"],
+                               @config["playlist_y"],
+                               @config["playlist_width"],
+                               @config["playlist_height"],
+                               @config["playlist_visible"])
+      @playlist.signal_connect("open_file_chooser") { open_file_chooser }
+      @playlist.signal_connect("drag_data_received") { |w, dc, x, y, sd, type, time|
+        handle_drop_event(sd.data, dc, time, true, false)
+      }
+      @playlist.signal_connect("play_entry") { |w, file| load_file(file, false, false, false, true) }
+      @playlist.signal_connect("playing_removed") { @mpv.send("stop"); @really_stop = true }
+
+      @progress_bar = ProgressBarWidget.new(@config["bar_color"],
+                                            @config["head_color"],
+                                            @config["progress_bar_height"])
+      @progress_bar.add_events(Gdk::Event::BUTTON_PRESS_MASK)
+      @progress_bar.signal_connect("button_press_event") { |w, e| handle_seek_event(e) }
+      vbox.pack_start(@progress_bar, false, false)
+
+      show_all
+      @mpv.start
+
+      argv = ARGV.join(" ")
+      if not argv.empty?
+        load_file(argv)
+      elsif not @config["playlist"].empty?
+        @config["playlist"].each { |x| load_file(x, true, true, false) }
+        @playlist.set_selected(@config["playlist_selected"])
+      end
+
+      Gtk.main
+    end
+
+    def load_config
+      @config = {
+        "width"                  => Gdk::Screen.default.width > 1280 ? 1280 : 853,
+        "height"                 => Gdk::Screen.default.width > 1280 ? 726  : 486,
+        "x"                      => -1,
+        "y"                      => -1,
+        "fullscreen_progressbar" => false,
+        "progress_bar_visible"   => true,
+        "progress_bar_height"    => 6,
+        "bar_color"              => "#8f5b5b",
+        "head_color"             => "#c48181",
+        "playlist_width"         => 360,
+        "playlist_height"        => 550,
+        "playlist_x"             => 0,
+        "playlist_y"             => 0,
+        "playlist_visible"       => true,
+        "always_save_position"   => false,
+        "scrobbler"              => "",
+        "playlist_selected"      => "",
+        "playlist"               => [ ],
+      }
+
+      if File.exists?(MAIN_CONF)
+        File.readlines(MAIN_CONF).each { |line|
+          key, _, val = line.partition("=")
+          key = key.strip
+          val = val.strip
+          next unless @config.has_key?(key) and not key.start_with?("#")
+
+          if @config[key].is_a?(Integer)
+            val = val.to_i
+          elsif @config[key].is_a?(TrueClass) or @config[key].is_a?(FalseClass)
+            val = val == "true"
+          elsif @config[key].is_a?(Array)
+            val = val.split("|")
+          elsif val.start_with?("#")
+            begin
+              c = Gdk::Color.parse(val)
+            rescue
+              puts("Invalid hexidecimal color for setting `#{key}': `#{val}")
+              c = Gdk::Color.parse(@config[key])
+            end
+            val = c
+          end
+
+          @config[key] = val
+        }
+      end
+    end
+
+    def process_args
+      args = [ ]
+      ARGV.dup.each { |arg|
+        if arg.start_with?("-")
+          args.push(arg)
+          ARGV.delete(arg)
+        end
+      }
+      return args
+    end
+
+    def load_bindings
+      @mouse_bindings = [ ]
+      @key_bindings   = [ ]
+      if File.exists?(INPUT_CONF)
+        File.readlines(INPUT_CONF).each { |line|
+          line = line.strip
+          if line.start_with?("MOUSE_BTN")
+            # 4 = up, 5 = down, 6 = left, 7 = right
+            button, cmd = line.match(/MOUSE_BTN(\d+)(?:_DBL)?\s+(.+)$/).captures
+            button = button.to_i + 1
+            type   = (4..7).include?(button) ? Gdk::Event::SCROLL :
+              line.include?("DBL") ? Gdk::Event::BUTTON2_PRESS : Gdk::Event::BUTTON_PRESS
+            @mouse_bindings[type] = [ ] if @mouse_bindings[type].nil?
+            @mouse_bindings[type][button] = cmd
+          elsif not line.empty?
+            key, cmd = line.match(/^([^\s]+)\s+(.+)$/).captures
+            if name = KEY_NAMES[key.downcase]
+              keyval = Gdk::Keyval.from_name(name)
+            else
+              keyval = Gdk::Keyval.from_name(key)
+            end
+
+            @key_bindings[keyval] = cmd if keyval > 0
+          end
+        }
+      end
+    end
+
+    def load_file(file, add_to_playlist=true, do_not_play=false, auto_add=true, force_play=false)
+      return if file.nil? or file.empty?
+      file = File.expand_path(file) if file[0] == "~"
+
+      if add_to_playlist
+        if @playlist.count == 0 and auto_add and file !~ /^https?:\/\//
+          dir     = File.directory?(file) ? file : File.dirname(file)
+          entries = Dir.entries(dir).sort
+          entries.delete_if { |x| x.start_with?(".") or not valid_video_file(x) }
+          entries.map { |x|
+            x = dir + "/" + x
+            @playlist.add_file(x)
+            file = x if file == dir
+          }
+        else
+          @playlist.add_file(file)
+        end
+      end
+
+      @mpv.load_file(file, force_play) unless do_not_play
+    end
+
+    def handle_mouse_event(e)
+      button = e.event_type == Gdk::Event::SCROLL ? WHEEL_BUTTONS[e.direction] : e.button
+      return if @mouse_bindings[e.event_type].nil?
+
+      process_cmd(@mouse_bindings[e.event_type][button])
+
+      return true
+    end
+
+    def handle_keyboard_event(e)
+      process_cmd(@key_bindings[e.keyval])
+
+      return true
+    end
+
+    def handle_seek_event(e)
+      if e.event_type == Gdk::Event::BUTTON_PRESS and e.button == 1
+        pos = e.x / allocation.width * @length.to_f
+        seek("seek #{pos} absolute")
+      end
+
+      return true
+    end
+
+    def handle_drop_event(data, context, time, do_not_play, replace)
+      files = URI.decode(data).gsub("file://", "").split("\r\n")
+      @playlist.clear if replace
+
+      files.each { |x|
+        load_file(x, true, do_not_play) if valid_video_file(x)
+      }
+
+      Gtk::Drag.finish(context, true, true, time)
+    end
+
+    def process_cmd(cmd)
+      case cmd
+      when "cycle fullscreen"
+        toggle_fullscreen
+      when "cycle pause"
+        @mpv.play_pause
+      when "cycle playlist"
+        @playlist.visible? ? @playlist.hide : @playlist.show
+      when /seek /
+        seek(cmd)
+      when /add chapter/
+        seek(cmd)
+      when "playlist_next"
+        load_file(@playlist.get_next, false)
+      when "playlist_prev"
+        load_file(@playlist.get_prev, false)
+      when "open_file_chooser"
+        open_file_chooser
+      when "cycle progress_bar"
+        toggle_progress_bar
+      when "quit_watch_later"
+        quit(true)
+      when "quit"
+        quit
+      else
+        @mpv.send(cmd) if cmd
+      end
+    end
+
+    def seek(cmd)
+      cmd = "no-osd " + cmd unless cmd.start_with?("no-osd") or
+                               not @progress_bar.visible?
+      @mpv.send(cmd)
+      @mpv.send("get_property time-pos")
+    end
+
+    def toggle_fullscreen
+      if window.state.fullscreen?
+        @progress_bar.show unless @progress_bar_user_hidden
+        unfullscreen
+        window.set_cursor(LEFT_PTR)
+      else
+        @progress_bar.hide unless @config["fullscreen_progressbar"]
+        fullscreen
+        window.set_cursor(BLANK_CURSOR)
+      end
+    end
+
+    def toggle_progress_bar
+      if @progress_bar.visible?
+        @progress_bar.hide
+        @progress_bar_user_hidden = true
+      else
+        @progress_bar.show
+        @progress_bar_user_hidden = false
+      end
+    end
+
+    def valid_video_file(x)
+      return (VIDEO_EXTS.include?(File.extname(x)) or
+              `file -b --mime-type "#{x}"`.start_with?("video"))
+    end
+
+
+    def open_file_chooser
+      dialog = Gtk::FileChooserDialog.new("Open File - #{PACKAGE}",
+                                          self, Gtk::FileChooser::ACTION_OPEN, nil,
+                                          [ Gtk::Stock::CANCEL, Gtk::Dialog::RESPONSE_CANCEL ],
+                                          [ Gtk::Stock::OPEN,   Gtk::Dialog::RESPONSE_ACCEPT ])
+      dialog.select_multiple = true
+      do_not_play = @playlist.count > 0
+
+      filter = Gtk::FileFilter.new
+      filter.name = "Video Files"
+      VIDEO_EXTS.each { |x| filter.add_pattern("*#{x}") }
+      dialog.add_filter(filter)
+
+      filterAll = Gtk::FileFilter.new
+      filterAll.name = "All Files"
+      filterAll.add_pattern("*.*")
+      dialog.add_filter(filterAll)
+
+      dialog.filenames.each { |x|
+        load_file(x, true, do_not_play)
+        do_not_play = true
+      } if dialog.run == Gtk::Dialog::RESPONSE_ACCEPT
+      dialog.destroy
+    end
+
+    def quit(watch_later=false)
+      @config["x"],
+      @config["y"],
+      @config["width"],
+      @config["height"]               = window.geometry unless window.state.fullscreen?
+      @config["playlist_x"],
+      @config["playlist_y"],
+      @config["playlist_width"],
+      @config["playlist_height"]      = @playlist.window.geometry
+      @config["playlist_visible"]     = @playlist.visible?
+      @config["playlist_selected"]    = @playing
+      @config["playlist"]             = @playlist.get_entries.join("|")
+      @config["progress_bar_visible"] = @progress_bar.visible?
+      File.open(MAIN_CONF, "w") { |file| @config.each { |k, v| file.puts("#{k}=#{v}") } }
+
+      @mpv.quit(@config["always_save_position"] ? true : watch_later)
+      Gtk.main_quit
+    end
+  end
+end
+

data/lib/ampv/mpvwidget.rb

@@ -0,0 +1,125 @@
+require "fifo"
+
+module Ampv
+  class MPvWidget < Gtk::EventBox
+
+    type_register
+    signal_new("file_changed", GLib::Signal::RUN_FIRST, nil, nil, String)
+    signal_new("length_changed", GLib::Signal::RUN_FIRST, nil, nil, Integer)
+    signal_new("time_pos_changed", GLib::Signal::RUN_FIRST, nil, nil, Float)
+    signal_new("stopped", GLib::Signal::RUN_FIRST, nil, nil)
+
+    def initialize(args, scrobbler)
+      if args.include?("--debug")
+        args.delete("--debug")
+        @debug = true
+      end
+
+      @scrobbler   = scrobbler
+      @mpv_path    = "/usr/bin/mpv"
+      @mpv_options = args.join(" ")
+      @mpv_fifo    = "/tmp/mpv.fifo." + Process.pid.to_s
+
+      super()
+
+      @socket = Gtk::Socket.new
+      @socket.modify_bg(Gtk::STATE_NORMAL, Gdk::Color.parse("#000"))
+
+      @socket.signal_connect("plug_removed") { signal_emit("stopped"); true }
+      add(@socket)
+    end
+
+    def start
+      if @thread.nil?
+        @fifo = Fifo.new(@mpv_fifo, :w, :nowait)
+
+        cmd = "#{@mpv_path} \
+          --identify \
+          --idle \
+          --input-file=#{@mpv_fifo} \
+          --no-mouse-movements \
+          --cursor-autohide=no \
+          --msglevel=all=2 \
+          --msglevel=global=4 \
+          --wid=#{@socket.id} #{@mpv_options}"
+        @thread = Thread.new { slave_reader(cmd) }
+      end
+    end
+
+    def send(cmd)
+      @fifo.puts(cmd) unless @fifo.nil?
+    end
+
+    def load_file(file, force_play=false)
+      send("loadfile \"#{file}\"")
+      @force_play = force_play
+    end
+
+    def play_pause
+      send("cycle pause")
+      @is_paused = @is_paused ? false : true
+    end
+
+    def quit(watch_later)
+      send("quit" + (watch_later ? "_watch_later" : ""))
+      @thread.join unless @thread.nil? or not @thread.alive?
+      @fifo.close
+      File.delete(@mpv_fifo)
+    end
+
+  private
+    def slave_reader(cmd)
+      @pipe = IO.popen(cmd, "a+")
+
+      until @pipe.nil? or @pipe.closed? or @pipe.eof?
+        line = @pipe.readline.chomp
+        if line.include?("ID_FILENAME=")
+          signal_emit("file_changed", (@playing = line.partition("ID_FILENAME=").last))
+          send("get_property pause") # saved position also saves play state
+
+          @prog_thread.kill unless @prog_thread.nil? or not @prog_thread.alive?
+          @prog_thread = Thread.new { progress_update }
+        elsif line.start_with?("ID_LENGTH=")
+          signal_emit("length_changed", (@length = line.rpartition("=").last.to_i))
+        elsif line.start_with?("ANS_pause=")
+          @is_paused = line.rpartition("=").last == "yes"
+          play_pause if @force_play and @is_paused
+        elsif line.start_with?("ANS_time-pos=")
+          signal_emit("time_pos_changed", line.rpartition("=").last.to_f)
+        end
+
+        if @debug or line.start_with?("Error")
+          puts(line) unless line.start_with?("ANS_time-pos=") or
+                            line.start_with?("ANS_ERROR") or
+                            line.start_with?("Failed to get") or
+                            line.start_with?("Command ")
+        end
+      end
+    end
+
+    def progress_update
+      scrobbled = false
+      watched = 0
+
+      while true
+        send("get_property time-pos") unless @is_paused
+
+        if not @scrobbler.nil? and not scrobbled and watched >= @length * 0.5
+          system("#{@scrobbler} \"#{@playing}\"")
+          scrobbled = true
+        end
+
+        sleep(1)
+        watched += 1 unless @is_paused
+      end
+    end
+
+    def signal_do_file_changed(file) end
+    def signal_do_length_changed(len) end
+    def signal_do_time_pos_changed(pos) end
+    def signal_do_stopped()
+      @prog_thread.kill
+    end
+  end
+end
+

data/lib/ampv/playlist.rb

@@ -0,0 +1,207 @@
+#require "gtk2"
+
+module Ampv
+  class Playlist < Gtk::Window
+
+    type_register
+    signal_new("play_entry", GLib::Signal::RUN_FIRST, nil, nil, String)
+    signal_new("playing_removed", GLib::Signal::RUN_FIRST, nil, nil)
+    signal_new("open_file_chooser", GLib::Signal::RUN_FIRST, nil, nil)
+
+    def initialize(x, y, w, h, is_visible)
+      buttons = {
+        [ Gtk::Stock::OPEN,    "Add to Playlist" ] => lambda { signal_emit("open_file_chooser") },
+        [ Gtk::Stock::GO_UP,   "Move Up"         ] => lambda { move_selected_up                 },
+        [ Gtk::Stock::GO_DOWN, "Move Down"       ] => lambda { move_selected_down               },
+        [ Gtk::Stock::REMOVE,  "Remove Selected" ] => lambda { remove_selected                  },
+        [ Gtk::Stock::CLEAR,   "Clear Playlist"  ] => lambda { clear                            }
+      }
+
+      super()
+      set_title("Playlist - #{PACKAGE}")
+      set_default_size(w, h)
+      set_skip_taskbar_hint(true)
+      move(x, y)
+
+      Gtk::Drag.dest_set(self, Gtk::Drag::DEST_DEFAULT_ALL,
+                         [ [ "text/uri-list", 0, 0 ] ],
+                         Gdk::DragContext::ACTION_LINK)
+
+      signal_connect("show") { move(@pos[0], @pos[1]) unless @pos.nil? }
+      signal_connect("hide") { @pos = window.root_origin }
+      signal_connect("delete_event") { hide_on_delete }
+
+      signal_connect("key_press_event") { |_w, e|
+        hide_on_delete if e.keyval == Gdk::Keyval::GDK_Escape
+      }
+
+      vbox = Gtk::VBox.new(false, 10)
+      vbox.border_width = 10
+      add(vbox)
+
+      sw = Gtk::ScrolledWindow.new
+      sw.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC)
+      vbox.pack_start(sw)
+
+      @model    = Gtk::ListStore.new(String, String)
+      @treeview = Gtk::TreeView.new(@model)
+      @treeview.enable_search  = false
+      @treeview.rubber_banding = true
+      @treeview.reorderable = true
+      @treeview.selection.mode = Gtk::SELECTION_MULTIPLE
+
+      @treeview.signal_connect("row_activated") { |_w, p, c|
+        signal_emit("play_entry", @model.get_iter(p)[0])
+      }
+      @treeview.signal_connect("key_press_event") { |_w, e|
+        remove_selected if e.keyval == Gdk::Keyval::GDK_Delete
+      }
+      @treeview.signal_connect("button_press_event") { |_w, e|
+        @menu.popup(nil, nil, e.button, e.time) if
+          e.event_type == Gdk::Event::BUTTON_PRESS and e.button == 3
+      }
+
+      ["Name", "Length"].each_with_index { |_x, i|
+        renderer = Gtk::CellRendererText.new
+        column   = Gtk::TreeViewColumn.new(_x,
+                                           renderer,
+                                           :text => i)
+        if _x == "Name"
+          renderer.ellipsize = Pango::ELLIPSIZE_MIDDLE
+          column.expand = true
+          column.set_cell_data_func(renderer) { |t, c, m, j|
+            c.text = File.basename(m.get_value(j, 0)) unless m.get_value(j, 0).nil?
+          }
+        end
+
+        @treeview.append_column(column)
+      }
+
+      sw.add(@treeview)
+
+      hbox = Gtk::HBox.new(true, 5)
+
+      buttons.each { |k, v|
+        button = Gtk::Button.new
+        button.image = Gtk::Image.new(k[0], Gtk::IconSize::BUTTON)
+        button.height_request = 36
+        button.set_tooltip_text(k[1])
+        button.signal_connect("clicked") { v.call }
+        hbox.pack_start(button)
+      }
+
+      vbox.pack_start(hbox, false)
+
+      @menu = Gtk::Menu.new
+      buttons.each { |k, v|
+        item = Gtk::ImageMenuItem.new(k[1])
+        item.image = Gtk::Image.new(k[0], Gtk::IconSize::MENU)
+        item.signal_connect("activate") { v.call }
+        @menu.append(item)
+      }
+      @menu.show_all
+
+      show_all if is_visible
+    end
+
+    def count
+      i = 0
+      @model.each { i += 1 }
+      return i
+    end
+
+    def add_file(file)
+      contains = false
+      @model.each { |m, p, iter|
+        if iter[0] == file
+          contains = true
+          break
+        end
+      }
+      unless contains
+        iter = @model.append
+        iter[0] = file
+      end
+    end
+
+    def move_selected_up
+      @treeview.selection.selected_rows.each { |path|
+        tmp = path.dup
+        break if not tmp.prev! or @treeview.selection.selected_rows.include?(tmp)
+        @model.move_before(@model.get_iter(path), @model.get_iter(tmp))
+      }
+    end
+
+    def move_selected_down
+      @treeview.selection.selected_rows.reverse.each { |path|
+        break if @treeview.selection.selected_rows.include?((tmp = path.dup.next!))
+        tmp = @model.get_iter(tmp)
+        @model.move_after(@model.get_iter(path), tmp) unless tmp.nil?
+      }
+    end
+
+    def remove_selected
+      to_remove = [ ]
+      @treeview.selection.selected_rows.each { |path|
+        to_remove.push(@model.get_iter(path))
+      }
+      to_remove.each { |iter|
+        signal_emit("playing_removed") if iter[0] == @playing
+        @model.remove(iter)
+      }
+    end
+
+    def get_next
+      @model.each { |m, p, iter|
+        return iter.next! ? iter[0] : nil if iter[0] == @playing
+      }
+      return nil
+    end
+
+    def get_prev
+      prev = nil
+      @model.each { |m, p, iter|
+        return prev if iter[0] == @playing
+        prev = iter[0]
+      }
+    end
+
+    def get_entries
+      entries = [ ]
+      @model.each { |m, p, iter| entries.push(iter[0]) }
+      return entries
+    end
+
+    def clear
+      @model.clear
+      signal_emit("playing_removed")
+    end
+
+    def set_selected(file)
+      @playing = file
+      i = 0
+      @model.each { |m, p, iter|
+        if iter[0] == @playing
+          @treeview.set_cursor(Gtk::TreePath.new(i), nil, false)
+          break
+        end
+        i += 1
+      }
+    end
+
+    def update_length(length)
+      @model.each { |m, p, iter|
+        if iter[0] == @playing
+          iter[1] = Time.at(length).utc.strftime("%H:%M:%S") unless length == 0
+          break
+        end
+      }
+    end
+
+  private
+    def signal_do_play_entry(file) end
+    def signal_do_playing_removed() end
+    def signal_do_open_file_chooser() end
+  end
+end
+

data/lib/ampv/progressbarwidget.rb

@@ -0,0 +1,36 @@
+
+module Ampv
+  class ProgressBarWidget < Gtk::DrawingArea
+    def initialize(bar_color, head_color, height)
+      super()
+      modify_bg(Gtk::STATE_NORMAL, Gdk::Color.parse("#000"))
+      set_height_request(height)
+
+      signal_connect("expose_event") {
+        @cx = window.create_cairo_context
+        draw_widget
+      }
+      @value      = 0
+      @bar_color  = bar_color
+      @head_color = head_color
+    end
+
+    def draw_widget
+      @cx.set_source_color(@bar_color)
+      @cx.rectangle(0, 0, allocation.width * @value.to_f, allocation.height)
+      @cx.fill
+
+      if @value > 0
+        @cx.set_source_color(@head_color)
+        @cx.rectangle(allocation.width * @value.to_f, 0, 2, allocation.height)
+        @cx.fill
+      end
+    end
+
+    def value=(v)
+      @value = v
+      queue_draw
+    end
+  end
+end
+

data/lib/ampv/version.rb

@@ -0,0 +1,6 @@
+
+module Ampv
+  PACKAGE = "ampv"
+  VERSION = "1.0.0"
+end
+

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: ampv
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- ahoka
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gtk2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby-fifo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A minimal GTK2 mpv frontend.
+email: 
+executables:
+- ampv
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- input.conf
+- lib/ampv/version.rb
+- lib/ampv/playlist.rb
+- lib/ampv/progressbarwidget.rb
+- lib/ampv/mpvwidget.rb
+- lib/ampv.rb
+- bin/ampv
+homepage: https://github.com/ahodesuka/ampv
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- gtk2
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: ampv
+test_files: []