screencaster-gtk 0.0.3.alpha1

data/bin/screencaster

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "screencaster-gtk"
+
+app = ScreencasterGtk.new
+app.set_up
+app.main

data/lib/screencaster-gtk.rb

@@ -0,0 +1,462 @@
+require 'gtk2'
+require 'logger'
+require 'fileutils'
+require 'getoptlong'
+require "screencaster-gtk/capture"
+require "screencaster-gtk/savefile"
+
+##########################
+
+
+class ScreencasterGtk
+  attr_reader :capture_window, :window
+  attr_writer :status_icon
+    
+  SCREENCASTER_DIR = File.join(Dir.home, ".screencaster")
+  # Set up logging. Keep 5 log files of a 100K each
+  log_dir = File.join(SCREENCASTER_DIR, 'log')
+  FileUtils.mkpath log_dir
+  LOGGER = Logger.new(File.join(log_dir, 'screencaster.log'), 5, 100000)
+  LOGGER.level = Logger::DEBUG
+  
+  PIDFILE = File.join(SCREENCASTER_DIR, "run", "screencaster.pid")
+
+  DEFAULT_SPACE = 10
+
+  def initialize
+    #### Create Main Window
+    
+    LOGGER.info "Started"
+
+    @window = Gtk::Window.new
+    @window.signal_connect("delete_event") {
+      LOGGER.debug "delete event occurred"
+      #true
+      self.quit
+      false
+    }
+    
+    @window.signal_connect("destroy") {
+      LOGGER.debug "destroy event occurred"
+    }
+    
+    # The following gets minimize and restore events, but not iconify and de-iconify 
+    @window.signal_connect("window_state_event") { |w, e|
+      puts ("window_state_event #{e.to_s}")
+    }
+    
+    @window.border_width = DEFAULT_SPACE
+    
+    bottom_columns = Gtk::HBox.new(false, ScreencasterGtk::DEFAULT_SPACE) # children have different sizes, spaced by DEFAULT_SPACE
+    
+    @select_button = Gtk::Button.new("Select Window to Record")
+    @select_button.signal_connect("clicked") {
+      self.select
+    }
+    bottom_columns.pack_start(@select_button, true, false)
+    
+    button = Gtk::Button.new("Quit")
+    button.signal_connect("clicked") {
+      self.quit
+    }
+    bottom_columns.pack_end(button, true, false)
+    
+    bottom_row = Gtk::VBox.new(false, ScreencasterGtk::DEFAULT_SPACE) # children have different sizes, spaced by DEFAULT_SPACE
+    bottom_row.pack_end(bottom_columns, false)
+    
+    control_columns = Gtk::HBox.new(false, ScreencasterGtk::DEFAULT_SPACE) # children have different sizes, spaced by DEFAULT_SPACE
+    
+    @record_button = Gtk::Button.new("Record")
+    @record_button.sensitive = false
+    @record_button.signal_connect("clicked") {
+      self.record
+    }
+    control_columns.pack_start(@record_button, true, false)
+    
+    @pause_button = Gtk::Button.new("Pause")
+    @pause_button.sensitive = false
+    @pause_button.signal_connect("clicked") {
+      self.pause
+    }
+    control_columns.pack_start(@pause_button, true, false)
+    
+    @stop_button = Gtk::Button.new("Stop")
+    @stop_button.sensitive = false
+    @stop_button.signal_connect("clicked") {
+      self.stop_recording
+    }
+    control_columns.pack_start(@stop_button, true, false)
+    
+    control_row = Gtk::VBox.new(false, ScreencasterGtk::DEFAULT_SPACE) # children have different sizes, spaced by DEFAULT_SPACE
+    control_row.pack_start(control_columns, true, false)
+    
+    columns = Gtk::HBox.new(false, ScreencasterGtk::DEFAULT_SPACE)
+    @progress_bar = Gtk::ProgressBar.new
+    columns.pack_start(@progress_bar, true, false)
+    
+    @cancel_button = Gtk::Button.new("Cancel")
+    @cancel_button.sensitive = false
+    @cancel_button.signal_connect("clicked") {
+      self.stop_encoding
+    }
+    columns.pack_start(@cancel_button, true, false)
+    
+    progress_row = Gtk::VBox.new(false, ScreencasterGtk::DEFAULT_SPACE) # children have different sizes, spaced by DEFAULT_SPACE
+    progress_row.pack_start(columns, true, false)
+    
+    the_box = Gtk::VBox.new(false, ScreencasterGtk::DEFAULT_SPACE)
+    the_box.pack_end(bottom_row, false, false)
+    the_box.pack_end(progress_row, false, false)
+    the_box.pack_end(control_row, false, false)
+    
+    @window.add(the_box)
+
+    ##### Done Creating Main Window
+    
+    #### Accelerator Group
+    group = Gtk::AccelGroup.new
+    group.connect(Gdk::Keyval::GDK_N, Gdk::Window::CONTROL_MASK|Gdk::Window::MOD1_MASK, Gtk::ACCEL_VISIBLE) do
+      #puts "You pressed 'Ctrl+Alt+n'"
+    end
+
+    #### Pop up menu on right click
+
+    @select = Gtk::ImageMenuItem.new("Select Window")
+    @select.signal_connect('activate'){self.select}
+
+    @record = Gtk::ImageMenuItem.new(Gtk::Stock::MEDIA_RECORD)
+    @record.signal_connect('activate'){self.record}
+    @record.add_accelerator('activate', 
+      group, Gdk::Keyval::GDK_R,
+      Gdk::Window::CONTROL_MASK | Gdk::Window::MOD1_MASK, 
+      Gtk::ACCEL_VISIBLE)
+    @pause = Gtk::ImageMenuItem.new(Gtk::Stock::MEDIA_PAUSE)
+    @pause.signal_connect('activate'){self.pause}
+    @pause.add_accelerator('activate', 
+      group, Gdk::Keyval::GDK_P,
+      Gdk::Window::CONTROL_MASK | Gdk::Window::MOD1_MASK, 
+      Gtk::ACCEL_VISIBLE)
+    @stop = Gtk::ImageMenuItem.new(Gtk::Stock::MEDIA_STOP)
+    @stop.signal_connect('activate'){self.stop}
+    @stop.add_accelerator('activate', 
+      group, Gdk::Keyval::GDK_S,
+      Gdk::Window::CONTROL_MASK | Gdk::Window::MOD1_MASK, 
+      Gtk::ACCEL_VISIBLE)
+    @show_hide = Gtk::MenuItem.new("Hide")
+    @show_hide.signal_connect('activate'){self.show_hide_all}
+
+    quit = Gtk::ImageMenuItem.new(Gtk::Stock::QUIT)
+    quit.signal_connect('activate'){self.quit}
+
+    @menu = Gtk::Menu.new
+    @menu.append(@select)
+    
+    @menu.append(Gtk::SeparatorMenuItem.new)
+    @menu.append(@record)
+    @menu.append(@pause)
+    @menu.append(@stop)
+    
+    @menu.append(Gtk::SeparatorMenuItem.new)
+    @menu.append(@show_hide)
+    
+    @menu.append(Gtk::SeparatorMenuItem.new)
+    @menu.append(quit)
+    
+    @menu.show_all
+
+    #### Done Menus
+    
+    #### Attach accelerators to window
+    #root = Gdk::Window.default_root_window
+    @window.add_accel_group(group)
+  end
+  
+  #### Status Icon
+  def status_icon
+    return @status_icon unless @status_icon.nil?
+    
+    @status_icon = Gtk::StatusIcon.new
+    # Some space appears in the tray immediately, so hide it.
+    # The icon doesn't actually appear until you start Gtk.main
+    @status_icon.visible = false
+    @status_icon.stock = Gtk::Stock::MEDIA_RECORD
+    @status_icon.tooltip = 'Screencaster'
+
+    ##Show menu on right click
+    @status_icon.signal_connect('popup-menu'){|tray, button, time| @menu.popup(nil, nil, button, time)}
+    
+    @status_icon
+  end
+  
+  #### Done Status Icon
+  
+  def quit
+    LOGGER.debug "Quitting"
+    # self.status_icon.destroy
+    # LOGGER.debug "After status icon destroy."
+    # @window.destroy
+    # LOGGER.debug "After window destroy."
+    # We don't want to destroy here because the object continues to exist
+    # Just hide everything
+    self.hide_all_including_status
+    # self.status_icon.hide doesn't work/exist
+    Gtk.main_quit 
+    LOGGER.debug "After main_quit."
+  end
+  
+  def select
+    LOGGER.debug "Selecting Window"
+    @capture_window = Capture.new
+    @capture_window.get_window_to_capture
+    @record_button.sensitive = true
+  end
+  
+  def record
+    LOGGER.debug "Recording"
+    recording
+    @capture_window.record
+  end
+  
+  def pause
+    LOGGER.debug "Pausing"
+    paused
+    @capture_window.pause_recording
+  end
+  
+  def stop_recording
+    LOGGER.debug "Stopped"
+    not_recording
+    @capture_window.stop_recording
+    
+    SaveFile.get_file_to_save { |filename|
+      encoding
+      @capture_window.encode(filename) { |percent, time_remaining| 
+        @progress_bar.fraction = percent 
+        @progress_bar.text = time_remaining
+        LOGGER.debug "Did progress #{percent.to_s} time remaining: #{time_remaining}"
+        percent < 1 || stop_encoding
+      }
+      LOGGER.debug "Back from encode"
+    }
+  end
+  
+  def stop_encoding
+    LOGGER.debug "Cancelled encoding"
+    not_recording
+    @capture_window.stop_encoding
+  end
+  
+  def stop
+    case @capture_window.state
+    when :recording || :paused
+      stop_recording
+    when :encoding
+      stop_encoding
+    when :stopped
+      # Do nothing
+    else
+      LOGGER.error "#{__FILE__} #{__LINE__}: Can't happen."
+    end
+  end
+  
+  def toggle_recording
+    LOGGER.debug "Toggle recording"
+    return if @capture_window.nil?
+    case @capture_window.state
+    when :recording
+      pause
+    when :paused
+      record
+    when :encoding
+      stop_encoding
+    when :stopped
+      # Do nothing
+    else
+      LOGGER.error "#{__FILE__} #{__LINE__}: Can't happen."
+    end
+  end
+  
+  def recording
+    self.status_icon.stock = Gtk::Stock::MEDIA_STOP
+    @select.sensitive = @select_button.sensitive = false
+    @pause.sensitive = @pause_button.sensitive = true
+    @stop.sensitive = @stop_button.sensitive = true
+    @record.sensitive = @record_button.sensitive = false
+    @cancel_button.sensitive = false
+  end
+  
+  def not_recording
+    self.status_icon.stock = Gtk::Stock::MEDIA_RECORD
+    @select.sensitive = @select_button.sensitive = true
+    @pause.sensitive = @pause_button.sensitive = false
+    @stop.sensitive = @stop_button.sensitive = false
+    @record.sensitive = @record_button.sensitive = ! @capture_window.nil?
+    @cancel_button.sensitive = false
+  end
+  
+  def paused
+    self.status_icon.stock = Gtk::Stock::MEDIA_RECORD
+    @select.sensitive = @select_button.sensitive = false
+    @pause.sensitive = @pause_button.sensitive = false
+    @stop.sensitive = @stop_button.sensitive = true
+    @record.sensitive = @record_button.sensitive = ! @capture_window.nil?
+    @cancel_button.sensitive = true
+  end
+  
+  def encoding
+    self.status_icon.stock = Gtk::Stock::MEDIA_STOP
+    @pause.sensitive = @pause_button.sensitive = false
+    @stop.sensitive = @stop_button.sensitive = false
+    @record.sensitive = @record_button.sensitive = false
+    @cancel_button.sensitive = true
+  end
+  
+  def not_encoding
+    not_recording
+  end
+  
+  def show_all
+    @show_hide.label = "Hide"
+    @show_hide_state = :show
+    @window.show_all
+  end
+  
+  def hide_all
+    @show_hide.label = "Show"
+    @show_hide_state = :hide
+    @window.hide_all
+  end
+  
+  def show_hide_all
+    case @show_hide_state
+    when :show
+      self.hide_all
+    when :hide
+      self.show_all
+    else
+      logger.error("#{__FILE__} (#{__LINE__} @show_hide_state: #{@show_hide_state.to_s}")
+    end
+  end
+  
+  def show_all_including_status
+    self.show_all
+    self.status_icon.visible = true
+  end
+  
+  def hide_all_including_status
+    self.hide_all
+    self.status_icon.visible = false
+  end
+  
+  def main
+    LOGGER.info "Starting"
+    self.not_recording
+    self.show_all_including_status
+    Gtk.main
+    LOGGER.info "Finished"
+  end
+  
+  def set_up
+    # Don't run the program if there's another instance running for the user.
+    # If there's another instance running for the user and the --pause or --start 
+    # flags are present, send the USR1 signal to the running instance
+    # and exit.
+    # If there's no other instance running for the user, and the --pause or --start 
+    # flags are not present, start normally.
+    
+    output_file = "/home/reid/test-key.log"
+    
+    ScreencasterGtk::LOGGER.debug("pid_file is #{PIDFILE}")
+    
+    if File.exists? PIDFILE
+      begin
+        f = File.new(PIDFILE)
+        ScreencasterGtk::LOGGER.debug("Opened PIDFILE")
+        existing_pid = f.gets
+        existing_pid = existing_pid.to_i
+        f.close
+        ScreencasterGtk::LOGGER.debug("existing_pid = #{existing_pid.to_s}")
+      rescue StandardError
+        LOGGER.error("File to read #{PIDFILE}")
+        exit 1
+      end
+    else
+      existing_pid = nil
+    end
+    
+    opts = GetoptLong.new(
+      [ '--help', '-h', GetoptLong::NO_ARGUMENT ],
+      [ '--pause', GetoptLong::NO_ARGUMENT ],
+      [ '--start', GetoptLong::NO_ARGUMENT ]
+    )
+    
+    opts.each do |opt, arg|
+      case opt
+        when '--help'
+          puts <<-EOF
+    screencaster [OPTION] ... 
+    
+    -h, --help:
+       show help
+    
+    -s, -p, --start, --pause:
+      Pause a running capture, or restart a paused capture
+          EOF
+          exit 0
+        when '--pause' || '--start'
+          if existing_pid then
+            ScreencasterGtk::LOGGER.debug("Got a pause for PID #{existing_pid}")
+            begin
+              Process.kill "USR1", existing_pid
+              exit 0
+            rescue SystemCallError
+              LOGGER.info("Got a pause but PID #{existing_pid} didn't exist")
+              exit 1
+            end
+          else
+            ScreencasterGtk::LOGGER.info("Got a pause but no PID")
+            exit 1
+          end 
+      end
+    end
+    
+    # TODO: Check for running process and if not, ignore PIDFILE.
+    (ScreencasterGtk::LOGGER.debug("Can't run two instances at once."); exit 1) if ! existing_pid.nil?
+    
+    @chain = Signal.trap("EXIT") { 
+      LOGGER.debug "In ScreencasterGtk exit handler @chain: #{@chain}"
+      ScreencasterGtk::LOGGER.debug("Exiting")
+      ScreencasterGtk::LOGGER.debug("unlinking") if File.file?(PIDFILE)
+      File.unlink(PIDFILE) if File.file?(PIDFILE)
+      `gconftool-2 --unset /apps/metacity/keybinding_commands/screencaster_pause`
+      `gconftool-2 --unset /apps/metacity/global_keybindings/run_screencaster_pause`
+      LOGGER.debug "About to call next trap with @chain: #{@chain}"
+      @chain.call unless @chain.nil?
+    }
+    LOGGER.debug "ScreencasterGtk.whatever @chain: #{@chain}"
+
+    `gconftool-2 --set /apps/metacity/keybinding_commands/screencaster_pause --type string "screencaster --pause"`
+    `gconftool-2 --set /apps/metacity/global_keybindings/run_screencaster_pause --type string "<Control><Alt>S"`
+
+    begin
+      FileUtils.mkpath(File.dirname(PIDFILE))
+      f = File.new(PIDFILE, "w")
+      f.puts(Process.pid.to_s)
+      f.close
+      LOGGER.debug("Wrote PID #{Process.pid}")
+    rescue StandardError
+      LOGGER.error("Failed to write #{PIDFILE}")
+      exit 1
+    end
+    
+    Signal.trap("USR1") { 
+      ScreencasterGtk::LOGGER.debug("Pause/Resume") 
+      self.toggle_recording
+    }
+    
+    $logger = ScreencasterGtk::LOGGER # TODO: Fix logging
+  end
+end
+
+#puts "Loaded #{__FILE__}"
+

data/lib/screencaster-gtk/capture.rb

@@ -0,0 +1,292 @@
+require 'open3'
+require 'logger'
+require "screencaster-gtk/progresstracker"
+
+class Capture
+  include ProgressTracker
+  
+  attr_writer :left, :top, :right, :bottom
+  attr_reader :state
+  attr :pid
+  attr :tmp_files
+  
+  def initialize
+    @tmp_files = []
+    @exit_chain = Signal.trap("EXIT") { 
+      self.cleanup
+      $logger.debug "In capture about to chain to trap @exit_chain: #{@exit_chain}"
+      @exit_chain.call unless @exit_chain.nil? 
+    }
+    $logger.debug "@exit_chain: #{@exit_chain.to_s}"
+    @state = :stopped
+  end
+  
+  def current_tmp_file
+    @tmp_files.last
+  end
+  
+  def new_tmp_file
+    @tmp_files << Capture.tmp_file_name(@tmp_files.size)
+    self.current_tmp_file
+  end
+  
+  def self.tmp_file_name(index = nil)
+    "/tmp/screencaster_#{$$}" + (index.nil? ? "": "_#{"%04d" % index}") + ".mkv"
+  end
+  
+  def self.format_input_files_for_mkvmerge(files)
+    files.drop(1).inject("\"#{files.first}\"") {|a, b| "#{a} + \"#{b}\"" }
+  end
+    
+  def width
+    @right - @left
+  end
+  
+  def height=(h)
+    @bottom = @top + h
+    h
+  end
+  
+  def height
+    @bottom - @top
+  end
+  
+  def width=(w)
+    @right = @left + w
+    w
+  end
+  
+  # I have to refactor this to make it more testable. 
+  # As a general approach, I want to factor out the parts that have human input
+  # so that whatever I have to do for that is as small as possible.
+
+  def get_window_to_capture
+    print "Click in the window you want to capture.\n"
+    info = `xwininfo`
+    
+    info =~ /Window id: (0x[[:xdigit:]]+)/
+    window_id = $1
+    
+    info =~ /geometry\s+([[:digit:]])+x([[:digit:]]+)\+([[:digit:]]+)-([[:digit:]]+)/
+    
+    info =~ /Absolute upper-left X:\s+([[:digit:]]+)/
+    @left = $1.to_i
+    info =~ /Absolute upper-left Y:\s+([[:digit:]]+)/
+    @top = $1.to_i
+    
+    info =~ /Width:\s+([[:digit:]]+)/
+    @width = $1.to_i
+    info =~ /Height:\s+([[:digit:]]+)/
+    @height = $1.to_i
+    
+    $logger.debug "Before xprop: Capturing #{@left.to_s},#{@top.to_s} to #{(@left+@width).to_s},#{(@top+@height).to_s}. Dimensions #{@width.to_s},#{@height.to_s}.\n"
+    
+    # Use xprop on the window to figure out decorations? Maybe...
+    # $logger.debug "Window ID: #{window_id}"
+    # info = `xprop -id #{window_id}`
+    # info =~ /_NET_FRAME_EXTENTS\(CARDINAL\) = ([[:digit:]]+), ([[:digit:]]+), ([[:digit:]]+), ([[:digit:]]+)/
+    # border_left = $1.to_i
+    # border_right = $2.to_i
+    # border_top = $3.to_i
+    # border_bottom = $4.to_i
+    # 
+    # $logger.debug "Borders: #{border_left.to_s},#{border_top.to_s},#{border_right.to_s},#{border_bottom.to_s}.\n"
+    # 
+    # top += border_top
+    # left += border_left
+    # height -= border_top + border_bottom
+    # width -= border_left + border_right
+    
+    @height +=  @height % 2
+    @width += @width % 2
+
+    $logger.debug "Capturing #{@left},#{@top} to #{@left+@width},#{@top+@height}. Dimensions #{@width},#{@height}.\n"
+  end
+  
+  def record
+    if @state != :paused
+      @tmp_files = [] 
+      self.total_amount = 0.0
+    end
+    record_one_file(self.new_tmp_file)
+  end
+  
+  def record_one_file(output_file)
+    @state = :recording
+    capture_fps=24
+    audio_options="-f alsa -ac 1 -ab 192k -i pulse -acodec pcm_s16le"
+    
+    # And i should probably popen here, save the pid, then fork and start
+    # reading the input, updating the number of frames saved, or the time
+    # recorded.
+    $logger.debug "Capturing...\n"
+    # @pid = Process.spawn("avconv \
+        # #{audio_options} \
+        # -f x11grab \
+        # -show_region 1 \
+        # -r #{capture_fps} \
+        # -s #{@width}x#{@height} \
+        # -i :0.0+#{@left},#{@top} \
+        # -qscale 0 -vcodec ffv1 \
+        # -y \
+        # #{TMP_FILE}")
+    # Process.detach(@pid)
+    # avconv writes output to stderr, why?
+    # writes with CR and not LF, so it's hard to read
+    # with popen and 2>&1, an extra shell gets created that messed things up.
+    # popen2e helps.
+    vcodec = 'huffyuv' # I used to use ffv1
+    
+    cmd_line = "avconv \
+      #{audio_options} \
+      -f x11grab \
+      -show_region 1 \
+      -r #{capture_fps} \
+      -s #{@width}x#{@height} \
+      -i :0.0+#{@left},#{@top} \
+      -qscale 0 -vcodec #{vcodec} \
+      -y \
+      #{output_file}"
+    
+    $logger.debug cmd_line
+
+    i, oe, t = Open3.popen2e(cmd_line)
+    @pid = t.pid
+    Process.detach(@pid)
+    
+    duration = 0.0
+    Thread.new do
+      while line = oe.gets("\r")
+        $logger.debug "****" + line
+        if (line =~ /time=([0-9]*\.[0-9]*)/)
+          duration = $1.to_f
+        end
+      end
+      self.total_amount += duration
+    end
+  end
+  
+  def stop_recording
+    begin
+      Process.kill("INT", @pid)
+    rescue SystemCallError
+      $logger.error("No recording to stop.") unless @state == :paused
+    end
+    @state = :stopped
+  end
+
+  def pause_recording
+    begin
+      Process.kill("INT", @pid)
+    rescue SystemCallError
+      $logger.error("No recording to pause.")
+    end
+    @state = :paused
+  end
+
+  # Refactoring this to make it more testable and so it works:
+  # Encoding now has two steps: Merge the files (if more than one)
+  # and then encode
+  # Encode takes an optional block that updates a progress bar or other type
+  # of status
+  # I believe I have to split it out so that variables are in scope when I 
+  # need them to be, but mainly I need to make this testable, and now is the time.
+  
+  def encode(output_file = "output.mp4", &feedback)
+    state = :encoding
+    output_file =~ /.mp4$/ || output_file += ".mp4"
+    
+    $logger.debug "Encoding #{Capture.format_input_files_for_mkvmerge(@tmp_files)}...\n"
+    $logger.debug("Total duration #{self.total_amount.to_s}")
+
+    t = self.merge(Capture.tmp_file_name, @tmp_files)
+    t.value
+    self.final_encode(output_file, Capture.tmp_file_name, feedback)
+  end 
+  
+  # This is ugly.
+  # When you open co-processes, they do get stuck together.
+  # It seems the if I don't read what's coming out of the co-process, it waits.
+  # But if I read it, then it goes right to the end until it returns.
+  
+  def merge(output_file, input_files, feedback = proc {} )
+    $logger.debug("Merging #{input_files.size.to_s} files: #{Capture.format_input_files_for_mkvmerge(input_files)}")
+    
+    if input_files.size == 1
+      cmd_line = "cp #{input_files[0]} #{output_file}"
+      #cmd_line = "sleep 5"
+    else
+      cmd_line = "mkvmerge -v -o #{output_file} #{Capture.format_input_files_for_mkvmerge(input_files)}"
+    end
+    $logger.debug "Merge command line: #{cmd_line}"
+    i, oe, t = Open3.popen2e(cmd_line)
+    @pid = t.pid
+    Process.detach(@pid)
+    $logger.debug "@pid: #{@pid.to_s}"
+    
+    t = Thread.new do
+      # $logger.debug "Sleeping..."
+      # sleep 2
+      # $logger.debug "Awake!"
+      while oe.gets do
+        # $logger.debug "Line"
+      end
+      feedback.call 1.0, "Done"
+    end
+    return t
+  end
+  
+  def final_encode(output_file, input_file, feedback = proc {} )
+    encode_fps=24
+    video_encoding_options="-vcodec libx264 -pre:v ultrafast"
+    
+    # I think I want to popen here, save the pid, then fork and start
+    # updating progress based on what I read, which the main body
+    # returns and carries on.
+    
+    # The following doesn't seem to be necessary
+#      -s #{@width}x#{@height} \
+    cmd_line = "avconv \
+      -i #{input_file} \
+      #{video_encoding_options} \
+      -r #{encode_fps} \
+      -threads 0 \
+      -y \
+      '#{output_file}'"
+      
+    $logger.debug cmd_line
+    
+    i, oe, t = Open3.popen2e(cmd_line)
+    @pid = t.pid
+    Process.detach(@pid)
+    
+    Thread.new do
+      while (line = oe.gets("\r"))
+        $logger.debug "****" + line
+        if (line =~ /time=([0-9]*\.[0-9]*)/) 
+          $logger.debug '******' + $1
+          self.current_amount = $1.to_f
+        end
+        $logger.debug "******** #{self.current_amount} #{self.fraction_complete}"
+        feedback.call self.fraction_complete, self.time_remaining_s
+      end
+      $logger.debug "reached end of file"
+      @state = :stopped
+      feedback.call self.fraction_complete = 1, self.time_remaining_s
+    end
+  end
+  
+  def stop_encoding
+    begin
+      Process.kill("INT", @pid)
+    rescue SystemCallError
+      $logger.error("No encoding to stop.")
+    end
+  end
+
+  def cleanup
+    @tmp_files.each { |f| File.delete(f) if File.exists?(f) }
+    File.delete(Capture.tmp_file_name) if File.exists?(Capture.tmp_file_name)
+  end
+end
+

data/lib/screencaster-gtk/progresstracker.rb

@@ -0,0 +1,45 @@
+module ProgressTracker
+  attr_reader :start_time
+  attr_writer :start_time, :total_amount
+  
+  def percent_complete
+    self.fraction_complete * 100
+  end
+  
+  def fraction_complete
+    [ self.current_amount.to_f / self.total_amount.to_f, 1.0 ].min
+  end
+    
+  def fraction_complete=(fraction)
+    @current_amount = fraction * self.total_amount
+  end
+
+  def current_amount
+    @current_amount || 0.0
+  end
+
+  def current_amount=(amt)
+    @start_time || @start_time = Time.new
+
+    # puts "Setting current_amount #{amt}"
+    @current_amount = amt
+  end
+  
+  def total_amount
+    @total_amount || 1.0
+  end
+  
+  def time_remaining
+    (Time.new - @start_time) * (1 - self.fraction_complete) / self.fraction_complete
+  end
+  
+  def time_remaining_s(format = "%dh %02dm %02ds remaining")
+    t = self.time_remaining
+    h = (t / 3600).to_i
+    m = ((t - h * 3600) / 60).to_i
+    s = (t % 60).to_i
+    sprintf(format, h, m, s)
+  end
+  
+end
+

data/lib/screencaster-gtk/savefile.rb

@@ -0,0 +1,75 @@
+require 'gtk2'
+
+class SaveFile
+  def self.set_up_dialog(file_name = "output.mp4")
+    @dialog = Gtk::FileChooserDialog.new(
+        "Save File As ...",
+        $window,
+        Gtk::FileChooser::ACTION_SAVE,
+        nil,
+        [ Gtk::Stock::CANCEL, Gtk::Dialog::RESPONSE_CANCEL ],
+        [ Gtk::Stock::SAVE, Gtk::Dialog::RESPONSE_ACCEPT ]
+    )
+    # dialog.signal_connect('response') do |w, r|
+      # odg = case r
+        # when Gtk::Dialog::RESPONSE_ACCEPT
+          # filename = dialog.filename
+          # "'ACCEPT' (#{r}) button pressed -- filename is {{ #{filename} }}"
+        # when Gtk::Dialog::RESPONSE_CANCEL;   "'CANCEL' (#{r}) button pressed"
+        # else; "Undefined response ID; perhaps Close-x? (#{r})"
+      # end
+      # puts odg
+      # dialog.destroy 
+    # end
+    @dialog.current_name = GLib.filename_to_utf8(file_name)
+    @dialog.current_folder = GLib.filename_to_utf8(Dir.getwd)
+    @dialog.do_overwrite_confirmation = true
+  end
+  
+  def self.get_file_to_save
+    @dialog || SaveFile.set_up_dialog
+    result = @dialog.run
+    file_name = @dialog.filename
+    case result
+      when Gtk::Dialog::RESPONSE_ACCEPT
+        @dialog.hide
+        yield file_name
+      when Gtk::Dialog::RESPONSE_CANCEL
+        self.confirm_cancel(@dialog)
+        @dialog.hide
+      else
+        LOGGER.error("Can't happen #{__FILE__} line: #{__LINE__}")
+        @dialog.hide
+    end
+  end
+  
+  def self.confirm_cancel(parent)
+    dialog = Gtk::Dialog.new(
+      "Confirm Cancel",
+      parent,
+      Gtk::Dialog::MODAL,
+      [ "Discard Recording", Gtk::Dialog::RESPONSE_CANCEL ],
+      [ "Save Recording As...", Gtk::Dialog::RESPONSE_OK ]
+    )
+    dialog.has_separator = false
+    label = Gtk::Label.new("Your recording has not been saved.")
+    image = Gtk::Image.new(Gtk::Stock::DIALOG_WARNING, Gtk::IconSize::DIALOG)
+  
+    hbox = Gtk::HBox.new(false, 5)
+    hbox.border_width = 10
+    hbox.pack_start_defaults(image);
+    hbox.pack_start_defaults(label);
+  
+    dialog.vbox.add(hbox)
+    dialog.show_all
+    result = dialog.run
+    dialog.destroy
+    
+    case result
+      when Gtk::Dialog::RESPONSE_OK
+        self.get_file_to_save
+      else
+    end
+  end
+end
+

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: screencaster-gtk
+version: !ruby/object:Gem::Version
+  version: 0.0.3.alpha1
+  prerelease: 6
+platform: ruby
+authors:
+- Larry Reid
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gdk_pixbuf2
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+- !ruby/object:Gem::Dependency
+  name: cairo
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.12'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.12.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.12'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.12.6
+- !ruby/object:Gem::Dependency
+  name: glib2
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+- !ruby/object:Gem::Dependency
+  name: gtk2
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+description: A gem for capturing screencasts
+email: larry.reid@jadesystems.ca
+executables:
+- screencaster
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/screencaster-gtk.rb
+- lib/screencaster-gtk/savefile.rb
+- lib/screencaster-gtk/capture.rb
+- lib/screencaster-gtk/progresstracker.rb
+- bin/screencaster
+homepage: http://github.org/lcreid/screencaster
+licenses:
+- GPL2
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements:
+- avconv
+- wmctl
+- libavcodec-extra-53
+- mkvtoolnix
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Screencaster
+test_files: []