Class: SensibleSwing::MainWindow

Inherits:

JFrame

Object
JFrame
SensibleSwing::MainWindow

show all

Includes:: SwingHelpers

Defined in:: lib/gui/base.rb,
lib/gui/create.rb,
lib/gui/normal.rb,
lib/gui/upconvert.rb,
lib/gui/create-file.rb,
lib/gui/dependencies.rb

Constant Summary collapse

LocalStorage =

Storage.new("sensible_cinema_storage_#{VERSION}")

SMPlayerIniFile =

File.expand_path("~/.smplayer_sensible_cinema/smplayer.ini")

LocalModifiedMplayer =

File.expand_path "vendor/cache/mplayer_edl/mplayer.exe"

EdlTempFile = stay 8.3 friendly :)

Dir.tmpdir + '/mplayer.temp.edl'

EdlFilesChosen = allow for switching tapes but still cache EDL loc. :P

{}

NonDvd = we need it for convenience, say you want to go through your indexed vids and convert them all?

'non dvd has no dvdid'

UpConvertKey =

'upconvert_setting'

UpConvertKeyExtra =

'upconvert_setting_extra'

UpConvertEnglish =

'upconvert_english_name'

ScreenMultipleFactor =

'screen_multiples'

Instance Attribute Summary collapse

#background_thread ⇒ Object

Returns the value of attribute background_thread.
#buttons ⇒ Object

Returns the value of attribute buttons.
#parent ⇒ Object

Returns the value of attribute parent.
#upconv_line ⇒ Object

Returns the value of attribute upconv_line.

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(start_visible = true, args = ARGV) ⇒ `MainWindow`

lodo not optionals

# File 'lib/gui/base.rb', line 93

def initialize start_visible = true, args = ARGV # lodo not optionals
  super "Sensible-Cinema #{VERSION} (GPL)"
 @args = args # save them away so this works with sub-child-windows
  force_accept_license_first # in other file :P
  setDefaultCloseOperation JFrame::EXIT_ON_CLOSE # closes the whole app when they hit X ...
  @panel = JPanel.new
  @buttons = []
  @panel.set_layout nil
  add @panel # why can't I just slap these down? panel? huh?
  @starting_button_y = 40
  @button_width = 400      
  
  add_text_line "Welcome to Sensible Cinema!"
  @starting_button_y += 10 # kinder ugly...
  add_text_line "      Rest mouse over buttons for \"help\" type descriptions (tooltips)."
  @current_dvds_line1 = add_text_line "Checking present DVD's..."
  @current_dvds_line2 = add_text_line ""
  @callbacks_for_dvd_edl_present = []
  DriveInfo.create_looping_drive_cacher
  DriveInfo.add_notify_on_changed_disks { update_currently_inserted_dvd_list }      
	  icon_filename = __DIR__ + "/../../vendor/profs.png"
	  raise unless File.exist? icon_filename # it doesn't check this for us?
  setIconImage(ImageIcon.new(icon_filename).getImage())
  check_for_various_dependencies
	  LocalStorage.set_once('init_preferences_once') {
 show_blocking_message_dialog "let's setup user preferences once..."
 set_individual_preferences
	  }
  set_visible start_visible
end

Instance Attribute Details

#background_thread ⇒ `Object`

Returns the value of attribute background_thread.



602
603
604

# File 'lib/gui/base.rb', line 602

def background_thread
  @background_thread
end

#buttons ⇒ `Object`

Returns the value of attribute buttons.



602
603
604

# File 'lib/gui/base.rb', line 602

def buttons
  @buttons
end

#parent ⇒ `Object`

Returns the value of attribute parent.



24
25
26

# File 'lib/gui/normal.rb', line 24

def parent
  @parent
end

#upconv_line ⇒ `Object`

Returns the value of attribute upconv_line.



24
25
26

# File 'lib/gui/normal.rb', line 24

def upconv_line
  @upconv_line
end

Class Method Details

.download(full_url, to_here) ⇒ `Object`

# File 'lib/gui/dependencies.rb', line 25

def self.download full_url, to_here
  require 'open-uri'
  require 'openssl'
	  require 'fileutils'
  eval("OpenSSL::SSL::VERIFY_PEER = OpenSSL::SSL::VERIFY_NONE") if full_url =~ /https/
  keep_going_bg_thread = true
  print 'downloading ' + File.basename(to_here)
  Thread.new { while keep_going_bg_thread; print '.'; sleep 1; end}
  writeOut = open(to_here + '.temp', "wb")
	  url = open(full_url, 'rb')
  writeOut.write(url.read)
	  url.close
  writeOut.close
	  FileUtils.mv to_here + '.temp', to_here # avoid partial downloads corrupting uss
  keep_going_bg_thread = false
  puts 'done!'
end

.download_to_string(full_url) ⇒ `Object`

# File 'lib/gui/dependencies.rb', line 43

def self.download_to_string full_url
   require 'tempfile'
   to = Tempfile.new 'abc'
   download(full_url, to.path)
   out = File.binread(to.path)
   to.delete
   out
end

Instance Method Details

#add_callback_for_dvd_edl_present(&block) ⇒ `Object`

# File 'lib/gui/base.rb', line 124

def add_callback_for_dvd_edl_present &block
  raise unless block
  @callbacks_for_dvd_edl_present << block
  update_currently_inserted_dvd_list # updates them :P
end

#add_change_upconvert_buttons ⇒ `Object`

# File 'lib/gui/upconvert.rb', line 102

def add_change_upconvert_buttons
  raise 'should have already been set for us' unless LocalStorage[ScreenMultipleFactor]
  @medium_dvd = new_jbutton("Set upconvert options to DVD-style video") {
 setup_dvd_upconvert_options
    display_current_upconvert_setting_and_close_window
  }
  high_compression = new_jbutton("Set upconvert options to high compressed video file playback") {
    # -autoq 6 -vf pp [?]
    LocalStorage[UpConvertEnglish] = "high compressed"
    LocalStorage[UpConvertKey] = "hqdn3d=0:1:4:4,pp=hb:y/vb:y,scale=SCREEN_X:-10:0:0:3" # pp should be after hqdn3d I think... and hqdn3d should be before scale...
    LocalStorage[UpConvertKeyExtra] = "-sws 9 -ssf ls=75.0 -ssf cs=25.0"
    display_current_upconvert_setting_and_close_window
    # -Processing method: mplayer with accurate deblocking ???
  }
  new_jbutton("Set upconvert options to experimental screen-upconverting playback") {
    LocalStorage[UpConvertKey] = "scale=SCREEN_X:-10:0:0:3" # no hqdn3d
    LocalStorage[UpConvertKeyExtra] = "-sws 9 -ssf ls=75.0 -ssf cs=25.0"
    LocalStorage[UpConvertEnglish] = "experimental screenupconversion"
    display_current_upconvert_setting_and_close_window
  }
  
  new_jbutton("Set upconvert options to whatever you want [like -sws 9 -ssf ls=100.0 -- for advanced users]") {
    new_settings = get_user_input("you can set -vf settings, and then other settings. What would you like your -vf settings to be?")
    LocalStorage[UpConvertKey] = new_settings
    other_settings = get_user_input("other settings you'd like to also have add:")
    LocalStorage[UpConvertKeyExtra] = other_settings
    LocalStorage[UpConvertEnglish] = "personalized: -vf #{new_settings}, #{other_settings}"      
  }
  
  # TODO tooltip from docu here +- this into tooltip
  # TODO "click here" link for more docu [?]
  add_text_line "Multiple factor screen widths"
  add_text_line "   (higher might be better, uses more cpu)." 
  add_text_line "   If mplayer just dies or displays only a black or white screen then lower this setting, it is too high."
  slider = JSlider.new
  slider.setBorder(BorderFactory.createTitledBorder("Screen resolution multiple"));
  
  # I want tick for 1x, 1.5x, 2x, 2.5x, 3x
  # so let's do marker values of 10 -> 30, since it requires integers...
  
  labelTable = java.util.Hashtable.new
  i = java.lang.Integer
  l = JLabel
  
  # allow for 0.75 too, if you have a large monitor, slower cpu...
  local_minimum = (720.0/get_current_max_width_resolution)*100 # allows 1024 to use upscaling to 860, but we warn when they do this
  label_minimum = nil
  (0..300).step(25) do |n|
    if n > local_minimum
      label_minimum ||= n
      if (n % 100 == 0)
        labelTable.put(i.new(n), l.new("#{n/100}x")) # 1x
      elsif n == label_minimum # just for the bottom label, rest too chatty
        labelTable.put(i.new(n), l.new("#{n/100.0}x")) # 1.5x
      end
    end
  end
  slider.setLabelTable( labelTable )
  
  slider.maximum=300
  slider.minimum=label_minimum
  slider.setMajorTickSpacing(100) 
  slider.setMinorTickSpacing(25) 
  slider.setPaintTicks(true)
  slider.setPaintLabels(true)    
  slider.snap_to_ticks=true
  
  slider.set_value LocalStorage[ScreenMultipleFactor] * 100
  
  slider.add_change_listener { |event|
    if !slider.value_is_adjusting
      # they released their hold on it...
      old_value = LocalStorage[ScreenMultipleFactor]
      new_value = slider.value/100.0
      LocalStorage[ScreenMultipleFactor] = new_value
      if new_value != old_value
        if slider.value == label_minimum
          show_blocking_message_dialog "Setting it too low like that might make it not do much upconverting (DVD's, are 720px, you're setting it to upconvert to #{new_value * get_current_max_width_resolution})"
        end
        display_current_upconvert_setting_and_close_window
      end
    end
  }
  slider.set_bounds(44, @starting_button_y, @button_width, 66)
  2.times {increment_button_location}
  @panel.add(slider)
  
  increment_button_location
  
  @none = new_jbutton("Reset upconvert options to none (no upconversion)")
  @none.tool_tip = "Having no upconvert options is reasonably good, might use directx for scaling, nice for slow cpu's"
  @none.on_clicked {
    reset_upconversion_options
    display_current_upconvert_setting_and_close_window
  }
  
  @generate_images = new_jbutton("Test current configuration by writing some images from playing a video file") do
    popup = warn_if_no_upconvert_options_currently_selected
    filename_mpg = new_existing_file_selector_and_select_file( "pick movie file (like moviename.mpg)")
    
    output_dir = get_same_drive_friendly_clean_temp_dir 'temp_upscaled_video_out'
    output_command = '-ss 2:44 -frames 300 -vo png:outdir="' + File.strip_drive_windows(output_dir) + '"'
    output_command += " -noframedrop" # don't want them to skip frames on cpu's without enough power to keep up
    thread = play_smplayer_edl_non_blocking [filename_mpg, nil], [output_command], true
    when_thread_done(thread) { popup.dispose; show_in_explorer(output_dir) }
  end
  @generate_images.tool_tip = "This creates a folder with images upconverted from some DVD or file, so you can tweak settings and compare." # TODO more tooltips

  @generate_screen_cast = new_jbutton("Test current configuration by watching video file and recording screen") do
    check_for_ffmpeg_installed
		popup = warn_if_no_upconvert_options_currently_selected
    filename_mpg = new_existing_file_selector_and_select_file( "pick movie file (like moviename.mpg)")
    output_dir = get_same_drive_friendly_clean_temp_dir 'temp_screencast_dir'
    thread1 = play_smplayer_edl_non_blocking [filename_mpg, nil], [" -ss 2:44 -endpos 11"]
    # screen capture for 10s
    fps_to_grab = 5
		
    thread2 = Thread.new {  c = %!ffmpeg -f dshow -i video="screen-capture-recorder" -r #{fps_to_grab} -vframes #{fps_to_grab*10} -y #{File.strip_drive_windows(output_dir)}/%d.png!; system_blocking c }
    thread2.join
    show_blocking_message_dialog "ffmpeg done, close mplayer now!"
    thread1.join
    popup.dispose # just in case :P
    show_in_explorer(output_dir)
  end


end

#add_change_upconvert_options_button ⇒ `Object`

# File 'lib/gui/upconvert.rb', line 52

def add_change_upconvert_options_button
  @show_upconvert_options = new_jbutton("Tweak Playback Upconversion Quality Settings") do
    upconvert_window = new_child_window
    upconvert_window.add_change_upconvert_buttons
  end
  @show_upconvert_options.tool_tip= "Allows you to set your upconvert options.\nUpconverting attempts to playback your movie with higher quality on high resolution monitors."
end

#add_open_documentation_button ⇒ `Object`

# File 'lib/gui/normal.rb', line 96

def add_open_documentation_button
  @open_help_file = new_jbutton("View Sensible Cinema Documentation") do
    show_in_explorer __DIR__ + "/../../documentation"
  end
end

#add_play_upconvert_buttons ⇒ `Object`

# File 'lib/gui/upconvert.rb', line 6

def add_play_upconvert_buttons

  @watch_file_upconvert = new_jbutton( "Watch a movie file upconverted (unedited)") do
    popup = warn_if_no_upconvert_options_currently_selected
    filename_mpg = new_existing_file_selector_and_select_file( "pick movie file (like moviename.mpg)")
    thread = play_smplayer_edl_non_blocking [filename_mpg, nil]
    when_thread_done(thread) { popup.dispose }
  end
  @watch_file_upconvert.tool_tip= "This plays back a movie file, like moviefile.mpg, or moviename.vob using your current upconverter settings.\nTo playback a file edited upconverted, set upconvert options here first, then run them using sensible cinema main--it will automatically use your new upconverting options.\n" # LODO
  
  @watch_dvd_upconvert = new_jbutton( "Watch a DVD upconverted (unedited)") do
    popup = warn_if_no_upconvert_options_currently_selected
    thread = play_dvd_smplayer_unedited false
    when_thread_done(thread) { popup.dispose }
  end
  @watch_dvd_upconvert.tool_tip = "Plays back the currently inserted DVD, using your current upconverter settings.\nIf it fails (dies immediately, blank screen, etc.), try setting upconvert options to a smaller screen resolution multiple.\nOr try playing the DVD with VLC first, then it might work.\nTo playback a DVD edited upconverted, set upconvert options here first, then run them using sensible cinema main--it will automatically use your new upconverting options."
  
  @watch_online = new_jbutton( "Watch upconverted online player, like netflix instant") do
    show_blocking_message_dialog("sorry not mac compat. yet") and raise unless OS.doze?
    answer = JOptionPane.show_select_buttons_prompt("Warning: you must have the screen capture device installed (install MSVC 2010 runtime x86 first), and also configured using its setup utility, and avisynth installed.", :yes => 'take me to its website', :no => 'I already and configured it, let me at it!')
    if answer == :yes
       SwingHelpers.open_url_to_view_it_non_blocking "https://github.com/rdp/screen-capture-recorder-to-video-windows-free"
       raise 'install it'
    end
    run_smplayer_non_blocking "upconvert_from_screen/upconvert_from_screen_me2.avs", nil, '', force_mplayer = true, true, false, nil
  end
  
  add_text_line ''
  @upconv_line = add_text_line ''
  change_upconvert_line_to_current
  
  add_change_upconvert_options_button
  if !upconvert_set_to_anything?
    show_blocking_message_dialog 'please configure your upconvert settings first'
    @show_upconvert_options.simulate_click # make them choose one
  end
  add_text_line ''
  
end

#add_text_line(line) ⇒ `Object`

# File 'lib/gui/base.rb', line 198

def add_text_line line
  jlabel = JLabel.new line
  happy = Font.new("Tahoma", Font::PLAIN, 11)
  jlabel.setFont(happy)
  jlabel.set_bounds(44,@starting_button_y ,460,14)
  @panel.add jlabel
  increment_button_location 18
  jlabel
end

#assert_confirmed_dialog(returned, license_url_should_also_be_embedded_by_you_in_message) ⇒ `Object`

# File 'lib/gui/dependencies.rb', line 155

def assert_confirmed_dialog returned, license_url_should_also_be_embedded_by_you_in_message
  # :yes is "view license", :no is "accept", :cancel
  if returned == :yes
    if license_url_should_also_be_embedded_by_you_in_message
      SwingHelpers.open_url_to_view_it_non_blocking license_url_should_also_be_embedded_by_you_in_message
      puts "Please restart after reading license agreement, to be able to then accept it."
    else
      puts 'dialog assertion failed'
    end
    System.exit 0
  elsif returned == :cancel
    p 'license not accepted...exiting'
    System.exit 1
  elsif returned == :exited
    p 'license exited early...exiting'
    System.exit 1
  elsif returned == :no
    # ok
  else
    raise 'unknown?'
  end
end

#assert_ownership_dialog ⇒ `Object`

# File 'lib/gui/dependencies.rb', line 131

def assert_ownership_dialog 
  force_accept_file_style_license
  message = "Do you certify you own the DVD this came of and have it in your possession, if necessary in your legal jurisdiction?"
  title = "Verify ownership"
  returned = JOptionPane.show_select_buttons_prompt(message, {:yes => "no", :no => "yes"})
  assert_confirmed_dialog returned, nil
end

#begin_buffer_preference ⇒ `Object`

MplayerBeginingBuffer = 1.0

MplayerEndBuffer = 0.0



466
467
468

# File 'lib/gui/base.rb', line 466

def begin_buffer_preference
 LocalStorage['mplayer_beginning_buffer']
end

#calculate_dvd_start_offset(title, drive) ⇒ `Object`

# File 'lib/gui/create.rb', line 399

def calculate_dvd_start_offset title, drive
  popup = show_non_blocking_message_dialog "calculating start info for title #{title}..." # must be non blocking so the command can run :P
  command = "mplayer -benchmark -frames 35  -osd-verbose -osdlevel 2 -vo null -nosound dvdnav://#{title} -nocache -dvd-device #{drive}  2>&1"
  puts command
  out = `#{command}`
  #search for V:  0.37
  popup.close
  outs = {}
	  old_mpeg = 0
  out.each_line{|l|
    if l =~  /V:\s+([\d\.]+)/
      outs[:mpeg_start_offset] ||= $1.to_f
    end
   float = /\d+\.\d+/
  if l =~ /last NAV packet was (#{float}), mpeg at (#{float})/
      nav = $1.to_f
      mpeg = $2.to_f
      if !outs[:dvd_nav_packet_offset] && nav > 0.0 # like 0.4
 if mpeg < nav
   # case there is an MPEG split before the second NAV packet [ratatouille, hp]
   p mpeg, nav, old_mpeg
   assert old_mpeg > 0.3
mpeg = old_mpeg + mpeg - 0.033367 # assume 30 fps, and that this is the second frame since it occurred, since the first one we apparently display "weird suddenly we're not a dvd?"
show_blocking_message_dialog "this dvd has some weird timing stuff at the start, attempting to accomodate...please report..."
 end
       outs[:dvd_nav_packet_offset] = [nav, mpeg] # like [0.4, 0.6] or the like
        else
 old_mpeg = mpeg # ratatouile weirdness...
 end
  	  end
  }
  show_blocking_message_dialog "unable to calculate DVD start time from #{command}?" unless outs.length == 2
  outs
end

#change_upconvert_line_to_current ⇒ `Object`

# File 'lib/gui/upconvert.rb', line 69

def change_upconvert_line_to_current
  current = get_current_upconvert_as_phrase
  if @upconv_line
    @upconv_line.set_text current
  end
  if @parent && @parent.upconv_line
    @parent.upconv_line.set_text current
  end # LODO I think the child also wants a status line..
end

#check_for_exe(windows_full_loc, unix_name) ⇒ `Object`

# File 'lib/gui/dependencies.rb', line 76

def check_for_exe windows_full_loc, unix_name
  # in windows, that exe *at that location* must exist...
  if OS.windows?
    File.exist?(windows_full_loc)
  else
    require 'lib/check_installed_mac.rb'
    if !CheckInstalledMac.check_for_installed(unix_name)
      exit 1 # it'll have already displayed a message...
    else
      true
    end
  end
end

#check_for_ffmpeg_installed ⇒ `Object`

# File 'lib/gui/dependencies.rb', line 90

def check_for_ffmpeg_installed
     ffmpeg_exe_loc = File.expand_path('vendor/cache/ffmpeg/ffmpeg.exe') # I think file basd normal needs ffmpeg
     if !check_for_exe(ffmpeg_exe_loc, 'ffmpeg')
       require_blocking_license_accept_dialog 'ffmpeg', 'gplv2', 'http://www.gnu.org/licenses/gpl-2.0.html', "Appears that you need to install a dependency: ffmpeg."
       download_zip_file_and_extract "ffmpeg (5MB)", "http://ffmpeg.zeranoe.com/builds/win32/static/ffmpeg-git-335bbe4-win32-static.7z", "ffmpeg"
     end

end

#check_for_various_dependencies ⇒ `Object`

# File 'lib/gui/dependencies.rb', line 99

def check_for_various_dependencies            
  if OS.doze? && !check_for_exe('vendor/cache/mplayer_edl/mplayer.exe', nil)
    require_blocking_license_accept_dialog 'Mplayer-EDL', 'gplv2', 'http://www.gnu.org/licenses/gpl-2.0.html', "Appears that you need to install a dependency: mplayer EDL "
    FileUtils.mkdir_p 'vendor/cache/mplayer_edl'
    puts 'downloading mplayer edl [12 MB]'
    MainWindow.download('http://sourceforge.net/projects/mplayer-edl/files/0.4/mplayer.exe', 'vendor/cache/mplayer_edl/mplayer.exe')
		config_dir = File.expand_path('~/mplayer')
		FileUtils.mkdir(config_dir) unless File.directory?(config_dir)
		FileUtils.cp('vendor/subfont.ttf', config_dir) # TODO mac
  end

  # runtime dependencies, at least as of today...
  if OS.mac?
    check_for_exe("mplayer", "mplayer") # mencoder and mplayer are separate for mac... [this checks for mac's mplayerx, too]
  else      
    path = RubyWhich.new.which('smplayer')
    if(path.length == 0)
      # this one has its own installer...
    require_blocking_license_accept_dialog 'Smplayer', 'gplv2', 'http://www.gnu.org/licenses/gpl-2.0.html', "Appears that you need to install a dependency: smplayer."
 		  save_to_dir = SwingHelpers.new_existing_dir_chooser_and_go 'pick dir to save smplayer exe installer to:'
    save_to_file =  "#{save_to_dir}/smplayer-0.6.9-win32.exe"
		  puts "downloading smplayer.exe [14MB] to #{save_to_file}"
      MainWindow.download "http://sourceforge.net/projects/smplayer/files/SMPlayer/0.6.9/smplayer-0.6.9-win32.exe", save_to_file
    show_blocking_message_dialog "Run this file to install it now (click ok to reveal): smplayer-0.6.9-win32.exe"
		  show_in_explorer save_to_file
      sleep 2
    show_blocking_message_dialog "hit ok after smplayer is installed:"
 add_smplayer_paths # load it onto the PATH now
    end
  end
end

#choose_dvd_drive_or_file(force_choose_only_dvd_drive) ⇒ `Object`

returns e:, volume_name, dvd_id or full_path.mkv, filename, ”

# File 'lib/gui/base.rb', line 608

def choose_dvd_drive_or_file force_choose_only_dvd_drive
  opticals = DriveInfo.get_dvd_drives_as_openstruct
  if @saved_opticals == opticals && @_choose_dvd_drive_or_file
    # memoize...if disks haven't changed :)
    return @_choose_dvd_drive_or_file
  else
    @saved_opticals = opticals # save currently mounted disk list, so we know if we should re-select later... 
    # is this ok for os x?
  end

  has_at_least_one_dvd_inserted = opticals.find{|d| d.VolumeName }
  if !has_at_least_one_dvd_inserted && force_choose_only_dvd_drive
    show_blocking_message_dialog 'insert a dvd first' 
    raise 'no dvd found'
  end
  names = opticals.map{|d| d.Name + "\\" + " (" +  (d.VolumeName || 'Insert DVD to use') + ")"}
  if !force_choose_only_dvd_drive && !has_at_least_one_dvd_inserted
    names += ['No DVD mounted so click to choose a Local File (or insert DVD, then re-try)']
    used_local_file_option = true
  end
  
  count = 0
  opticals.each{|d| count += 1 if d.VolumeName}
  if count == 1 && !used_local_file_option
   # just choose it if there's only one disk available..
   p 'selecting only disk currently present in the various DVD drives [if you have more than one, that is]'
   selected_idx = opticals.index{|d| d.VolumeName}
   unless selected_idx
     show_blocking_message_dialog "Please insert a disk first"
     raise 'inset disk'
   end
  else
    dialog = get_disk_chooser_window names
    selected_idx = dialog.go_selected_index
  end
    if used_local_file_option
      raise unless selected_idx == 0 # it was our only option...they must have selected it!
      filename = new_existing_file_selector_and_select_file("Select yer previously grabbed from DVD file")
      assert_ownership_dialog
      return [filename, File.basename(filename), NonDvd]
    else
      disk = opticals[selected_idx]
      out = show_non_blocking_message_dialog "calculating current disk's unique id...if this pauses more than 10s then clean your DVD..."
      begin
      dvd_id = DriveInfo.md5sum_disk(disk.MountPoint)
      rescue Exception => e
      show_blocking_message_dialog e.to_s # todo a bit ugly...
     raise
    ensure
    out.dispose
    end
      @_choose_dvd_drive_or_file = [disk.DevicePoint, opticals[selected_idx].VolumeName, dvd_id]
      return @_choose_dvd_drive_or_file
    end
end

#choose_dvd_or_file_and_edl_for_it(force_choose_edl_file_if_no_easy_match = true) ⇒ `Object`

# File 'lib/gui/base.rb', line 422

def choose_dvd_or_file_and_edl_for_it force_choose_edl_file_if_no_easy_match = true
  drive_or_file, dvd_volume_name, dvd_id = choose_dvd_drive_or_file false
  edl_path = EdlFilesChosen[dvd_id]
  if !edl_path
    edl_path = EdlParser.single_edit_list_matches_dvd(dvd_id)
    if !edl_path && force_choose_edl_file_if_no_easy_match
    message = "Please pick a DVD Edit List File (none or more than one were found that seem to match #{dvd_volume_name})--may need to create one, if one doesn't exist yet"
    show_blocking_message_dialog message
      edl_path = new_existing_file_selector_and_select_file(message, EdlParser::EDL_DIR)
    end
  end
  p 're/loading ' + edl_path # in case it has changed on disk
  if edl_path # sometimes they don't have to choose one [?]
    descriptors = nil
    begin
      descriptors = parse_edl edl_path
    rescue SyntaxError => e
      show_non_blocking_message_dialog("this file has an error--please fix then hit ok: \n" + edl_path + "\n " + e)
      raise e
    end
  end
  EdlFilesChosen[dvd_id] ||= edl_path
  [drive_or_file, dvd_volume_name, dvd_id, edl_path, descriptors]
end

#choose_file_and_edl_and_create_sxs_or_play(just_create_xbmc_dot_edl_file_instead_of_play) ⇒ `Object`

side by side stuff we haven’t really factored out yet, also doubles for both normal/create LODO

# File 'lib/gui/normal.rb', line 103

def choose_file_and_edl_and_create_sxs_or_play just_create_xbmc_dot_edl_file_instead_of_play
  filename_mpg = new_existing_file_selector_and_select_file( "Pick moviefile (like moviename.mpg or video_ts/anything.ext)")
  edl_filename = new_existing_file_selector_and_select_file( "Pick an EDL file to use with it", EdlParser::EDL_DIR)
  assert_ownership_dialog
  if just_create_xbmc_dot_edl_file_instead_of_play
    descriptors = EdlParser.parse_file edl_filename
    # XBMC can use english timestamps
    edl_contents = MplayerEdl.convert_to_edl descriptors, add_secs_end = 0.0, begin_buffer_preference, splits = [], extra_time_to_all = 0.0, use_english_timestamps=true
    output_file = filename_mpg.gsub(/\.[^\.]+$/, '') + '.edl' # sanitize...
    File.write(output_file, edl_contents)
    raise unless File.exist?(output_file) # sanity
    show_blocking_message_dialog("created #{output_file}")
  else
    play_smplayer_edl_non_blocking [filename_mpg, edl_filename]
  end
end

#create_brand_new_dvd_edl ⇒ `Object`

# File 'lib/gui/create.rb', line 462

def create_brand_new_dvd_edl
 hashes, title_lengths = get_disk_info # has a prompt
 volume = hashes['volume_name']
 default_english_name = volume.split('_').map{|word| word.downcase.capitalize}.join(' ') # A Court A Jester
  english_name = get_user_input("Enter a human readable DVD description for #{volume}", default_english_name)

  # EDL versions:
 # nothing with disk_unique_id: probably dvd_start_offset 29.97
  # nothing without disk_unque_id: probably start_zero 29.97
  # 1.1: has timestamps_relative_to, I guess

  input = <<-EOL
# edl_version_version 1.1, sensible cinema v#{VERSION}
# comments can go be created by placing text after a # on any line, for example this one.
"name" => "#{english_name}",

"mutes" => [
  # an example line, uncomment the leading "#" to make it active
  # "0:00:01.0", "0:00:02.0", "profanity", "da..", 
],

"blank_outs" => [
  # an example line, uncomment the leading "#" to make it active
  # "00:03:00.0" , "00:04:00.0", "violence", "of some sort",
],

"source" => "dvd",
"volume_name" => "#{volume}",
"timestamps_relative_to" => ["dvd_start_offset","29.97"],
"disk_unique_id" => "#{hashes['disk_unique_id']}",
"dvd_title_track" => "#{hashes['dvd_title_track']}", # our guess for it
"dvd_title_track_length" => "#{hashes['dvd_title_track_length']}", 
# "not edited out stuff" => "some...",
# "closing thoughts" => "only ...",
# "subtitles_to_display_relative_path" => "some_file.srt" # if you want to display some custom subtitles alongside your movie
"dvd_title_track_start_offset" => "#{hashes['dvd_start_offset']}",
"dvd_nav_packet_offset" => #{hashes['dvd_nav_packet_offset'].inspect},
    EOL
		
  filename = EdlParser::EDL_DIR + "/edls_being_edited/" + english_name.gsub(' ', '_') + '.txt'
  if File.exist?(filename)
   show_blocking_message_dialog 'don\'t want to overwrite a file in the edit dir that already has same name, opening it instead...'
 else
   File.write(filename, input)
  end
  open_file_to_edit_it filename
end

#create_new_for_file_or_netflix ⇒ `Object`

# File 'lib/gui/create.rb', line 527

def create_new_for_file_or_netflix
  names = ['movie file', 'netflix instant']
     dialog = DropDownSelector.new(self, names, "Select type")
     type = dialog.go_selected_value
     extra_options = {}
     if type == 'movie file'
       path = SwingHelpers.new_previously_existing_file_selector_and_go "Select file to create EDL for"
       guess_name = File.basename(path).split('.')[0..-2].join('.') # like yo.something.720p.HDTV.X264-DIMENSION.m4v maybe?
       extra_options['filename'] = File.basename path
       require 'lib/movie_hasher'
       extra_options['movie_hash'] = MovieHasher.compute_hash path
     else
       url = get_user_input "Please input the movies url (like http://www.netflix.com/Movie/Curious-George/70042686 )" #?
       if url =~ /netflix/
         guess_name = url.split('/')[-2]
       else
         show_blocking_message_dialog "non hulu/netflix? please report!"
         type = 'unknown'
         guess_name = url.split('/')[-1]
       end
       extra_options['url'] = url
     end
     english_name = get_user_input "Enter name of movie", guess_name.gsub(/[-._]/, ' ')
     filename = new_nonexisting_filechooser_and_go 'Pick new EDL filename', EdlParser::EDL_DIR + '/..', english_name.gsub(' ', '_') + '.txt'
     display_and_raise "needs .txt extension" unless filename =~ /\.txt$/i
     
     output = <<-EOL
# edl_version_version 1.1, created by sensible cinema v#{VERSION}
# comments can go be created by placing text after a # on any line, for example this one.
"name" => "#{english_name}",

"source" => "#{type}",
#{extra_options.map{|k, v| %!\n"#{k}" => "#{v}",\n!}}
"mutes" => [
  # an example line, uncomment the leading "#" to make it active
  # "0:00:01.0", "0:00:02.0", "profanity", "da..", 
],

"blank_outs" => [
  # an example line, uncomment the leading "#" to make it active
  # "00:03:00.0" , "00:04:00.0", "violence", "of some sort",
],

"timestamps_relative_to" => ["#{type}"],
# "not edited out stuff" => "some...",
# "closing thoughts" => "only ...",
# "subtitles_to_display_relative_path" => "some_file.srt" # if you want to display some custom subtitles alongside your movie
     EOL
     File.write filename, output
     open_file_to_edit_it filename

end

#display_and_raise(error_message) ⇒ `Object`

# File 'lib/gui/base.rb', line 665

def display_and_raise error_message
  show_blocking_message_dialog error_message
  raise error_message
end

#display_current_upconvert_setting_and_close_window ⇒ `Object`

# File 'lib/gui/upconvert.rb', line 241

def display_current_upconvert_setting_and_close_window
  change_upconvert_line_to_current
  show_blocking_message_dialog get_current_upconvert_as_phrase
  self.dispose
end

#download_7zip ⇒ `Object`

# File 'lib/gui/dependencies.rb', line 53

def download_7zip
  Dir.mkdir('./vendor/cache') unless File.directory? 'vendor/cache' # development may not have it created yet... [?]
  unless File.exist? 'vendor/cache/7za.exe'
    Dir.chdir('vendor/cache') do
      print 'downloading unzipper (7zip--400K) ...'
      MainWindow.download("http://downloads.sourceforge.net/project/sevenzip/7-Zip/9.20/7za920.zip", "7za920.zip")
      system_blocking("../unzip.exe -o 7za920.zip") # -o means "overwrite" without prompting
    end
  end
end

#download_zip_file_and_extract(english_name, url, to_this) ⇒ `Object`

# File 'lib/gui/dependencies.rb', line 64

def download_zip_file_and_extract english_name, url, to_this
  download_7zip
  Dir.chdir('vendor/cache') do
    file_name = url.split('/')[-1]
    print "downloading #{english_name} ..."
    MainWindow.download(url, file_name)
    system_blocking("7za e #{file_name} -y -o#{to_this}")
    puts 'done ' + english_name
    # creates vendor/cache/mencoder/mencoder.exe...
  end
end

#force_accept_file_style_license ⇒ `Object`

# File 'lib/gui/dependencies.rb', line 17

def force_accept_file_style_license
   if !(LocalStorage['accepted_legal_copys'] == VERSION)
    require_blocking_license_accept_dialog 'Sensible Cinema', 'is_it_legal_to_copy_dvds.txt file', File.expand_path(File.dirname(__FILE__) + "/../../documentation/is_it_legal_to_copy_dvds.txt"), 
        'is_it_legal_to_copy_dvds.txt file', 'I acknowledge that I have read, understand, accept the documentation/is_it_legal_to_copy_dvds.txt file.'
    LocalStorage['accepted_legal_copys'] = VERSION
  end
end

#force_accept_license_first ⇒ `Object`

# File 'lib/gui/dependencies.rb', line 9

def force_accept_license_first
  if !(LocalStorage['main_license_accepted'] == VERSION)
    require_blocking_license_accept_dialog 'Sensible Cinema', 'gplv3', 'http://www.gnu.org/licenses/gpl.html', 'Sensible Cinema license agreement', 
        "Sensible Cinema is distributed under the gplv3 (http://www.gnu.org/licenses/gpl.html).\nBY CLICKING \"accept\" YOU SIGNIFY THAT YOU HAVE READ, UNDERSTOOD AND AGREED TO ABIDE BY THE TERMS OF THIS AGREEMENT"
    LocalStorage['main_license_accepted'] = VERSION
  end
end

#get_current_max_width_resolution ⇒ `Object`

# File 'lib/gui/upconvert.rb', line 257

def get_current_max_width_resolution
  # choose width of widest monitor (why would they display it on the other, right?)
  java.awt.GraphicsEnvironment.getLocalGraphicsEnvironment.getScreenDevices.map{|gd| gd.display_mode.width}.max.to_i
end

#get_current_upconvert_as_phrase ⇒ `Object`

# File 'lib/gui/upconvert.rb', line 247

def get_current_upconvert_as_phrase
  settings = LocalStorage[UpConvertEnglish]
  out = "Upconvert options are now #{  settings ? "set to #{settings} style" : "NOT SET"}"
  if settings
    multiple = LocalStorage[ScreenMultipleFactor]
    out += " (screen multiplier #{multiple}*#{get_current_max_width_resolution} = #{(multiple * get_current_max_width_resolution).to_i}px)."
  end
  out
end

#get_disk_chooser_window(names) ⇒ `Object`



705
706
707

# File 'lib/gui/base.rb', line 705

def get_disk_chooser_window names
  DropDownSelector.new(self, names, "Click to select DVD drive")
end

#get_disk_info ⇒ `Object`

# File 'lib/gui/create.rb', line 333

def get_disk_info
 drive, volume_name, dvd_id = choose_dvd_drive_or_file true # require a real DVD disk :)
  # display it, allow them to copy and paste it out
 out_hashes = {}
 out_hashes['disk_unique_id'] = dvd_id
 out_hashes['volume_name'] = volume_name
  popup = show_non_blocking_message_dialog "calculating DVD title sizes..."
  command = "mplayer -vo direct3d dvdnav:// -nocache -dvd-device #{drive} -identify -frames 0 2>&1"
  puts command
  title_lengths_output = `#{command}`
  popup.close
  edit_list_path = EdlParser.single_edit_list_matches_dvd(dvd_id)
  if edit_list_path
	  parsed = parse_edl edit_list_path
    title_to_get_offset_of = get_title_track_string(parsed)
  else
    title_to_get_offset_of = nil
  end
  title_lengths = title_lengths_output.split("\n").select{|line| line =~ /TITLE.*LENGTH/}
  # ID_DVD_TITLE_4_LENGTH=365.000
  titles_with_length = title_lengths.map{|name| name =~ /ID_DVD_TITLE_(\d+)_LENGTH=([\d\.]+)/; [$1, $2.to_f]}
	  if titles_with_length.length > 50
 show_blocking_message_dialog "this DVD has > 50 titles, this may mean that our 'guess' for the main title will be off, please double check the right number\nby starting the main movie in VLC then Playback menu -> title to see which number it is on."
	  end
  largest_title = titles_with_length.max_by{|title, length| length}
 if !largest_title
   display_and_raise "unable to parse title lengths? maybe need to clean disk first? #{title_lengths_output}"
	  end
 largest_title = largest_title[0]
  title_to_get_offset_of ||= largest_title
  out_hashes['dvd_title_track'] = title_to_get_offset_of
 out_hashes['dvd_title_track_length'] = titles_with_length.detect{|title, length| title == title_to_get_offset_of}[1]
  offsets = calculate_dvd_start_offset(title_to_get_offset_of, drive)
	start_offset = offsets[:mpeg_start_offset]
 out_hashes['dvd_start_offset'] = start_offset
  out_hashes['dvd_nav_packet_offset'] = offsets[:dvd_nav_packet_offset]
 [out_hashes, title_lengths]
end

#get_drive_with_most_space_with_slash ⇒ `Object`



598
599
600

# File 'lib/gui/base.rb', line 598

def get_drive_with_most_space_with_slash
  DriveInfo.get_drive_with_most_space_with_slash
end

#get_dvd_playback_options(descriptors) ⇒ `Object`

# File 'lib/gui/base.rb', line 391

def get_dvd_playback_options descriptors
  out = []
  
  nav, mpeg_time = descriptors['dvd_nav_packet_offset'] # like [0.5, 0.734067]
  if nav
 mpeg_time *= 1/1.001 # -> 29.97 fps
    offset_time = mpeg_time - nav
  else
  # readings: 0.213  0.173 0.233 0.21 0.18 0.197 they're almost all right around 0.20...
    show_blocking_message_dialog "error--your DVD EDL doesn\'t list a start offset time [dvd_nav_packet_offset] which is needed for precise accurate timing. Please run\nadvanced mode -> Display information about current DVD\nand add it to the EDL. Using a default for now...if you tweak any timing info you may want to set this more accurately first!"
    offset_time = 0.20
  end
	  raise if offset_time <= 0 # unexpected...
	  # -osd-add is because the initial NAV packet is "x" seconds off from the mpeg, and since 
	  # we have it set within mplayer to "prefer to just give you the MPEG time when you haven't passed a DVD block"
	  # we wanted to match that more precisely once we did get past it.
	  # so basically today we are trying to "match" the underlying MPEG time well. Which is wrong, of course.
	  # either match the file or match the DVD, punk!
	  out << "-osd-add #{ "%0.3f" % offset_time}"
  out.join(' ')
end

#get_freespace(path) ⇒ `Object`



594
595
596

# File 'lib/gui/base.rb', line 594

def get_freespace path
  JFile.new(File.dirname(path)).get_usable_space
end

#get_same_drive_friendly_clean_temp_dir(suffix) ⇒ `Object`

# File 'lib/gui/upconvert.rb', line 230

def get_same_drive_friendly_clean_temp_dir suffix
    output_dir = Dir.tmpdir
    if File.get_root_dir(output_dir) != File.get_root_dir(Dir.pwd) # you are hosed!
      output_dir = File.get_root_dir(Dir.pwd) # we'll raise if it's not writable...
    end
    output_dir = output_dir + '/' + suffix
    FileUtils.rm_rf output_dir
    Dir.mkdir output_dir
    output_dir
end

#get_set_preference(name, english_name) ⇒ `Object`

# File 'lib/gui/dependencies.rb', line 203

def get_set_preference name, english_name
  old_preference = LocalStorage[name]
  old_class = old_preference.class
	  
	  new_preference = get_user_input("Enter value for #{english_name}", old_preference)
  display_and_raise 'enter something like 0.0' if new_preference.empty?
  if old_class == Float
    new_preference = new_preference.to_f
  elsif old_class == String
    # leave same
  else
    raise 'unknown type?' + old_class.to_s
  end
  LocalStorage[name] = new_preference
end

#get_srt_filename(descriptors, edl_filename) ⇒ `Object`

# File 'lib/gui/base.rb', line 168

def get_srt_filename descriptors, edl_filename
  path = descriptors['subtitles_to_display_relative_path'] if descriptors
  if path
    path = File.expand_path(File.dirname(edl_filename) + '/' + path)
    raise 'nonexisting srt file must be relative to the edl file...' + path unless File.exist? path
  end
  path
end

#get_start_stop_times_strings ⇒ `Object`

# File 'lib/gui/create.rb', line 434

def get_start_stop_times_strings
    # only show this message once :)
    @show_block ||= show_blocking_message_dialog(<<-EOL, "Preview")
      Ok, let's preview just a portion of it. 
      Note that you'll want to preview a section that wholly includes an edit section within it.
      For example, if it mutes from second 1 to second 10, you'll want to play from 00:00 to 00:12 or what not.
      Also note that the first time you preview a section of a video, it will take a long time (like an hour) as it sets up the entire video for processing.
      Subsequent previews will be faster, though, as long as you use the same filename, as it won't have to re-set it up for processing.
      Also note that if you change your edit list, you'll need to close, and restart the video to be able to see it with your new settings.
    EOL
    old_start = LocalStorage['start_time']
    start_time = get_user_input("At what point in the video would you like to start your preview? (like 01:00 for starting at 1 minute)", LocalStorage['start_time'])
    default_end = LocalStorage['end_time']
    if start_time and start_time != old_start
      default_end = EdlParser.translate_string_to_seconds(start_time) + 10
      default_end = EdlParser.translate_time_to_human_readable(default_end)
    end
    end_time = get_user_input("At what point in the video would you like to finish your preview? (like 02:00 for ending at the 2 minute mark)", default_end)
    unless start_time and end_time
      # this one is raw showMessageDialog...
      JOptionPane.showMessageDialog(nil, " Please choose start and end", "Failed", JOptionPane::ERROR_MESSAGE)
      return
    end
    LocalStorage['start_time'] = start_time
    LocalStorage['end_time'] = end_time
    [start_time, end_time]
end

#get_temp_file_name(name_with_ext) ⇒ `Object`



709
710
711

# File 'lib/gui/base.rb', line 709

def get_temp_file_name name_with_ext
  File.dirname(EdlTempFile) + '/' + name_with_ext
end

#get_title_track_string(descriptors, use_default_of_one = true) ⇒ `Object`

# File 'lib/gui/base.rb', line 162

def get_title_track_string descriptors, use_default_of_one = true
  given = descriptors["dvd_title_track"] 
  given ||= "1" if use_default_of_one
  given
end

#get_upconvert_secondary_settings ⇒ `Object`



277
278
279

# File 'lib/gui/upconvert.rb', line 277

def get_upconvert_secondary_settings
  LocalStorage[UpConvertKeyExtra]
end

#get_upconvert_vf_settings ⇒ `Object`

# File 'lib/gui/upconvert.rb', line 262

def get_upconvert_vf_settings
  template = LocalStorage[UpConvertKey]
  if template
    screen_multiple = LocalStorage[ScreenMultipleFactor]
    upc = template.gsub('SCREEN_X', (get_current_max_width_resolution*screen_multiple).to_i.to_s) # has to be an integer...
    upc = 'pullup,softskip,' + upc
    show_non_blocking_message_dialog 'using upconvert settings ' + upc
    p 'using upconvert settings: ' + upc
    upc
  else
    p 'not using any specific upconversion-ing'
    # pullup, softskip -- might slow things down too much for slow cpus
  end
end

#get_user_input(message, default = '', cancel_ok = false) ⇒ `Object`



572
573
574

# File 'lib/gui/base.rb', line 572

def get_user_input(message, default = '', cancel_ok = false)
  SwingHelpers.get_user_input message, default, cancel_ok
end

#get_user_input_with_persistence(message, storage_key) ⇒ `Object`

# File 'lib/gui/base.rb', line 567

def get_user_input_with_persistence(message, storage_key)
  got = get_user_input(message, LocalStorage[storage_key])
     LocalStorage[storage_key] = got
  got
end

#hard_exit ⇒ `Object`

26	# File 'lib/gui/normal.rb', line 26 def hard_exit; java::lang::System.exit 0; end

#increment_button_location(how_much = 30) ⇒ `Object`

# File 'lib/gui/base.rb', line 208

def increment_button_location how_much = 30
  @starting_button_y += how_much
  setSize @button_width+80, @starting_button_y + 50
end

#is_dvd?(drive_or_file) ⇒ `Boolean`

Returns:

(Boolean)

# File 'lib/gui/base.rb', line 449

def is_dvd? drive_or_file
  # it's like a/b/VIDEO_TS or d:/
  if File.basename(File.dirname(drive_or_file)) == 'VIDEO_TS' 
    # /a/b/c/VIDEO_TS/yo.vob
    true
  elsif File.exist?(drive_or_file + '/VIDEO_TS')
    # d:\
    true
  elsif OS.mac? && (drive_or_file =~ /\/dev\/rdisk\d+/)
    true
  else
   false
  end
end

#new_child_window ⇒ `Object`

a window that when closed doesn’t bring the whole app down

# File 'lib/gui/base.rb', line 221

def new_child_window
  child = MainWindow.new true, []
  child.setDefaultCloseOperation(JFrame::DISPOSE_ON_CLOSE) # don't exit on close
  child.parent=self # this should have failed in the PPL
  # make both windows visible by moving the child down and to the right of its parent
  x, y = self.get_location.x, self.get_location.y
  child.set_location(x + 100, y + 100)
  child
end

#new_existing_file_selector_and_select_file(title, dir = nil) ⇒ `Object`

also caches directory previously selected …

# File 'lib/gui/base.rb', line 541

def new_existing_file_selector_and_select_file title, dir = nil
  bring_to_front unless OS.mac? # causes duplicate prompts or something?
  unique_trace = caller.inspect
  if LocalStorage[unique_trace]
    dir = LocalStorage[unique_trace]
  end
  p 'using system default dir' unless dir # happens more frequently after code changes alter the path :P
  p 'using lookup dir ' + dir, LocalStorage[unique_trace] if $VERBOSE
  got = SwingHelpers.new_previously_existing_file_selector_and_go title, dir
  LocalStorage[unique_trace] = File.dirname(got)
  got
end

#new_jbutton(title, tooltip = nil) ⇒ `Object`

# File 'lib/gui/base.rb', line 185

def new_jbutton title, tooltip = nil
  button = JButton.new title
  button.tool_tip = tooltip
  button.set_bounds(44, @starting_button_y, @button_width, 23)
  @panel.add button
  @buttons << button
  if block_given? # allow for new_jbutton("xx") do ... end [this is possible through some miraculous means LOL]
    button.on_clicked { yield }
  end
  increment_button_location
  button
end

#new_nonexisting_filechooser_and_go(title = nil, default_dir = nil, default_file = nil) ⇒ `Object`

# File 'lib/gui/base.rb', line 535

def new_nonexisting_filechooser_and_go title = nil, default_dir = nil, default_file = nil
  bring_to_front unless OS.mac? # causes triples on mac! TODO rdp
  JFileChooser.new_nonexisting_filechooser_and_go title, default_dir, default_file
end

#normalize_path(path) ⇒ `Object`

converts to full path, 8.3 if on doze

# File 'lib/gui/base.rb', line 714

def normalize_path path
  path = File.expand_path path
  path = EightThree.convert_path_to_8_3 path if OS.doze?
end

#open_edl_file_when_done(thred, filename) ⇒ `Object`

# File 'lib/gui/create.rb', line 5

def open_edl_file_when_done thred, filename
  Thread.new {
    thred.join
    open_file_to_edit_it filename
  }
end

#open_file_to_edit_it(filename, options = {}) ⇒ `Object`

:start_minimized is the only option

# File 'lib/gui/base.rb', line 522

def open_file_to_edit_it filename, options = {} # :start_minimized is the only option
  if OS.windows?
    if options[:start_minimized]
      system_non_blocking "start /min notepad \"#{filename}\""
    else
      system_non_blocking "notepad \"#{filename}\""
    end
  else
    # ignore minimized :P
    system_non_blocking "open -a TextEdit \"#{filename}\""
  end
end

#parse_edl(path) ⇒ `Object`



590
591
592

# File 'lib/gui/base.rb', line 590

def parse_edl path
  EdlParser.parse_file path
end

#play_dvd_smplayer_unedited(use_mplayer_instead) ⇒ `Object`

# File 'lib/gui/base.rb', line 380

def play_dvd_smplayer_unedited use_mplayer_instead
  drive_or_file, dvd_volume_name, dvd_id, edl_path_maybe_nil, descriptors = choose_dvd_or_file_and_edl_for_it(force_choose_edl_file_if_no_easy_match = true)
  title_track_maybe_nil = get_title_track_string(descriptors, false)
  if is_dvd?(drive_or_file)
    dvd_options = get_dvd_playback_options(descriptors)
  else
    dvd_options = ''
  end
  run_smplayer_non_blocking drive_or_file, title_track_maybe_nil, dvd_options, use_mplayer_instead, true, false, get_srt_filename(descriptors, edl_path_maybe_nil)
end

#play_smplayer_edl_non_blocking(optional_file_with_edl_path = nil, extra_mplayer_commands_array = [], force_mplayer = false, start_full_screen = true, add_secs_end = 0, add_secs_begin = begin_buffer_preference, show_subs = false) ⇒ `Object`

# File 'lib/gui/base.rb', line 470

def play_smplayer_edl_non_blocking optional_file_with_edl_path = nil, extra_mplayer_commands_array = [], force_mplayer = false, start_full_screen = true, add_secs_end = 0, 
 add_secs_begin = begin_buffer_preference, show_subs = false
  if we_are_in_create_mode
    assert(add_secs_begin == 0 && add_secs_end == 0)
  end
  if optional_file_with_edl_path
    drive_or_file, edl_path = optional_file_with_edl_path
    dvd_id = NonDvd # fake it out...LODO a bit smelly/ugly
  else
    drive_or_file, dvd_volume_name, dvd_id, edl_path, descriptors = choose_dvd_or_file_and_edl_for_it
  end
  start_add_this_to_all_ts = 0
	  
  if edl_path # some don't have one [?]
 begin
# TODO combine these 2 methods yipzers
      descriptors = EdlParser.parse_file edl_path
     splits = [] # TODO not pass as parameter either
      edl_contents = MplayerEdl.convert_to_edl descriptors, add_secs_end, add_secs_begin, splits, start_add_this_to_all_ts # add a sec to mutes to accomodate for mplayer's oddness..
      File.write(EdlTempFile, edl_contents)
      extra_mplayer_commands_array << "-edl #{EdlTempFile}" 
		rescue SyntaxError => e
show_blocking_message_dialog "unable to parse file! #{edl_path} #{e}"
raise
		end
    title_track = get_title_track_string(descriptors)
  end
  
  if is_dvd?(drive_or_file)
    # it's a DVD of some sort
    extra_mplayer_commands_array << get_dvd_playback_options(descriptors)
  else
 check_for_ffmpeg_installed
 # it's a file
    # check if it has a start offset...
    all =  `ffmpeg -i "#{drive_or_file}" 2>&1` # => Duration: 01:35:49.59, start: 600.000000
    all =~ /Duration.*start: ([\d\.]+)/
    start = $1.to_f
    if start > 1 # LODO dvd's themselves start at 0.3 [sintel], but I don't think much higher than that never seen it...
      show_non_blocking_message_dialog "Warning: file seems to start at an extra offset, adding it to the timestamps... #{start}
        maybe not compatible with XBMC, if that's what you use, and you probably don't" # LODO test it XBMC...
      start_add_this_to_all_ts = start
    end
  end
  
  run_smplayer_non_blocking drive_or_file, title_track, extra_mplayer_commands_array.join(' '), force_mplayer, show_subs, start_full_screen, get_srt_filename(descriptors, edl_path)
end

#print(*args) ⇒ `Object`



518
519
520

# File 'lib/gui/base.rb', line 518

def print *args
  Kernel.print *args # avoid bin\sensible-cinema.rb:83:in `system_blocking': cannot convert instance of class org.jruby.RubyString to class java.awt.Graphics (TypeError)
end

#require_blocking_license_accept_dialog(program, license_name, license_url_should_also_be_embedded_by_you_in_message, title = 'Confirm Acceptance of License Agreement', message = nil) ⇒ `Object`

# File 'lib/gui/dependencies.rb', line 139

def require_blocking_license_accept_dialog program, license_name, license_url_should_also_be_embedded_by_you_in_message, 
  title = 'Confirm Acceptance of License Agreement', message = nil
  puts 'Please confirm license agreement in open window before proceeding.'
  
  message ||= "Sensible Cinema requires a separately installed program (#{program}), not yet installed.
    You can install this program manually to the vendor/cache subdirectory, or Sensible Cinema can download it for you.
    By clicking accept, below, you are confirming that you have read and agree to be bound by the
    terms of its license (the #{license_name}), located at #{license_url_should_also_be_embedded_by_you_in_message}.  
    Click 'View License' to view it.  If you do not agree to these terms, click 'Cancel'.  You also agree that this is a 
    separate program, with its own distribution, license, ownership and copyright.  
    You agree that you are responsible for the download and use of this program, within sensible cinema or otherwise."
  answer = JOptionPane.show_select_buttons_prompt message, :no => "I have read and Accept the terms of the #{license_name} License Agreement.", :yes => "View #{license_name}"
  assert_confirmed_dialog answer, license_url_should_also_be_embedded_by_you_in_message
  p 'confirmation of sensible cinema related license duly noted of: ' + license_name # LODO require all licenses together :P
end

#reset_upconversion_options ⇒ `Object`

# File 'lib/gui/upconvert.rb', line 96

def reset_upconversion_options
	LocalStorage[UpConvertKey] = nil
    LocalStorage[UpConvertKeyExtra] = nil
    LocalStorage[UpConvertEnglish] = nil
end

#run_smplayer_blocking(play_this, title_track_maybe_nil, passed_in_extra_options, force_use_mplayer, show_subs, start_full_screen, srt_filename) ⇒ `Object`

basically run mplayer/smplayer on a file or DVD

# File 'lib/gui/base.rb', line 238

def run_smplayer_blocking play_this, title_track_maybe_nil, passed_in_extra_options, force_use_mplayer, show_subs, start_full_screen, srt_filename
  raise unless passed_in_extra_options # cannot be nil
  extra_options = []
  # -framedrop is for slow CPU's
  # same with -autosync to try and help it stay in sync... -mc 0.03 is to A/V correct 1s audio per 2s video
  # -hardframedrop might help but hurts the eyes just too much
  extra_options << "-framedrop" # even in create mode, if the audio ever gets off, we're hosed with making accurate timestamps...so drop, until I hear otherwise...
  extra_options << "-mc 2"
  extra_options << "-autosync 30" 

  if we_are_in_create_mode
    extra_options << "-osdlevel 2"
    extra_options << "-osd-verbose" if we_are_in_developer_mode?		
  end
  extra_options << "-osd-fractions 1"
  
  if !show_subs && !srt_filename
    # disable all subtitles :P
    extra_options << "-nosub -noautosub -forcedsubsonly -sid 1000"
  end
 if srt_filename
   extra_options << "-sub #{srt_filename}"
 else
    extra_options << "-alang en"
    extra_options << "-slang en"
 end

  force_use_mplayer ||= OS.mac?
  parent_parent = File.basename(File.dirname(play_this))
  if parent_parent == 'VIDEO_TS'
    # case d:\yo\VIDEO_TS\title0.vob
    dvd_device_dir = normalize_path(File.dirname(play_this))
    play_this = "\"dvdnav://#{title_track_maybe_nil}/#{dvd_device_dir}/..\""
  elsif File.exist?(play_this + '/VIDEO_TS') || (play_this =~ /\/dev\/rdisk\d/)
    # case d:\ where d:\VIDEO_TS exists [DVD mounted in drive, or DVD dir] or mac's /dev/rdisk1
    play_this = "\"dvdnav://#{title_track_maybe_nil}/#{play_this}\""
  else
    # case g:\video\filename.mpg
    # leave it the same...
  end
  if play_this =~ /dvdnav/ && title_track_maybe_nil
    extra_options << "-msglevel identify=4" # prevent smplayer from using *forever* to look up info on DVD's with -identify ...
  end
  
  extra_options << "-mouse-movements #{get_upconvert_secondary_settings}" # just in case smplayer also needs -mouse-movements... :) LODO
  extra_options << "-lavdopts threads=#{OS.cpu_count}" # just in case this helps [supposed to with h.264] # NB fast *crashes* doze...
  if force_use_mplayer
    extra_options << "-font #{File.expand_path('vendor/subfont.ttf')}"
 key_strokes = <<-EOL
RIGHT seek +10
LEFT seek -10
DOWN seek -60
UP seek +60
ENTER {dvdnav} dvdnav select	  
MOUSE_BTN0 {dvdnav} dvdnav select
MOUSE_BTN0_DBL vo_fullscreen
MOUSE_BTN2 vo_fullscreen
KP_ENTER dvdnav select
# some for os x, some for doze. huh?
   EOL
   conf_file = File.expand_path './mplayer_input_conf'
   File.write conf_file, key_strokes
   extra_options << "-volume 100" # why start low? mplayer why oh why LODO
   if OS.windows?
    # direct3d for windows 7 old nvidia cards' sake [yipes] and also dvdnav sake
    extra_options << "-vo direct3d"
    conf_file = conf_file[2..-1] # strip off drive letter, which it doesn't seem to like no sir
   end
   if start_full_screen
     extra_options << "-fs"
     upconv = get_upconvert_vf_settings
     upconv = "-vf #{upconv}" if upconv.present?
   else
    upconv = ""
   end
   if OS.doze?
     mplayer_loc = LocalModifiedMplayer
     assert File.exist?(mplayer_loc)
   else
     mplayer_loc = "mplayer"
   end
   c = "#{mplayer_loc} #{extra_options.join(' ')} #{upconv} -input conf=\"#{conf_file}\" #{passed_in_extra_options} \"#{play_this}\" "
  else
    if OS.windows?
      extra_options << "-vo direct3d" # more light nvidia...should be ok...this wastes cpu...but we have to have it I guess...
    end
    set_smplayer_opts extra_options.join(' ') + " " + passed_in_extra_options, get_upconvert_vf_settings, show_subs
    c = "smplayer \"#{play_this}\" -config-path \"#{File.dirname  EightThree.convert_path_to_8_3(SMPlayerIniFile)}\" " 
    c += " -fullscreen " if start_full_screen
    if !we_are_in_create_mode
      #c += " -close-at-end " # still too unstable...
    end
  end
  puts c
  system_blocking c
end

#run_smplayer_non_blocking(*args) ⇒ `Object`

# File 'lib/gui/base.rb', line 231

def run_smplayer_non_blocking *args
  @background_thread = Thread.new {
    run_smplayer_blocking *args
  }
end

#sanity_check_file(filename) ⇒ `Object`

# File 'lib/gui/create-file.rb', line 5

def sanity_check_file filename
	  check_for_ffmpeg_installed
  out = `ffmpeg -i #{filename} 2>&1`
  print out
  unless out =~ /Duration.*start: 0.00/ || out =~ /Duration.*start: 600/
    show_blocking_message_dialog 'file\'s typically have the movie start at zero, this one doesn\'t? Please report.' + out
    raise # give up, as otherwise we're 0.3 off, I think...hmm...
  end
  if filename =~ /\.mkv/i
    show_blocking_message_dialog "warning .mkv files from makemkv have been known to be off timing wise, please convert to a .ts file using tsmuxer first if it did come from makemkv"
  else
    if filename !~ /\.(ts|mpg|mpeg)$/i
      show_blocking_message_dialog("warning: file #{filename} is not a .mpg or .ts file--conversion may not work properly all the way [produce a truncated file], but we can try it if you want...") 
    end
  end
end

#set_individual_preferences ⇒ `Object`

# File 'lib/gui/dependencies.rb', line 178

def set_individual_preferences
     get_set_preference 'mplayer_beginning_buffer', "How much extra \"buffer\" time to add at the beginning of all cuts/mutes in normal mode [for added safety sake]."
     if JOptionPane.show_select_buttons_prompt("Would you like to use this with Zoom Player MAX's scene cuts [3rd party player program, costs $], or MPlayer et al [free]", :no => "ZoomPlayer MAX", :yes => "MPlayer/VLC/DVD-Navigator [all free]") == :no
       LocalStorage['have_zoom_button'] = true
     else
    LocalStorage['have_zoom_button'] = false
  end
  # TODO break these out into create mode prefs versus human [?]
     if JOptionPane.show_select_buttons_prompt("Would you like to enable some obscure options, like
Using keyboard shortcuts to create EDL files on the fly, or 
Prompting to create euphemized .srt files, or
Being able to add your own 'profanity words' specific to different videos?
(Most users answer no to this).", :yes => 'No', :no => 'Yes') == :no
       LocalStorage['prompt_obscure_options'] = true
     else
    LocalStorage['prompt_obscure_options'] = false
  end
  if JOptionPane.show_select_buttons_prompt("Would you like to enable upconversion [i.e. make playback prettier, requires more cpu?]") == :yes
    setup_dvd_upconvert_options
  else
    reset_upconversion_options
  end
  true
end

#set_smplayer_opts(to_this, video_settings, show_subs = false) ⇒ `Object`

# File 'lib/gui/base.rb', line 338

def set_smplayer_opts to_this, video_settings, show_subs = false
  p 'setting smplayer extra opts to this:' + to_this
  old_prefs = File.read(SMPlayerIniFile) rescue ''
  unless old_prefs.length > 0
    # LODO double check the rest here...
    old_prefs = "[%General]\nmplayer_bin=\n[advanced]\nmplayer_additional_options=\nmplayer_additional_video_filters=\n[subtitles]\nautoload_sub=false\n[performance]\npriority=3" 
  end
  raise to_this if to_this =~ /"/ # unexpected, unfortunately... <smplayer bug>
  assert new_prefs = old_prefs.gsub(/mplayer_additional_options=.*/, "mplayer_additional_options=#{to_this}")
  assert new_prefs.gsub!(/autoload_sub=.*$/, "autoload_sub=#{show_subs.to_s}")
  raise 'unexpected' if get_upconvert_vf_settings =~ /"/
  assert new_prefs.gsub!(/mplayer_additional_video_filters=.*$/, "mplayer_additional_video_filters=\"#{video_settings}\"")
  raise 'smplayer on non doze not expected...' unless OS.doze?
  mplayer_to_use = LocalModifiedMplayer  
  assert File.exist?(mplayer_to_use)
  new_value = "\"" + mplayer_to_use.to_filename.gsub("\\", '/') + '"' # forward slashes. Weird.
  assert new_prefs.gsub!(/mplayer_bin=.*$/, "mplayer_bin=" + new_value)
  # now some less important ones...
  new_prefs.gsub!(/priority=.*$/, "priority=3") # normal priority...scary otherwise! lodo tell smplayer...
  # enable dvdnav navigation, just for kicks I guess.
  new_prefs.gsub!(/use_dvdnav=.*$/, "use_dvdnav=true")
  
  FileUtils.mkdir_p File.dirname(SMPlayerIniFile)
  File.write(SMPlayerIniFile, new_prefs)
  new_prefs.each_line{|l| print l if l =~ /additional_video/} # debug
end

#setup_create_buttons ⇒ `Object`

# File 'lib/gui/create.rb', line 12

def setup_create_buttons
	  # only create mode needs this uh guess
  EdlParser.on_any_file_changed_single_cached_thread { DriveInfo.notify_all_drive_blocks_that_change_has_occured }
	  
 add_text_line 'Normal playback Options:'
  new_jbutton("Display Standard Playback Options") do
    window = new_child_window
    window.setup_normal_buttons
  end
  
  add_text_line 'Create: Edit Decision List File Options:'
  
  @open_current = new_jbutton("Edit/Open EDL for currently inserted DVD") do
    drive, volume_name, dvd_id = choose_dvd_drive_or_file true # require a real DVD disk :)
    edit_list_path = EdlParser.single_edit_list_matches_dvd(dvd_id)
    if edit_list_path
      open_file_to_edit_it edit_list_path
    else
      show_blocking_message_dialog "EDL for this dvd doesn't exist yet, maybe create it first? #{volume_name}"
    end
  end
  
  create_new_edl_for_current_dvd_text = "Create new Edit List for currently inserted DVD"
  @create_new_edl_for_current_dvd = new_jbutton(create_new_edl_for_current_dvd_text, 
      "If your DVD doesn't have an EDL created for it, this will be your first step--create an EDL file for it.")
  @create_new_edl_for_current_dvd.on_clicked do
   drive, volume_name, dvd_id = choose_dvd_drive_or_file true # require a real DVD disk :)
    edit_list_path = EdlParser.single_edit_list_matches_dvd(dvd_id, true)
    if edit_list_path
  if show_select_buttons_prompt('It appears that one or more EDL\'s exist for this DVD already--create another?', {}) == :no
      raise 'aborted'
  end
    end	  
    create_brand_new_dvd_edl
    show_blocking_message_dialog "Now that it's created, you can add some entries by hand, or try downloading a subtitle\nfile and parsing it to look for profanities\nif it finds any, then copy and paste them into the file you just created"
  end
  
  add_callback_for_dvd_edl_present { |disk_available, edl_available|
    #TODO rdp file buttons
    @open_current.set_enabled edl_available
    #@create_new_edl_for_current_dvd.set_enabled disk_available
    if edl_available
      @create_new_edl_for_current_dvd.text= create_new_edl_for_current_dvd_text + " [yours already has one!]"
    else
if disk_available
        @create_new_edl_for_current_dvd.text= create_new_edl_for_current_dvd_text + " [it doesn't have one yet!]"
else
  @create_new_edl_for_current_dvd.text= create_new_edl_for_current_dvd_text + " [no disk inserted!]"
end
    end
  }
  
  @parse_srt = new_jbutton("Scan a subtitle file to detect profanity timestamps automatically" )
  @parse_srt.tool_tip = <<-EOL
    You can download a .srt file and use it to programmatically search for the location of various profanities.
    Basically download it from opensubtitles.org 
    (or google search for something like your equivalent for "prince of egypt subtitles 1cd en",
    (for opensubtitles.org enter dvd title in the search box, click on a result, click one from the list with an English flag, 
    then choose 'Download(zip)', then unzip the file)
    NB that you'll want/need to *carefully* double check your subtitle file for accuracy. Here's how:
    Now carefully compare a beginning timestamp in it with the actual words in the .srt file 
    with the actual DVD.
    (see the button "Watch DVD unedited (realtime mplayer)")
    (smplayer can kind of do it, too, play it, hit the 'o' button to display
    the OSD timestamp, then go to just before the verbiage, 
    and hit the '.' key until a subtitle very first appears.
    Next convert that number to 29.97 fps (using the button for that).
  EOL

  @parse_srt.on_clicked do

    srt_filename = new_existing_file_selector_and_select_file("Pick srt file to scan for profanities [may need to download .srt file first]:", File.expand_path('~'))
  if(srt_filename =~ /utf16/) # from subrip sometimes
    show_blocking_message_dialog "warning--filename #{srt_filename} may be in utf16, which we don't yet parse"
                end
		if srt_filename =~ /\.sub$/i
show_blocking_message_dialog "warning--input file has to be in SubRip [.srt] format, and yours might be in .sub format, which is incompatible"
		end
    # TODO nuke, or do I use them for the 600.0 stuff?
    add_to_beginning = "0.0"#get_user_input("How much time to subtract from the beginning of every subtitle entry (ex: (1:00,1:01) becomes (0:59,1:01))", "0.0")
    add_to_end = "0.0"#get_user_input("How much time to add to the end of every subtitle entry (ex: (1:00,1:04) becomes (1:00,1:05))", "0.0")
 
    euphemized_entries = euphemized_filename = nil
    with_autoclose_message("parsing srt file... #{File.basename srt_filename}") do
      parsed_profanities, euphemized_entries = SubtitleProfanityFinder.edl_output_from_string File.read(srt_filename), {},  0, 0, 0, 0, 3000, 3000
      write_subs_to_file euphemized_filename = get_temp_file_name('euphemized.subtitles.srt.txt'), euphemized_entries
    end

	if show_select_buttons_prompt("Sometimes subtitle files' time signatures don't match precisely with the video.\nWould you like to enter some information to allow it to synchronize the timestamps?\n  (on the final pass you should do this, even if it already matches well, for future information' sake)") == :yes

      if show_select_buttons_prompt("Would you like to start playing the movie in mplayer, to be able to search for subtitle timestamp times [you probably do...]?\n") == :yes
        show_blocking_message_dialog "ok--use the arrow keys and pgdown/pgup to search/scan, and then '.' to pinpoint a precise subtitle start time within mplayer.\nYou will be prompted for a beginning and starting timestamp time to search for."
        play_dvd_smplayer_unedited true
      end

 open_file_to_edit_it euphemized_filename
      sleep 0.5 # let it open in TextEdit/Notepad first...
  	  bring_to_front

      all_entries = euphemized_entries # rename :)
      start_entry = all_entries[0]
      start_text = start_entry.single_line_text
      start_srt_time = start_entry.beginning_time
      human_start = EdlParser.translate_time_to_human_readable(start_srt_time)
      start_movie_sig = get_user_input_with_persistence("Enter beginning timestamp within the movie itself for when the subtitle \"#{start_text}\"\nfirst frame the subtitle appears on the on screen display (possibly near #{human_start})", start_text)
      start_movie_time = EdlParser.translate_string_to_seconds start_movie_sig
      if(show_select_buttons_prompt 'Would you like to select an ending timestamp at the end or 3/4 mark of the movie [end can be a spoiler at times]?', :yes => 'very end of movie', :no => '3/4 of the way into movie') == :yes
       end_entry = all_entries[-1]
      else
       end_entry = all_entries[all_entries.length*0.75] 
      end
      end_text = end_entry.single_line_text
      end_srt_time = end_entry.beginning_time
      human_end = EdlParser.translate_time_to_human_readable(end_srt_time)
      end_movie_sig = get_user_input_with_persistence("Enter beginning timestamp within the movie itself for when the subtitle ##{end_entry.index_number}\n\"#{end_text}\"\nfirst appears (possibly near #{human_end}).\nYou can find it by searching to near that time in the movie [pgup+pgdown, then arrow keys], find some subtitle, then find where that subtitle is within the .srt file to see where it lies\nrelative to the one you are interested in\nthen seek relative to that to find the one you want.", end_text) 
end_movie_time = EdlParser.translate_string_to_seconds end_movie_sig
    else
      # the case they know it already matches
	  start_srt_time = 0
      start_movie_time = 0
      end_srt_time = 3000
      end_movie_time = 3000
	end

    parsed_profanities, euphemized_synchronized_entries = nil
		extra_profanity_hash = {}
		if LocalStorage['prompt_obscure_options']
for entry in get_user_input_with_persistence("enter any 'extra' words to search for, like badword1,badword2 if any", srt_filename).split(',')
  extra_profanity_hash[entry] = entry
end
		end
    with_autoclose_message("parsing srt file... #{File.basename srt_filename}") do
      parsed_profanities, euphemized_synchronized_entries = SubtitleProfanityFinder.edl_output_from_string File.read(srt_filename), extra_profanity_hash, add_to_beginning.to_f, add_to_end.to_f, start_srt_time, start_movie_time, end_srt_time, end_movie_time
    end
    
    filename = get_temp_file_name('partial.edl.txt')
    out =  "# copy and paste these into your \"mute\" section of A SEPARATE EDL already created with the other buttons, for lines you deem them mutable\n" + parsed_profanities
    if end_srt_time != 3000
out += %!\n\n#Also add these lines at the bottom of the EDL (for later coordination):\n"beginning_subtitle" => ["#{start_text}", "#{start_movie_sig}", #{start_entry.index_number}],! +
           %!\n"ending_subtitle_entry" => ["#{end_text}", "#{end_movie_sig}", #{end_entry.index_number}],!
 end
    middle_entry = euphemized_synchronized_entries[euphemized_synchronized_entries.length*0.5]
    show_non_blocking_message_dialog "You may want to double check if the math worked out.\n\"#{middle_entry.single_line_text}\" (##{middle_entry.index_number})\nshould appear at #{EdlParser.translate_time_to_human_readable middle_entry.beginning_time}\nYou can go and check it!\nIf it's off much you may want to try this whole process again\n with a different other .srt file"
    File.write filename, out
    open_file_to_edit_it filename
    sleep 1 # let it open
		
		if LocalStorage['prompt_obscure_options']
   if show_select_buttons_prompt("Would you like to write out a synchronized, euphemized .srt file [useful if you want to watch the movie with sanitized subtitles later]\nyou probably don't?") == :yes
        out_file = new_nonexisting_filechooser_and_go("Select filename to write to", File.dirname(srt_filename), File.basename(srt_filename)[0..-5] + ".euphemized.srt")
  write_subs_to_file out_file, euphemized_synchronized_entries
        show_in_explorer out_file
      end
		end
    
  end
	  
  add_text_line 'Create: Advanced View Edited Options'
  
  @mplayer_edl_with_subs = new_jbutton( "Watch DVD edited (realtime) (with mplayer, subtitles)") do
    watch_dvd_edited_realtime_mplayer true
  end
  
	  @mplayer_edl_with_subs.tool_tip="This watches it in mplayer, which has access to its console output, and also includes subtitles."
	  
  @mplayer_partial = new_jbutton( "Watch DVD edited (realtime) (mplayer) based on timestamp") do
    times = get_start_stop_times_strings
    times.map!{|t| EdlParser.translate_string_to_seconds t}
    start_time = times[0]
    end_time = times[1]
    extra_mplayer_commands = ["-ss #{start_time}", "-endpos #{end_time - start_time}"]
    play_smplayer_edl_non_blocking nil, extra_mplayer_commands, true, false, add_end = 0.0, add_begin = 0.0 # create mode => aggressive
  end
	  
	  @mplayer_partial.tool_tip="this can play just a specific portion of your film, like from second 30 to 35, for testing."
        
  new_jbutton("Display mplayer keyboard commands/howto/instructions") do
    show_mplayer_instructions
  end

  add_text_line "Create: Watch Unedited Options:"
  
  @play_smplayer = new_jbutton( "Watch DVD unedited (realtime smplayer)")
  @play_smplayer.tool_tip = <<-EOL
    This will play the DVD unedited within smplayer.
    NB it will default to title 1, so updated your EDL file that matches this DVD with the proper title if this doesn't work for you 
    i.e. if it just plays a single preview title or what not, and not the main title, you need to change this value.
    This is useful if you want to just kind of watch the movie to enjoy it, and look for scenes to cut out.
    You can use the built-in OSD (on-screen-display) to see what time frame the questionable scenes are at
    (type "o" to toggle it).  However, just realize that the OSD is in 30 fps, and our time stamps are all in 29.97
    fps, so you'll need to convert it (the convert timestamp button) to be able to use it in a file.
    NB That you can get the mplayer keyboard control instructions with the show instructions button.
  EOL
  @play_smplayer.on_clicked {
    play_dvd_smplayer_unedited false
  }

  add_text_line "Less commonly used Edit options:"

  new_jbutton("Create new Edit List (for netflix instant or movie file)") do # LODO VIDEO_TS here too?
 create_new_for_file_or_netflix
  end
  
  new_jbutton("Show more (rarely used) buttons/options") do
    child = new_child_window
    child.show_rarely_used_buttons
  end

end

#setup_default_buttons ⇒ `Object`

# File 'lib/gui/base.rb', line 680

def setup_default_buttons
  if we_are_in_upconvert_mode
    add_play_upconvert_buttons
  else
    if we_are_in_create_mode
      setup_create_buttons
    else
      setup_normal_buttons
    end
  
  end # big else
  
  @exit = new_jbutton("Exit", "Exits the application and kills any background processes that are running at all--don't exit unless you are done processing all the way!")
  @exit.on_clicked {
    Thread.new { self.close } # don't waste the time to close it :P
    puts 'Thank you for using Sensible Cinema. Come again!'
    System.exit 0
  }

  increment_button_location
  increment_button_location
  self

end

#setup_dvd_upconvert_options ⇒ `Object`

# File 'lib/gui/upconvert.rb', line 84

def setup_dvd_upconvert_options
 luma_spatial = 0
    chroma_spatial = 1
    luma_tmp = 4
    chroma_tmp = 4
		# SCREEN_X is replaced later.
    LocalStorage[UpConvertKey] = "hqdn3d=%s:%s:%s:%s,scale=SCREEN_X:-10:0:0:2" % [luma_spatial, chroma_spatial, luma_tmp, chroma_tmp]
    # hqdn3d[=luma_spatial:chroma_spatial:luma_tmp:chroma_tmp]
    LocalStorage[UpConvertKeyExtra] = "-sws 9 -ssf ls=75.0 -ssf cs=7.0"
    LocalStorage[UpConvertEnglish] = "DVD"
end

#setup_normal_buttons ⇒ `Object`

# File 'lib/gui/normal.rb', line 28

def setup_normal_buttons
  add_text_line ""
  
  @mplayer_edl = new_jbutton( watch_edited_text="Watch currently mounted DVD edited (realtime)" )
  @mplayer_edl.tool_tip = "This will watch your DVD in realtime from your computer while skipping/muting questionable scenes."
  @mplayer_edl.on_clicked {
    play_smplayer_edl_non_blocking
	sleep 5
	puts 'enjoy your movie playing in other window'
    sleep 1
	hard_exit if OS.doze? # paranoid on cpu usage LOL LODO mac too? it kills mplayer child processes currently...hmm...
  }
  
  add_callback_for_dvd_edl_present { |disk_available, edl_available|
    b = @mplayer_edl
 if disk_available
			if edl_available
 b.enable
 b.text=watch_edited_text
			else
 b.enable # leave it enabled in case it's some nonstandard form of a disk that does have one [?]
 b.text= watch_edited_text + "  [disk has no Edit List Available!]" 
			end
		else
@mplayer_edl.disable
@mplayer_edl.text=watch_edited_text + " [no disk presently inserted]"
		end
  }
  
  @watch_file_edl = new_jbutton( "Watch movie file edited (realtime)" ) do
    force_accept_file_style_license
    choose_file_and_edl_and_create_sxs_or_play false
  end
  
  if LocalStorage[UpConvertEnglish] # LODO no tight coupling like this
    add_text_line ''
    add_open_documentation_button
    @upconv_line = add_text_line "    #{get_current_upconvert_as_phrase}"
  else
    @upconv_line = add_text_line ''
    add_open_documentation_button
  end
  
  @show_upconvert_options = new_jbutton("Tweak Preferences [timing, upconversion]") do
 set_individual_preferences
    show_blocking_message_dialog "You will now be able to set some upconversion options, which makes the playback look nicer but uses more cpu [if desired].\nClose the window when finished."
    upconvert_window = new_child_window
    upconvert_window.add_change_upconvert_buttons
  end
  @show_upconvert_options.tool_tip= "Allows you to set your upconvert options.\nUpconverting attempts to playback your movie with higher quality on high resolution monitors."
  
  new_jbutton("Create new Edit Decision List for a DVD or File that doesn't have one yet") do
   window = new_child_window
      window.setup_create_buttons
 end
		
    @upload = new_jbutton("Feedback/questions welcome!") # keeps this one last! :)
    @upload.tool_tip = "We welcome all feedback!\nQuestion, comments, request help.\nAlso if you create a new EDL, please submit it back to us so that others can benefit from it later!"
    @upload.on_clicked {
    show_blocking_message_dialog "ok, next it will open up the groups page now or optionally an email you could send"
      system_non_blocking("start mailto:[email protected]")
      system_non_blocking("start http://groups.google.com/group/sensible-cinema")
    }
    increment_button_location
	  
end

#show_blocking_message_dialog(message, title = , style = JOptionPane::INFORMATION_MESSAGE) ⇒ `Object`



554
555
556

# File 'lib/gui/base.rb', line 554

def show_blocking_message_dialog(message, title = message.split("\n")[0], style= JOptionPane::INFORMATION_MESSAGE)
  SwingHelpers.show_blocking_message_dialog message, title, style
end

#show_copy_pastable_string(message, value) ⇒ `Object`

# File 'lib/gui/base.rb', line 576

def show_copy_pastable_string(message, value)
  bring_to_front
  RubyClip.set_clipboard value            
  get_user_input message + " (has been copied to clipboard)", value, true
end

#show_in_explorer(filename) ⇒ `Object`



582
583
584

# File 'lib/gui/base.rb', line 582

def show_in_explorer filename
  SwingHelpers.show_in_explorer filename
end

#show_mplayer_instructions ⇒ `Object`

# File 'lib/gui/create.rb', line 510

def show_mplayer_instructions
  show_non_blocking_message_dialog <<-EOL
    About to run mplayer.  To control it (or smplayer), you can use these keyboard keys:
    spacebar : pause,
    double clicky/right click/'f' : toggle full screen,
    enter : select DVD menu currently highlighted
    arrow keys (left, right, up down, pg up, pg dn) : seek/scan
    / and *	: inc/dec volume.
    'o' key: turn on on-screen-display timestamps see wiki "understanding timestamps"
    'v' key: toggle display of subtitles.
    '.' key: step forward one frame.
    '#' key: change audio language track
    'j' : change subtitle track/language
	  [ and ] make playback faster or slower [like 2x]
  EOL
end

#show_non_blocking_message_dialog(message, close_button_text = 'Close') ⇒ `Object`

call dispose on this to close it if it hasn’t been canceled yet…

# File 'lib/gui/base.rb', line 559

def show_non_blocking_message_dialog message, close_button_text = 'Close'
  bring_to_front
  # lodo NonBlockingDialog it can get to the top instead of being so buried...
  SwingHelpers.show_non_blocking_message_dialog message, close_button_text
end

#show_rarely_used_buttons ⇒ `Object`

# File 'lib/gui/create.rb', line 235

def show_rarely_used_buttons
  if we_are_in_developer_mode?
   @reload = new_jbutton("[programmer mode] reload bin/sensible-cinema code") do
     for file in Dir[__DIR__ + '/*.rb']
       p file
       eval(File.read(file), TOPLEVEL_BINDING, file)
     end
   end
  end

  @display_dvd_info = new_jbutton( "Display information about current DVD (ID, timing, etc.)" )
  @display_dvd_info.tool_tip = "This is useful to setup a DVD's 'unique ID' within an EDL for it. \nIf your EDL doesn't have a line like disk_unique_id => \"...\" then you will want to run this to be able to add that line in."
  @display_dvd_info.on_clicked {
    Thread.new {
      out_hashes, title_lengths = get_disk_info
     out_string = out_hashes.map{|name, value| name.inspect + ' => ' + value.inspect  + ','}.join("\n") + "\n" + title_lengths.join("\n")
      out_string += %!\n"timestamps_relative_to" => ["dvd_start_offset","29.97"],! # since they're all this way currently
      filename = get_temp_file_name('disk_info.txt')
      File.write filename, out_string 
      open_file_to_edit_it filename
      out_string # for unit tests :) TODO
    }
  }
  
  @convert_seconds_to_ts = new_jbutton( "Convert 3600.0 <-> 1:00:00 style timestamps" )
  @convert_seconds_to_ts.on_clicked {
    input = get_user_input("Enter \"from\" timestamp, like 3600 or 1:40:00:", "1:00:00.1 or 3600.1")
    while(input)
      if input =~ /:/
        output = EdlParser.translate_string_to_seconds input
        output = "%.02f" % output # so they know we're not rounding for example 6.10 not 6.1
      else
        output = EdlParser.translate_time_to_human_readable input.to_f, true
      end 
      input = show_copy_pastable_string("Converted:", output)         
    end
  }
  
  @convert_timestamp = new_jbutton( "Convert timestamp from DVD player time to EDL time (30->29.97 fps)" )
  @convert_timestamp.tool_tip=<<-EOL
    Our EDL's assume 29.97 fps (which is what a DVD actually has).  Unfortunately most hardware or commercial DVD players
    think that the DVD is 30 fps, which means that if you use them for timestamps for your EDL's,
    you will be slightly off (at the end of a 2 hour film, by 8 seconds).  So all your edits will be wrong.
    How to fix: convert your times from "DVD player" time to "EDL accurate" time by using this button.
    This is necessary for all hardware DVD player timestamps, PowerDVD player (software), Windows Media Player (playing a DVD), 
    and mplayer's "on screen display" DVD timestamps.
    It is not necessary for smplayer timestamps (or mplayer's "V: 3600" in the command line), which are already 29.97.
    smplayer's on-screen-display (the 'o' key) is accurate (and doesn't suffer from MPEG timestamps resets midway through) 
    but is 30 fps, so timestamps would need to be converted.
    Dont use VLC for DVD timestamps at all--it can get up to 30s off!  VLC playing back a file is usually pretty accurate to 29.97.
    In general, GUI's like VLC or smplayer are always a tidge off (maybe 0.3s) from the right timestamp, so take that into consideration.
    Mplayers "V: 3600" is usually right on (29.97 fps), however.
  EOL
  @convert_timestamp.on_clicked {
    thirty_fps = get_user_input("Enter your DVD/hardware (30 fps) timestamp, I'll convert it to 29.97 (usable in EDL's):", "1:00:00.1")
    thirty_fps_in_seconds = EdlParser.translate_string_to_seconds thirty_fps
    twenty_nine_seven_fps = ConvertThirtyFps.from_thirty(thirty_fps_in_seconds)
    human_twenty_nine_seven = EdlParser.translate_time_to_human_readable twenty_nine_seven_fps, true
    show_copy_pastable_string("Sensible cinema usable value (29.97 fps) for #{thirty_fps} would be:                ", human_twenty_nine_seven)
  }
  
  @create_dot_edl = new_jbutton( "Create a side-by-side moviefilename.edl file [XBMC etc.]")
  @create_dot_edl.tool_tip = <<-EOL
    Creates a moviefilename.edl file (corresponding to some moviefilename.some_ext file already existing)
    XBMC/smplayer (smplayer can be used by WMC plugins, etc.) "automagically detect", 
    if it exists, and automatically use it .edl to show that file edited played back.
    If you use smplayer, note that you'll need to download the "lord mulder mplayer"
    version (which includes an updated version of mplayer that fixes some bugs in EDL playback)
  EOL
  @create_dot_edl.on_clicked {
    show_blocking_message_dialog "Warning: With XBMC you'll need at least Eden v11.0 for mutes to work at all"
    choose_file_and_edl_and_create_sxs_or_play true
  }
	  
  if LocalStorage['have_zoom_button']
    @create_zoomplayer = new_jbutton( "Create a ZoomPlayer MAX compatible EDL file") do
      raise unless OS.doze?
      @prompt ||= show_blocking_message_dialog <<-EOL
  To work with ZoomPlayer MAX's scene cut functionality, first play the DVD you want to watch edited, and 
  create a dummy cut for it in it via the ZoomPlayer MAX cut scene editor. (right click -> open interface -> scene cut editor)
  Once you create a cut, ZoomPlayer will create a file like this:
  [windows 7]: c:\\Users\\All Users\\Zoom Player\\DVD-Bookmarks\\Sintel_NTSC.3D4D1DFBEB1A53FE\\disc.cut
  
  After it has been created, come back to this.  You will next be prompted to select the generated disc.cut file, and also a sensible cinema EDL file.
  The generated file will then be overwritten with the sensible cinema EDL information.
  DVD compatible only currently--ask if you want it for file based selection as well and I can add it.
      EOL
      zoom_path  = new_existing_file_selector_and_select_file( "Pick Zoomplayer disc.cut File to override", ENV["ALLUSERSPROFILE"]+ '/Zoom Player/DVD-Bookmarks' )
      edl_path = new_existing_file_selector_and_select_file( "Pick EDL", EdlParser::EDL_DIR)
      specs = parse_edl(edl_path)
      require_relative '../zoom_player_max_edl'
      out = ZoomPlayerMaxEdl.convert_to_edl_string specs
      File.write(zoom_path, out)
      show_blocking_message_dialog "wrote #{zoom_path}"
    end
  end
end

#show_select_buttons_prompt(message, names = {}) ⇒ `Object`



586
587
588

# File 'lib/gui/base.rb', line 586

def show_select_buttons_prompt message, names ={}
  SwingHelpers.show_select_buttons_prompt(message, names)
end

#system_blocking(command) ⇒ `Object`

# File 'lib/gui/base.rb', line 365

def system_blocking command
  return true if command =~ /^@rem/ # JRUBY-5890 bug
  raise command + " failed env #{ENV['PATH']}" unless system_original command
end

#system_non_blocking(command) ⇒ `Object`



370
371
372

# File 'lib/gui/base.rb', line 370

def system_non_blocking command
  @background_thread = Thread.new { system_original command }
end

#upconvert_set_to_anything? ⇒ `Boolean`

Returns:

(Boolean)



46
47
48

# File 'lib/gui/upconvert.rb', line 46

def upconvert_set_to_anything?
  LocalStorage[UpConvertEnglish].present?
end

#update_currently_inserted_dvd_list ⇒ `Object`

# File 'lib/gui/base.rb', line 130

def update_currently_inserted_dvd_list
 present_discs = []
  DriveInfo.get_dvd_drives_as_openstruct.each{|disk|
    if disk.VolumeName
       dvd_id = DriveInfo.md5sum_disk(disk.MountPoint)			     
       edit_list_path_if_present = EdlParser.single_edit_list_matches_dvd(dvd_id, true)
    if edit_list_path_if_present
         human_name = parse_edl(edit_list_path_if_present)['name']
      human_name ||= ''
       end
       present_discs << [human_name, disk.VolumeName, edit_list_path_if_present]
    end
  }
  found_one = false
  present_discs.map!{|human_name, volume_name, has_edl| 
    if human_name
      found_one = true
      "DVD: #{human_name} has an Edit List available! (#{volume_name})"
    else
      "DVD: (#{volume_name}) has NO Edit List available!"
    end
  }
  if present_discs.length > 0
    @current_dvds_line1.text= '      ' + present_discs[0]
    @current_dvds_line2.text= '      ' + present_discs[1..2].join(" ")
  else
    @current_dvds_line1.text= '      No DVD discs currently inserted.'
    @current_dvds_line2.text = ''
  end
  @callbacks_for_dvd_edl_present.each{|c| c.call(present_discs.length > 0, found_one)}
end

#warn_if_no_upconvert_options_currently_selected ⇒ `Object`

# File 'lib/gui/upconvert.rb', line 61

def warn_if_no_upconvert_options_currently_selected
  if !upconvert_set_to_anything?
    show_non_blocking_message_dialog "Warning: upconvert options have not been set yet--set upconvert options first, if desired."
  else
    JFrame.new # something it can call dispose on :P
  end
end

#watch_dvd_edited_realtime_mplayer(show_subs) ⇒ `Object`

# File 'lib/gui/create.rb', line 372

def watch_dvd_edited_realtime_mplayer show_subs
  edl_out_command = ""
  if LocalStorage['prompt_obscure_options']
    answer = show_select_buttons_prompt <<-EOL, {}
      Would you like to create an .edl outfile as it plays (hit button to capture timestamps)?
      EOL
    if answer == :yes
      show_non_blocking_message_dialog <<-EOL
      EDL outfile:
      As mplayer goes through the video, when you see a scene you want to edit or skip, 
      hit 'i' and mplayer will write the start time in the file and set it to skip for 2 seconds, 
      hit 'i' again to end the edited/skipped scene, within that file.
      EOL
  
      edlout_filename = new_nonexisting_filechooser_and_go "pick edlout filename"
      edl_out_command = "-edlout #{edlout_filename}"
      
    else
      @has_ever_rejected_edl_outfile = true
    end
  end
  thred = play_smplayer_edl_non_blocking nil, [edl_out_command], true, false, add_end = 0.0, add_begin = 0.0, show_subs # more aggressive :)
  if(edl_out_command.present?)
    open_edl_file_when_done thred, edlout_filename
  end
end

#we_are_in_create_mode ⇒ `Object`



177
178
179

# File 'lib/gui/base.rb', line 177

def we_are_in_create_mode
 @args.index("--create-mode")
end

#we_are_in_developer_mode? ⇒ `Boolean`

Returns:

(Boolean)



181
182
183

# File 'lib/gui/base.rb', line 181

def we_are_in_developer_mode?
  @args.detect{|a| a == '--developer-mode'}
end

#we_are_in_upconvert_mode ⇒ `Object`



676
677
678

# File 'lib/gui/base.rb', line 676

def we_are_in_upconvert_mode
  @args.index("--upconvert-mode")
end

#when_thread_done(thread) ⇒ `Object`



215
216
217

# File 'lib/gui/base.rb', line 215

def when_thread_done(thread)
  Thread.new {thread.join; yield }
end

#with_autoclose_message(message) ⇒ `Object`

# File 'lib/gui/base.rb', line 670

def with_autoclose_message(message)
  a = show_non_blocking_message_dialog message
  yield
  a.close
end

#write_subs_to_file(out_file, euphemized_synchronized_entries) ⇒ `Object`

# File 'lib/gui/create.rb', line 222

def write_subs_to_file out_file, euphemized_synchronized_entries
     File.open(out_file, 'w') do |f|
       euphemized_synchronized_entries.each_with_index{|entry, idx|
         beginning_time = EdlParser.translate_time_to_human_readable(entry.beginning_time).gsub('.',',')
         ending_time = EdlParser.translate_time_to_human_readable(entry.ending_time).gsub('.',',')
         f.puts entry.index_number
         f.puts "#{beginning_time} --> #{ending_time}"
         f.puts entry.text
         f.puts ''
       }
		  end
end

Class: SensibleSwing::MainWindow

Constant Summary collapse

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(start_visible = true, args = ARGV) ⇒ MainWindow

Instance Attribute Details

#background_thread ⇒ Object

#buttons ⇒ Object

#parent ⇒ Object

#upconv_line ⇒ Object

Class Method Details

.download(full_url, to_here) ⇒ Object

.download_to_string(full_url) ⇒ Object

Instance Method Details

#add_callback_for_dvd_edl_present(&block) ⇒ Object

#add_change_upconvert_buttons ⇒ Object

#add_change_upconvert_options_button ⇒ Object

#add_open_documentation_button ⇒ Object

#add_play_upconvert_buttons ⇒ Object

#add_text_line(line) ⇒ Object

#assert_confirmed_dialog(returned, license_url_should_also_be_embedded_by_you_in_message) ⇒ Object

#assert_ownership_dialog ⇒ Object

#begin_buffer_preference ⇒ Object

#calculate_dvd_start_offset(title, drive) ⇒ Object

#change_upconvert_line_to_current ⇒ Object

#check_for_exe(windows_full_loc, unix_name) ⇒ Object

#check_for_ffmpeg_installed ⇒ Object

#check_for_various_dependencies ⇒ Object

#choose_dvd_drive_or_file(force_choose_only_dvd_drive) ⇒ Object

#choose_dvd_or_file_and_edl_for_it(force_choose_edl_file_if_no_easy_match = true) ⇒ Object

#choose_file_and_edl_and_create_sxs_or_play(just_create_xbmc_dot_edl_file_instead_of_play) ⇒ Object

#create_brand_new_dvd_edl ⇒ Object

#create_new_for_file_or_netflix ⇒ Object

#display_and_raise(error_message) ⇒ Object

#display_current_upconvert_setting_and_close_window ⇒ Object

#download_7zip ⇒ Object

#download_zip_file_and_extract(english_name, url, to_this) ⇒ Object

#force_accept_file_style_license ⇒ Object

#force_accept_license_first ⇒ Object

#get_current_max_width_resolution ⇒ Object

#get_current_upconvert_as_phrase ⇒ Object

#get_disk_chooser_window(names) ⇒ Object

#get_disk_info ⇒ Object

#get_drive_with_most_space_with_slash ⇒ Object

#get_dvd_playback_options(descriptors) ⇒ Object

#get_freespace(path) ⇒ Object

#get_same_drive_friendly_clean_temp_dir(suffix) ⇒ Object

#get_set_preference(name, english_name) ⇒ Object

#get_srt_filename(descriptors, edl_filename) ⇒ Object

#get_start_stop_times_strings ⇒ Object

#get_temp_file_name(name_with_ext) ⇒ Object

#get_title_track_string(descriptors, use_default_of_one = true) ⇒ Object

#get_upconvert_secondary_settings ⇒ Object

#get_upconvert_vf_settings ⇒ Object

#get_user_input(message, default = '', cancel_ok = false) ⇒ Object

#get_user_input_with_persistence(message, storage_key) ⇒ Object

#hard_exit ⇒ Object

#increment_button_location(how_much = 30) ⇒ Object

#is_dvd?(drive_or_file) ⇒ Boolean

#new_child_window ⇒ Object

#new_existing_file_selector_and_select_file(title, dir = nil) ⇒ Object

#new_jbutton(title, tooltip = nil) ⇒ Object

#new_nonexisting_filechooser_and_go(title = nil, default_dir = nil, default_file = nil) ⇒ Object

#normalize_path(path) ⇒ Object

#open_edl_file_when_done(thred, filename) ⇒ Object

#open_file_to_edit_it(filename, options = {}) ⇒ Object

#parse_edl(path) ⇒ Object

#play_dvd_smplayer_unedited(use_mplayer_instead) ⇒ Object

#play_smplayer_edl_non_blocking(optional_file_with_edl_path = nil, extra_mplayer_commands_array = [], force_mplayer = false, start_full_screen = true, add_secs_end = 0, add_secs_begin = begin_buffer_preference, show_subs = false) ⇒ Object

#print(*args) ⇒ Object

#require_blocking_license_accept_dialog(program, license_name, license_url_should_also_be_embedded_by_you_in_message, title = 'Confirm Acceptance of License Agreement', message = nil) ⇒ Object

#reset_upconversion_options ⇒ Object

#run_smplayer_blocking(play_this, title_track_maybe_nil, passed_in_extra_options, force_use_mplayer, show_subs, start_full_screen, srt_filename) ⇒ Object

#run_smplayer_non_blocking(*args) ⇒ Object

#sanity_check_file(filename) ⇒ Object

#set_individual_preferences ⇒ Object

#set_smplayer_opts(to_this, video_settings, show_subs = false) ⇒ Object

#setup_create_buttons ⇒ Object

#initialize(start_visible = true, args = ARGV) ⇒ `MainWindow`

#background_thread ⇒ `Object`

#buttons ⇒ `Object`

#parent ⇒ `Object`

#upconv_line ⇒ `Object`

.download(full_url, to_here) ⇒ `Object`

.download_to_string(full_url) ⇒ `Object`

#add_callback_for_dvd_edl_present(&block) ⇒ `Object`

#add_change_upconvert_buttons ⇒ `Object`

#add_change_upconvert_options_button ⇒ `Object`

#add_open_documentation_button ⇒ `Object`

#add_play_upconvert_buttons ⇒ `Object`

#add_text_line(line) ⇒ `Object`

#assert_confirmed_dialog(returned, license_url_should_also_be_embedded_by_you_in_message) ⇒ `Object`

#assert_ownership_dialog ⇒ `Object`

#begin_buffer_preference ⇒ `Object`

#calculate_dvd_start_offset(title, drive) ⇒ `Object`

#change_upconvert_line_to_current ⇒ `Object`

#check_for_exe(windows_full_loc, unix_name) ⇒ `Object`

#check_for_ffmpeg_installed ⇒ `Object`

#check_for_various_dependencies ⇒ `Object`

#choose_dvd_drive_or_file(force_choose_only_dvd_drive) ⇒ `Object`

#choose_dvd_or_file_and_edl_for_it(force_choose_edl_file_if_no_easy_match = true) ⇒ `Object`

#choose_file_and_edl_and_create_sxs_or_play(just_create_xbmc_dot_edl_file_instead_of_play) ⇒ `Object`

#create_brand_new_dvd_edl ⇒ `Object`

#create_new_for_file_or_netflix ⇒ `Object`

#display_and_raise(error_message) ⇒ `Object`

#display_current_upconvert_setting_and_close_window ⇒ `Object`

#download_7zip ⇒ `Object`

#download_zip_file_and_extract(english_name, url, to_this) ⇒ `Object`

#force_accept_file_style_license ⇒ `Object`

#force_accept_license_first ⇒ `Object`

#get_current_max_width_resolution ⇒ `Object`

#get_current_upconvert_as_phrase ⇒ `Object`

#get_disk_chooser_window(names) ⇒ `Object`

#get_disk_info ⇒ `Object`

#get_drive_with_most_space_with_slash ⇒ `Object`

#get_dvd_playback_options(descriptors) ⇒ `Object`

#get_freespace(path) ⇒ `Object`

#get_same_drive_friendly_clean_temp_dir(suffix) ⇒ `Object`

#get_set_preference(name, english_name) ⇒ `Object`

#get_srt_filename(descriptors, edl_filename) ⇒ `Object`

#get_start_stop_times_strings ⇒ `Object`

#get_temp_file_name(name_with_ext) ⇒ `Object`

#get_title_track_string(descriptors, use_default_of_one = true) ⇒ `Object`

#get_upconvert_secondary_settings ⇒ `Object`

#get_upconvert_vf_settings ⇒ `Object`

#get_user_input(message, default = '', cancel_ok = false) ⇒ `Object`

#get_user_input_with_persistence(message, storage_key) ⇒ `Object`

#hard_exit ⇒ `Object`

#increment_button_location(how_much = 30) ⇒ `Object`

#is_dvd?(drive_or_file) ⇒ `Boolean`

#new_child_window ⇒ `Object`

#new_existing_file_selector_and_select_file(title, dir = nil) ⇒ `Object`

#new_jbutton(title, tooltip = nil) ⇒ `Object`

#new_nonexisting_filechooser_and_go(title = nil, default_dir = nil, default_file = nil) ⇒ `Object`

#normalize_path(path) ⇒ `Object`

#open_edl_file_when_done(thred, filename) ⇒ `Object`

#open_file_to_edit_it(filename, options = {}) ⇒ `Object`

#parse_edl(path) ⇒ `Object`

#play_dvd_smplayer_unedited(use_mplayer_instead) ⇒ `Object`

#play_smplayer_edl_non_blocking(optional_file_with_edl_path = nil, extra_mplayer_commands_array = [], force_mplayer = false, start_full_screen = true, add_secs_end = 0, add_secs_begin = begin_buffer_preference, show_subs = false) ⇒ `Object`

#print(*args) ⇒ `Object`

#require_blocking_license_accept_dialog(program, license_name, license_url_should_also_be_embedded_by_you_in_message, title = 'Confirm Acceptance of License Agreement', message = nil) ⇒ `Object`

#reset_upconversion_options ⇒ `Object`

#run_smplayer_blocking(play_this, title_track_maybe_nil, passed_in_extra_options, force_use_mplayer, show_subs, start_full_screen, srt_filename) ⇒ `Object`

#run_smplayer_non_blocking(*args) ⇒ `Object`

#sanity_check_file(filename) ⇒ `Object`

#set_individual_preferences ⇒ `Object`

#set_smplayer_opts(to_this, video_settings, show_subs = false) ⇒ `Object`

#setup_create_buttons ⇒ `Object`

#setup_default_buttons ⇒ `Object`

#setup_dvd_upconvert_options ⇒ `Object`

#setup_normal_buttons ⇒ `Object`

#show_blocking_message_dialog(message, title = , style = JOptionPane::INFORMATION_MESSAGE) ⇒ `Object`

#show_copy_pastable_string(message, value) ⇒ `Object`

#show_in_explorer(filename) ⇒ `Object`

#show_mplayer_instructions ⇒ `Object`

#show_non_blocking_message_dialog(message, close_button_text = 'Close') ⇒ `Object`

#show_rarely_used_buttons ⇒ `Object`