Fix scrubbing bug: don't skip to 0s after drag

Fix play/pause toggle bug
Sometimes, while casting, WT thinks the video isn't visible and the play/pause toggle stops working
2016-07-21 01:09:43 -07:00 · 2016-07-21 01:03:45 -07:00 · 2016-07-21 00:17:00 -07:00 · 2016-07-20 23:47:32 -07:00 · 2016-07-20 23:18:23 -07:00 · 2016-07-17 17:34:58 -07:00
42 changed files with 2074 additions and 1354 deletions
--- a/AUTHORS.md
+++ b/AUTHORS.md
@@ -22,5 +22,9 @@
 - Mathias Rasmussen <mathiasvr@gmail.com>
 - Sergey Bargamon <sergey@bargamon.ru>
 - Thomas Watson Steen <w@tson.dk>
+- anonymlol <anonymlol7@gmail.com>
+- Gediminas Petrikas <gedas18@gmail.com>
+- Adam Gotlib <gotlib.adam+dev@gmail.com>
+- Rémi Jouannet <remijouannet@gmail.com>

 #### Generated by bin/update-authors.sh.
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,11 +1,62 @@
 # WebTorrent Desktop Version History

+## v0.9.0 - 2016-07-20
+
+### Added
+- Save selected subtitles
+- Ask for confirmation before deleting torrents
+- Support Debian Jessie
+
+### Changed
+- Only send telemetry in production
+- Clean up the code. Split main.js, refactor lots of things
+
+### Fixed
+- Fix state.playing.jumpToTime behavior
+- Remove torrent file and poster image when deleting a torrent
+
+## v0.8.1 - 2016-06-24
+
+### Added
+
+- New URI handler: stream-magnet
+
+### Fixed
+
+- DLNA crashing bug
+
+## v0.8.0 - 2016-06-23
+
+### Added
+
+- Cast menu: choose which Chromecast, Airplay, or DLNA device you want to use
+- Telemetry: send basic data, plus stats on how often the play button works
+- Make posters from jpeg files, not just jpg
+- Support .wmv video via Play in VLC
+- Windows thumbnail bar with a play/pause button
+
+### Changed
+
+- Nicer modal styles
+
+### Fixed
+
+- Windows tray icon now stays in the right state
+
+## v0.7.2 - 2016-06-02
+
+### Fixed
+
+- Fix exception that affects users upgrading from v0.5.1 or older
+  - Ensure `state.saved.prefs` configuration exists
+- Fix window title on "About WebTorrent" window
+
 ## v0.7.1 - 2016-06-02

 ### Changed

- Change "Step Forward" keyboard shortcut to `Alt+Left`
- Change "Step Backward" keyboard shortcut to to `Alt+Right`
+- Change "Step Forward" keyboard shortcut to `Alt+Left` (Windows)
+- Change "Step Backward" keyboard shortcut to to `Alt+Right` (Windows)

 ### Fixed

--- a/README.md
+++ b/README.md
@@ -81,6 +81,12 @@ brew install wine

 (Requires the [Homebrew](http://brew.sh/) package manager.)

+### Privacy
+
+WebTorrent Desktop collects some basic usage stats to help us make the app better. For example, we track how well the play button works. How often does it succeed? Time out? Show a missing codec error?
+
+The app never sends personally identifying information, nor does it track which swarms you join.
+
 ### Code Style

 [![js-standard-style](https://cdn.rawgit.com/feross/standard/master/badge.svg)](https://github.com/feross/standard)
--- a/bin/check-deps.js
+++ b/bin/check-deps.js
@@ -3,7 +3,48 @@
 var fs = require('fs')
 var cp = require('child_process')

-var BUILT_IN_DEPS = ['child_process', 'electron', 'fs', 'os', 'path']
+// We can't use `builtin-modules` here since our TravisCI
+// setup expects this file to run with no dependencies
+var BUILT_IN_NODE_MODULES = [
+  'assert',
+  'buffer',
+  'child_process',
+  'cluster',
+  'console',
+  'constants',
+  'crypto',
+  'dgram',
+  'dns',
+  'domain',
+  'events',
+  'fs',
+  'http',
+  'https',
+  'module',
+  'net',
+  'os',
+  'path',
+  'process',
+  'punycode',
+  'querystring',
+  'readline',
+  'repl',
+  'stream',
+  'string_decoder',
+  'timers',
+  'tls',
+  'tty',
+  'url',
+  'util',
+  'v8',
+  'vm',
+  'zlib'
+]
+
+var BUILT_IN_ELECTRON_MODULES = [ 'electron' ]
+
+var BUILT_IN_DEPS = [].concat(BUILT_IN_NODE_MODULES, BUILT_IN_ELECTRON_MODULES)
+
 var EXECUTABLE_DEPS = ['gh-release', 'standard']

 main()
@@ -19,10 +60,10 @@ function main () {
  var packageDeps = findPackageDeps()

  var missingDeps = usedDeps.filter(
-    (dep) => !packageDeps.includes(dep) && !BUILT_IN_DEPS.includes(dep)
+    (dep) => !includes(packageDeps, dep) && !includes(BUILT_IN_DEPS, dep)
  )
  var unusedDeps = packageDeps.filter(
-    (dep) => !usedDeps.includes(dep) && !EXECUTABLE_DEPS.includes(dep)
+    (dep) => !includes(usedDeps, dep) && !includes(EXECUTABLE_DEPS, dep)
  )

  if (missingDeps.length > 0) {
@@ -52,3 +93,7 @@ function findUsedDeps () {
  var stdout = cp.execSync('./bin/list-deps.sh')
  return stdout.toString().trim().split('\n')
 }
+
+function includes (arr, elem) {
+  return arr.indexOf(elem) >= 0
+}
--- a/bin/package.js
+++ b/bin/package.js
@@ -206,6 +206,12 @@ function buildDarwin (cb) {
        CFBundleURLIconFile: path.basename(config.APP_FILE_ICON) + '.icns',
        CFBundleURLName: 'BitTorrent Magnet URL',
        CFBundleURLSchemes: [ 'magnet' ]
+      },
+      {
+        CFBundleTypeRole: 'Editor',
+        CFBundleURLIconFile: path.basename(config.APP_FILE_ICON) + '.icns',
+        CFBundleURLName: 'BitTorrent Stream-Magnet URL',
+        CFBundleURLSchemes: [ 'stream-magnet' ]
      }
    ]

@@ -460,7 +466,7 @@ function buildLinux (cb) {
      info: {
        arch: destArch === 'x64' ? 'amd64' : 'i386',
        targetDir: DIST_PATH,
-        depends: 'libc6 (>= 2.4)',
+        depends: 'gconf2, libgtk2.0-0, libnss3, libxss1',
        scripts: {
          postinst: path.join(config.STATIC_PATH, 'linux', 'postinst'),
          prerm: path.join(config.STATIC_PATH, 'linux', 'prerm')
--- a/config.js
+++ b/config.js
@@ -10,6 +10,9 @@ var PORTABLE_PATH = path.join(path.dirname(process.execPath), 'Portable Settings

 module.exports = {
  ANNOUNCEMENT_URL: 'https://webtorrent.io/desktop/announcement',
+  AUTO_UPDATE_URL: 'https://webtorrent.io/desktop/update',
+  CRASH_REPORT_URL: 'https://webtorrent.io/desktop/crash-report',
+  TELEMETRY_URL: 'https://webtorrent.io/desktop/telemetry',

  APP_COPYRIGHT: 'Copyright © 2014-2016 ' + APP_TEAM,
  APP_FILE_ICON: path.join(__dirname, 'static', 'WebTorrentFile'),
@@ -19,10 +22,6 @@ module.exports = {
  APP_VERSION: APP_VERSION,
  APP_WINDOW_TITLE: APP_NAME + ' (BETA)',

-  AUTO_UPDATE_URL: 'https://webtorrent.io/desktop/update',
-
-  CRASH_REPORT_URL: 'https://webtorrent.io/desktop/crash-report',
-
  CONFIG_PATH: getConfigPath(),

  DEFAULT_TORRENTS: [
--- a/main/handlers.js
+++ b/main/handlers.js
@@ -37,6 +37,7 @@ function installDarwin () {
  // On OS X, only protocols that are listed in `Info.plist` can be set as the
  // default handler at runtime.
  app.setAsDefaultProtocolClient('magnet')
+  app.setAsDefaultProtocolClient('stream-magnet')

  // File handlers are defined in `Info.plist`.
 }
@@ -63,6 +64,12 @@ function installWin32 () {
    iconPath,
    EXEC_COMMAND
  )
+  registerProtocolHandlerWin32(
+    'stream-magnet',
+    'URL:BitTorrent Stream-Magnet URL',
+    iconPath,
+    EXEC_COMMAND
+  )
  registerFileHandlerWin32(
    '.torrent',
    'io.webtorrent.torrent',
@@ -201,6 +208,7 @@ function uninstallWin32 () {
  var Registry = require('winreg')

  unregisterProtocolHandlerWin32('magnet', EXEC_COMMAND)
+  unregisterProtocolHandlerWin32('stream-magnet', EXEC_COMMAND)
  unregisterFileHandlerWin32('.torrent', 'io.webtorrent.torrent', EXEC_COMMAND)

  function unregisterProtocolHandlerWin32 (protocol, command) {
--- a/main/index.js
+++ b/main/index.js
@@ -68,6 +68,13 @@ function init () {

    // To keep app startup fast, some code is delayed.
    setTimeout(delayedInit, config.DELAYED_INIT)
+
+    // Report uncaught exceptions
+    process.on('uncaughtException', (err) => {
+      console.error(err)
+      var errJSON = {message: err.message, stack: err.stack}
+      windows.main.dispatch('uncaughtError', 'main', errJSON)
+    })
  })

  app.once('ipcReady', function () {
@@ -83,7 +90,10 @@ function init () {
    e.preventDefault()
    windows.main.dispatch('saveState') // try to save state on exit
    ipcMain.once('savedState', () => app.quit())
-    setTimeout(() => app.quit(), 2000) // quit after 2 secs, at most
+    setTimeout(() => {
+      console.error('Saving state took too long. Quitting.')
+      app.quit()
+    }, 2000) // quit after 2 secs, at most
  })

  app.on('activate', function () {
--- a/main/ipc.js
+++ b/main/ipc.js
@@ -15,6 +15,7 @@ var shell = require('./shell')
 var shortcuts = require('./shortcuts')
 var vlc = require('./vlc')
 var windows = require('./windows')
+var thumbar = require('./thumbar')

 // Messages from the main process, to be sent once the WebTorrent process starts
 var messageQueueMainToWebTorrent = []
@@ -60,20 +61,27 @@ function init () {

  ipc.on('onPlayerOpen', function () {
    menu.onPlayerOpen()
-    shortcuts.onPlayerOpen()
+    powerSaveBlocker.enable()
+    shortcuts.enable()
+    thumbar.enable()
  })

  ipc.on('onPlayerClose', function () {
    menu.onPlayerClose()
-    shortcuts.onPlayerOpen()
+    powerSaveBlocker.disable()
+    shortcuts.disable()
+    thumbar.disable()
  })

-  /**
-   * Power Save Blocker
-   */
+  ipc.on('onPlayerPlay', function () {
+    powerSaveBlocker.enable()
+    thumbar.onPlayerPlay()
+  })

-  ipc.on('blockPowerSave', () => powerSaveBlocker.start())
-  ipc.on('unblockPowerSave', () => powerSaveBlocker.stop())
+  ipc.on('onPlayerPause', function () {
+    powerSaveBlocker.disable()
+    thumbar.onPlayerPause()
+  })

  /**
   * Shell
@@ -81,6 +89,7 @@ function init () {

  ipc.on('openItem', (e, ...args) => shell.openItem(...args))
  ipc.on('showItemInFolder', (e, ...args) => shell.showItemInFolder(...args))
+  ipc.on('moveItemToTrash', (e, ...args) => shell.moveItemToTrash(...args))

  /**
   * Windows: Main
--- a/main/menu.js
+++ b/main/menu.js
@@ -220,7 +220,7 @@ function getMenuTemplate () {
          accelerator: process.platform === 'darwin'
            ? 'CmdOrCtrl+Alt+Right'
            : 'Alt+Right',
-          click: () => windows.main.dispatch('skip', 1),
+          click: () => windows.main.dispatch('skip', 10),
          enabled: false
        },
        {
@@ -228,7 +228,7 @@ function getMenuTemplate () {
          accelerator: process.platform === 'darwin'
            ? 'CmdOrCtrl+Alt+Left'
            : 'Alt+Left',
-          click: () => windows.main.dispatch('skip', -1),
+          click: () => windows.main.dispatch('skip', -10),
          enabled: false
        },
        {
--- a/main/power-save-blocker.js
+++ b/main/power-save-blocker.js
@@ -1,6 +1,6 @@
 module.exports = {
-  start,
-  stop
+  enable,
+  disable
 }

 var electron = require('electron')
@@ -12,19 +12,19 @@ var blockId = 0
 * Block the system from entering low-power (sleep) mode or turning off the
 * display.
 */
-function start () {
-  stop() // Stop the previous power saver block, if one exists.
+function enable () {
+  disable() // Stop the previous power saver block, if one exists.
  blockId = electron.powerSaveBlocker.start('prevent-display-sleep')
-  log(`powerSaveBlocker.start: ${blockId}`)
+  log(`powerSaveBlocker.enable: ${blockId}`)
 }

 /**
 * Stop blocking the system from entering low-power mode.
 */
-function stop () {
+function disable () {
  if (!electron.powerSaveBlocker.isStarted(blockId)) {
    return
  }
  electron.powerSaveBlocker.stop(blockId)
-  log(`powerSaveBlocker.stop: ${blockId}`)
+  log(`powerSaveBlocker.disable: ${blockId}`)
 }
--- a/main/shell.js
+++ b/main/shell.js
@@ -1,7 +1,8 @@
 module.exports = {
  openExternal,
  openItem,
-  showItemInFolder
+  showItemInFolder,
+  moveItemToTrash
 }

 var electron = require('electron')
@@ -30,3 +31,11 @@ function showItemInFolder (path) {
  log(`showItemInFolder: ${path}`)
  electron.shell.showItemInFolder(path)
 }
+
+/**
+ * Move the given file to trash and returns a boolean status for the operation.
+ */
+function moveItemToTrash (path) {
+  log(`moveItemToTrash: ${path}`)
+  electron.shell.moveItemToTrash(path)
+}
--- a/main/shortcuts.js
+++ b/main/shortcuts.js
@@ -1,12 +1,12 @@
 module.exports = {
-  onPlayerClose,
-  onPlayerOpen
+  disable,
+  enable
 }

 var electron = require('electron')
 var windows = require('./windows')

-function onPlayerOpen () {
+function enable () {
  // Register play/pause media key, available on some keyboards.
  electron.globalShortcut.register(
    'MediaPlayPause',
@@ -14,7 +14,7 @@ function onPlayerOpen () {
  )
 }

-function onPlayerClose () {
+function disable () {
  // Return the media key to the OS, so other apps can use it.
  electron.globalShortcut.unregister('MediaPlayPause')
 }
--- a/main/thumbar.js
+++ b/main/thumbar.js
@@ -0,0 +1,54 @@
+module.exports = {
+  disable,
+  enable,
+  onPlayerPause,
+  onPlayerPlay
+}
+
+/**
+ * On Windows, add a "thumbnail toolbar" with a play/pause button in the taskbar.
+ * This provides users a way to access play/pause functionality without restoring
+ * or activating the window.
+ */
+
+var path = require('path')
+var config = require('../config')
+
+var windows = require('./windows')
+
+/**
+ * Show the Windows thumbnail toolbar buttons.
+ */
+function enable () {
+  update(false)
+}
+
+/**
+ * Hide the Windows thumbnail toolbar buttons.
+ */
+function disable () {
+  windows.main.win.setThumbarButtons([])
+}
+
+function onPlayerPause () {
+  update(true)
+}
+
+function onPlayerPlay () {
+  update(false)
+}
+
+function update (isPaused) {
+  var icon = isPaused
+    ? 'PlayThumbnailBarButton.png'
+    : 'PauseThumbnailBarButton.png'
+
+  var buttons = [
+    {
+      tooltip: isPaused ? 'Play' : 'Pause',
+      icon: path.join(config.STATIC_PATH, icon),
+      click: () => windows.main.dispatch('playPause')
+    }
+  ]
+  windows.main.win.setThumbarButtons(buttons)
+}
--- a/main/windows/main.js
+++ b/main/windows/main.js
@@ -51,15 +51,11 @@ function init () {
    menu.onToggleFullScreen(main.win.isFullScreen())
  })

-  win.on('blur', function () {
-    menu.onWindowBlur()
-    tray.onWindowBlur()
-  })
+  win.on('blur', onWindowBlur)
+  win.on('focus', onWindowFocus)

-  win.on('focus', function () {
-    menu.onWindowFocus()
-    tray.onWindowFocus()
-  })
+  win.on('hide', onWindowBlur)
+  win.on('show', onWindowFocus)

  win.on('enter-full-screen', function () {
    menu.onToggleFullScreen(true)
@@ -78,7 +74,7 @@ function init () {
      app.quit()
    } else if (!app.isQuitting) {
      e.preventDefault()
-      win.hide()
+      hide()
    }
  })
 }
@@ -207,6 +203,16 @@ function toggleFullScreen (flag) {
  main.win.setFullScreen(flag)
 }

+function onWindowBlur () {
+  menu.onWindowBlur()
+  tray.onWindowBlur()
+}
+
+function onWindowFocus () {
+  menu.onWindowFocus()
+  tray.onWindowFocus()
+}
+
 function getIconPath () {
  return process.platform === 'win32'
    ? config.APP_ICON + '.ico'
--- a/package.json
+++ b/package.json
@@ -1,10 +1,10 @@
 {
  "name": "webtorrent-desktop",
  "description": "WebTorrent, the streaming torrent client. For OS X, Windows, and Linux.",
-  "version": "0.7.2",
+  "version": "0.9.0",
  "author": {
    "name": "WebTorrent, LLC",
-    "email": "feross@feross.org",
+    "email": "feross@webtorrent.io",
    "url": "https://webtorrent.io"
  },
  "bin": {
--- a/renderer/controllers/media-controller.js
+++ b/renderer/controllers/media-controller.js
@@ -0,0 +1,56 @@
+const electron = require('electron')
+
+const ipcRenderer = electron.ipcRenderer
+
+// Controls local play back: the <video>/<audio> tag and VLC
+// Does not control remote casting (Chromecast etc)
+module.exports = class MediaController {
+  constructor (state) {
+    this.state = state
+  }
+
+  mediaSuccess () {
+    this.state.playing.result = 'success'
+  }
+
+  mediaStalled () {
+    this.state.playing.isStalled = true
+  }
+
+  mediaError (error) {
+    var state = this.state
+    if (state.location.url() === 'player') {
+      state.playing.result = 'error'
+      state.playing.location = 'error'
+      ipcRenderer.send('checkForVLC')
+      ipcRenderer.once('checkForVLC', function (e, isInstalled) {
+        state.modal = {
+          id: 'unsupported-media-modal',
+          error: error,
+          vlcInstalled: isInstalled
+        }
+      })
+    }
+  }
+
+  mediaTimeUpdate () {
+    this.state.playing.lastTimeUpdate = new Date().getTime()
+    this.state.playing.isStalled = false
+  }
+
+  mediaMouseMoved () {
+    this.state.playing.mouseStationarySince = new Date().getTime()
+  }
+
+  vlcPlay () {
+    ipcRenderer.send('vlcPlay', this.state.server.localURL)
+    this.state.playing.location = 'vlc'
+  }
+
+  vlcNotFound () {
+    var modal = this.state.modal
+    if (modal && modal.id === 'unsupported-media-modal') {
+      modal.vlcNotFound = true
+    }
+  }
+}
--- a/renderer/controllers/playback-controller.js
+++ b/renderer/controllers/playback-controller.js
@@ -0,0 +1,309 @@
+const electron = require('electron')
+const path = require('path')
+
+const Cast = require('../lib/cast')
+const {dispatch} = require('../lib/dispatcher')
+const telemetry = require('../lib/telemetry')
+const errors = require('../lib/errors')
+const sound = require('../lib/sound')
+const TorrentPlayer = require('../lib/torrent-player')
+const TorrentSummary = require('../lib/torrent-summary')
+const State = require('../lib/state')
+
+const ipcRenderer = electron.ipcRenderer
+
+// Controls playback of torrents and files within torrents
+// both local (<video>,<audio>,VLC) and remote (cast)
+module.exports = class PlaybackController {
+  constructor (state, config, update) {
+    this.state = state
+    this.config = config
+    this.update = update
+  }
+
+  // Play a file in a torrent.
+  // * Start torrenting, if necessary
+  // * Stream, if not already fully downloaded
+  // * If no file index is provided, pick the default file to play
+  playFile (infoHash, index /* optional */) {
+    this.state.location.go({
+      url: 'player',
+      onbeforeload: (cb) => {
+        this.play()
+        openPlayer(this.state, infoHash, index, cb)
+      },
+      onbeforeunload: (cb) => closePlayer(this.state, this.config, cb)
+    }, (err) => {
+      if (err) dispatch('error', err)
+    })
+  }
+
+  // Show a file in the OS, eg in Finder on a Mac
+  openItem (infoHash, index) {
+    var torrentSummary = TorrentSummary.getByKey(this.state, infoHash)
+    var filePath = path.join(
+      torrentSummary.path,
+      torrentSummary.files[index].path)
+    ipcRenderer.send('openItem', filePath)
+  }
+
+  // Toggle (play or pause) the currently playing media
+  playPause () {
+    var state = this.state
+    if (state.location.url() !== 'player') return
+
+    // force rerendering if window is hidden,
+    // in order to bypass `raf` and play/pause media immediately
+    var mediaTag = document.querySelector('video,audio')
+    if (!state.window.isVisible && mediaTag) {
+      if (state.playing.isPaused) mediaTag.play()
+      else mediaTag.pause()
+    }
+
+    if (state.playing.isPaused) this.play()
+    else this.pause()
+  }
+
+  // Play (unpause) the current media
+  play () {
+    var state = this.state
+    if (!state.playing.isPaused) return
+    state.playing.isPaused = false
+    if (isCasting(state)) {
+      Cast.play()
+    }
+    ipcRenderer.send('onPlayerPlay')
+  }
+
+  // Pause the currently playing media
+  pause () {
+    var state = this.state
+    if (state.playing.isPaused) return
+    state.playing.isPaused = true
+    if (isCasting(state)) {
+      Cast.pause()
+    }
+    ipcRenderer.send('onPlayerPause')
+  }
+
+  // Skip specified number of seconds (backwards if negative)
+  skip (time) {
+    this.skipTo(this.state.playing.currentTime + time)
+  }
+
+  // Skip (aka seek) to a specific point, in seconds
+  skipTo (time) {
+    if (isCasting(this.state)) Cast.seek(time)
+    else this.state.playing.jumpToTime = time
+  }
+
+  // Change playback speed. 1 = faster, -1 = slower
+  // Playback speed ranges from 16 (fast forward) to 1 (normal playback)
+  // to 0.25 (quarter-speed playback), then goes to -0.25, -0.5, -1, -2, etc
+  // until -16 (fast rewind)
+  changePlaybackRate (direction) {
+    var state = this.state
+    var rate = state.playing.playbackRate
+    if (direction > 0 && rate >= 0.25 && rate < 2) {
+      rate += 0.25
+    } else if (direction < 0 && rate > 0.25 && rate <= 2) {
+      rate -= 0.25
+    } else if (direction < 0 && rate === 0.25) { /* when we set playback rate at 0 in html 5, playback hangs ;( */
+      rate = -1
+    } else if (direction > 0 && rate === -1) {
+      rate = 0.25
+    } else if ((direction > 0 && rate >= 1 && rate < 16) || (direction < 0 && rate > -16 && rate <= -1)) {
+      rate *= 2
+    } else if ((direction < 0 && rate > 1 && rate <= 16) || (direction > 0 && rate >= -16 && rate < -1)) {
+      rate /= 2
+    }
+    state.playing.playbackRate = rate
+    if (isCasting(state) && !Cast.setRate(rate)) {
+      state.playing.playbackRate = 1
+    }
+  }
+
+  // Change the volume, in range [0, 1], by some amount
+  // For example, volume muted (0), changeVolume (0.3) increases to 30% volume
+  changeVolume (delta) {
+    // change volume with delta value
+    this.setVolume(this.state.playing.volume + delta)
+  }
+
+  // Set the volume to some value in [0, 1]
+  setVolume (volume) {
+    // check if its in [0.0 - 1.0] range
+    volume = Math.max(0, Math.min(1, volume))
+
+    var state = this.state
+    if (isCasting(state)) {
+      Cast.setVolume(volume)
+    } else {
+      state.playing.setVolume = volume
+    }
+  }
+
+  // Hide player controls while playing video, if the mouse stays still for a while
+  // Never hide the controls when:
+  // * The mouse is over the controls or we're scrubbing (see CSS)
+  // * The video is paused
+  // * The video is playing remotely on Chromecast or Airplay
+  showOrHidePlayerControls () {
+    var state = this.state
+    var hideControls = state.location.url() === 'player' &&
+      state.playing.mouseStationarySince !== 0 &&
+      new Date().getTime() - state.playing.mouseStationarySince > 2000 &&
+      !state.playing.isPaused &&
+      state.playing.location === 'local'
+
+    if (hideControls !== state.playing.hideControls) {
+      state.playing.hideControls = hideControls
+      return true
+    }
+    return false
+  }
+}
+
+// Opens the video player to a specific torrent
+function openPlayer (state, infoHash, index, cb) {
+  var torrentSummary = TorrentSummary.getByKey(state, infoHash)
+
+  // automatically choose which file in the torrent to play, if necessary
+  if (index === undefined) index = torrentSummary.defaultPlayFileIndex
+  if (index === undefined) index = TorrentPlayer.pickFileToPlay(torrentSummary.files)
+  if (index === undefined) return cb(new errors.UnplayableError())
+
+  // update UI to show pending playback
+  if (torrentSummary.progress !== 1) sound.play('PLAY')
+  // TODO: remove torrentSummary.playStatus
+  torrentSummary.playStatus = 'requested'
+  this.update()
+
+  var timeout = setTimeout(() => {
+    telemetry.logPlayAttempt('timeout')
+    // TODO: remove torrentSummary.playStatus
+    torrentSummary.playStatus = 'timeout' /* no seeders available? */
+    sound.play('ERROR')
+    cb(new Error('Playback timed out. Try again.'))
+    this.update()
+  }, 10000) /* give it a few seconds */
+
+  if (torrentSummary.status === 'paused') {
+    dispatch('startTorrentingSummary', torrentSummary)
+    ipcRenderer.once('wt-ready-' + torrentSummary.infoHash,
+      () => openPlayerFromActiveTorrent(state, torrentSummary, index, timeout, cb))
+  } else {
+    openPlayerFromActiveTorrent(state, torrentSummary, index, timeout, cb)
+  }
+}
+
+function openPlayerFromActiveTorrent (state, torrentSummary, index, timeout, cb) {
+  var fileSummary = torrentSummary.files[index]
+
+  // update state
+  state.playing.infoHash = torrentSummary.infoHash
+  state.playing.fileIndex = index
+  state.playing.type = TorrentPlayer.isVideo(fileSummary) ? 'video'
+    : TorrentPlayer.isAudio(fileSummary) ? 'audio'
+    : 'other'
+
+  // pick up where we left off
+  if (fileSummary.currentTime) {
+    var fraction = fileSummary.currentTime / fileSummary.duration
+    var secondsLeft = fileSummary.duration - fileSummary.currentTime
+    if (fraction < 0.9 && secondsLeft > 10) {
+      state.playing.jumpToTime = fileSummary.currentTime
+    }
+  }
+
+  // if it's audio, parse out the metadata (artist, title, etc)
+  if (state.playing.type === 'audio' && !fileSummary.audioInfo) {
+    ipcRenderer.send('wt-get-audio-metadata', torrentSummary.infoHash, index)
+  }
+
+  // if it's video, check for subtitles files that are done downloading
+  dispatch('checkForSubtitles')
+
+  // enable previously selected subtitle track
+  if (fileSummary.selectedSubtitle) {
+    dispatch('addSubtitles', [fileSummary.selectedSubtitle], true)
+  }
+
+  ipcRenderer.send('wt-start-server', torrentSummary.infoHash, index)
+  ipcRenderer.once('wt-server-' + torrentSummary.infoHash, (e, info) => {
+    clearTimeout(timeout)
+
+    // if we timed out (user clicked play a long time ago), don't autoplay
+    var timedOut = torrentSummary.playStatus === 'timeout'
+    delete torrentSummary.playStatus
+    if (timedOut) {
+      ipcRenderer.send('wt-stop-server')
+      return this.update()
+    }
+
+    // otherwise, play the video
+    state.window.title = torrentSummary.files[state.playing.fileIndex].name
+    this.update()
+
+    ipcRenderer.send('onPlayerOpen')
+
+    cb()
+  })
+}
+
+function closePlayer (state, config, cb) {
+  console.log('closePlayer')
+
+  // Quit any external players, like Chromecast/Airplay/etc or VLC
+  if (isCasting(state)) {
+    Cast.stop()
+  }
+  if (state.playing.location === 'vlc') {
+    ipcRenderer.send('vlcQuit')
+  }
+
+  // Save volume (this session only, not in state.saved)
+  state.previousVolume = state.playing.volume
+
+  // Telemetry: track what happens after the user clicks play
+  var result = state.playing.result // 'success' or 'error'
+  if (result === 'success') telemetry.logPlayAttempt('success') // first frame displayed
+  else if (result === 'error') telemetry.logPlayAttempt('error') // codec missing, etc
+  else if (result === undefined) telemetry.logPlayAttempt('abandoned') // user exited before first frame
+  else console.error('Unknown state.playing.result', state.playing.result)
+
+  // Reset the window contents back to the home screen
+  state.window.title = config.APP_WINDOW_TITLE
+  state.playing = State.getDefaultPlayState()
+  state.server = null
+
+  // Reset the window size and location back to where it was
+  if (state.window.isFullScreen) {
+    dispatch('toggleFullScreen', false)
+  }
+  restoreBounds(state)
+
+  // Tell the WebTorrent process to kill the torrent-to-HTTP server
+  ipcRenderer.send('wt-stop-server')
+
+  ipcRenderer.send('onPlayerClose')
+
+  this.update()
+  cb()
+}
+
+// Checks whether we are connected and already casting
+// Returns false if we not casting (state.playing.location === 'local')
+// or if we're trying to connect but haven't yet ('chromecast-pending', etc)
+function isCasting (state) {
+  return state.playing.location === 'chromecast' ||
+    state.playing.location === 'airplay' ||
+    state.playing.location === 'dlna'
+}
+
+function restoreBounds (state) {
+  ipcRenderer.send('setAspectRatio', 0)
+  if (state.window.bounds) {
+    ipcRenderer.send('setBounds', state.window.bounds, false)
+  }
+}
--- a/renderer/controllers/prefs-controller.js
+++ b/renderer/controllers/prefs-controller.js
@@ -0,0 +1,51 @@
+const State = require('../lib/state')
+
+// Controls the Preferences screen
+module.exports = class PrefsController {
+  constructor (state, config) {
+    this.state = state
+    this.config = config
+  }
+
+  // Goes to the Preferences screen
+  show () {
+    var state = this.state
+    state.location.go({
+      url: 'preferences',
+      onbeforeload: function (cb) {
+        // initialize preferences
+        state.window.title = 'Preferences'
+        state.unsaved = Object.assign(state.unsaved || {}, {prefs: state.saved.prefs || {}})
+        cb()
+      },
+      onbeforeunload: (cb) => {
+        // save state after preferences
+        this.save()
+        state.window.title = this.config.APP_WINDOW_TITLE
+        cb()
+      }
+    })
+  }
+
+  // Updates a single property in the UNSAVED prefs
+  // For example: updatePreferences("foo.bar", "baz")
+  // Call savePreferences to save to config.json
+  update (property, value) {
+    var path = property.split('.')
+    var key = this.state.unsaved.prefs
+    for (var i = 0; i < path.length - 1; i++) {
+      if (typeof key[path[i]] === 'undefined') {
+        key[path[i]] = {}
+      }
+      key = key[path[i]]
+    }
+    key[path[i]] = value
+  }
+
+  // All unsaved prefs take effect atomically, and are saved to config.json
+  save () {
+    var state = this.state
+    state.saved.prefs = Object.assign(state.saved.prefs || {}, state.unsaved.prefs)
+    State.save(state)
+  }
+}
--- a/renderer/controllers/subtitles-controller.js
+++ b/renderer/controllers/subtitles-controller.js
@@ -0,0 +1,137 @@
+const electron = require('electron')
+const fs = require('fs-extra')
+const path = require('path')
+const parallel = require('run-parallel')
+
+const {dispatch} = require('../lib/dispatcher')
+
+module.exports = class SubtitlesController {
+  constructor (state) {
+    this.state = state
+  }
+
+  openSubtitles () {
+    electron.remote.dialog.showOpenDialog({
+      title: 'Select a subtitles file.',
+      filters: [ { name: 'Subtitles', extensions: ['vtt', 'srt'] } ],
+      properties: [ 'openFile' ]
+    }, (filenames) => {
+      if (!Array.isArray(filenames)) return
+      this.addSubtitles(filenames, true)
+    })
+  }
+
+  selectSubtitle (ix) {
+    this.state.playing.subtitles.selectedIndex = ix
+  }
+
+  toggleSubtitlesMenu () {
+    var subtitles = this.state.playing.subtitles
+    subtitles.showMenu = !subtitles.showMenu
+  }
+
+  addSubtitles (files, autoSelect) {
+    var state = this.state
+    // Subtitles are only supported when playing video files
+    if (state.playing.type !== 'video') return
+    if (files.length === 0) return
+    var subtitles = state.playing.subtitles
+
+    // Read the files concurrently, then add all resulting subtitle tracks
+    var tasks = files.map((file) => (cb) => loadSubtitle(file, cb))
+    parallel(tasks, function (err, tracks) {
+      if (err) return dispatch('error', err)
+
+      for (var i = 0; i < tracks.length; i++) {
+        // No dupes allowed
+        var track = tracks[i]
+        var trackIndex = state.playing.subtitles.tracks
+          .findIndex((t) => track.filePath === t.filePath)
+
+        // Add the track
+        if (trackIndex === -1) {
+          trackIndex = state.playing.subtitles.tracks.push(track) - 1
+        }
+
+        // If we're auto-selecting a track, try to find one in the user's language
+        if (autoSelect && (i === 0 || isSystemLanguage(track.language))) {
+          state.playing.subtitles.selectedIndex = trackIndex
+        }
+      }
+
+      // Finally, make sure no two tracks have the same label
+      relabelSubtitles(subtitles)
+    })
+  }
+
+  checkForSubtitles () {
+    if (this.state.playing.type !== 'video') return
+    var torrentSummary = this.state.getPlayingTorrentSummary()
+    if (!torrentSummary || !torrentSummary.progress) return
+
+    torrentSummary.progress.files.forEach((fp, ix) => {
+      if (fp.numPieces !== fp.numPiecesPresent) return // ignore incomplete files
+      var file = torrentSummary.files[ix]
+      if (!this.isSubtitle(file.name)) return
+      var filePath = path.join(torrentSummary.path, file.path)
+      this.addSubtitles([filePath], false)
+    })
+  }
+
+  isSubtitle (file) {
+    var name = typeof file === 'string' ? file : file.name
+    var ext = path.extname(name).toLowerCase()
+    return ext === '.srt' || ext === '.vtt'
+  }
+}
+
+function loadSubtitle (file, cb) {
+  // Lazy load to keep startup fast
+  var concat = require('simple-concat')
+  var LanguageDetect = require('languagedetect')
+  var srtToVtt = require('srt-to-vtt')
+
+  // Read the .SRT or .VTT file, parse it, add subtitle track
+  var filePath = file.path || file
+
+  var vttStream = fs.createReadStream(filePath).pipe(srtToVtt())
+
+  concat(vttStream, function (err, buf) {
+    if (err) return dispatch('error', 'Can\'t parse subtitles file.')
+
+    // Detect what language the subtitles are in
+    var vttContents = buf.toString().replace(/(.*-->.*)/g, '')
+    var langDetected = (new LanguageDetect()).detect(vttContents, 2)
+    langDetected = langDetected.length ? langDetected[0][0] : 'subtitle'
+    langDetected = langDetected.slice(0, 1).toUpperCase() + langDetected.slice(1)
+
+    var track = {
+      buffer: 'data:text/vtt;base64,' + buf.toString('base64'),
+      language: langDetected,
+      label: langDetected,
+      filePath: filePath
+    }
+
+    cb(null, track)
+  })
+}
+
+// Checks whether a language name like "English" or "German" matches the system
+// language, aka the current locale
+function isSystemLanguage (language) {
+  var iso639 = require('iso-639-1')
+  var osLangISO = window.navigator.language.split('-')[0] // eg "en"
+  var langIso = iso639.getCode(language) // eg "de" if language is "German"
+  return langIso === osLangISO
+}
+
+// Make sure we don't have two subtitle tracks with the same label
+// Labels each track by language, eg "German", "English", "English 2", ...
+function relabelSubtitles (subtitles) {
+  var counts = {}
+  subtitles.tracks.forEach(function (track) {
+    var lang = track.language
+    counts[lang] = (counts[lang] || 0) + 1
+    track.label = counts[lang] > 1 ? (lang + ' ' + counts[lang]) : lang
+  })
+}
--- a/renderer/controllers/torrent-controller.js
+++ b/renderer/controllers/torrent-controller.js
@@ -0,0 +1,192 @@
+const path = require('path')
+const ipcRenderer = require('electron').ipcRenderer
+
+const TorrentSummary = require('../lib/torrent-summary')
+const TorrentPlayer = require('../lib/torrent-player')
+const sound = require('../lib/sound')
+const {dispatch} = require('../lib/dispatcher')
+
+module.exports = class TorrentController {
+  constructor (state) {
+    this.state = state
+  }
+
+  torrentInfoHash (torrentKey, infoHash) {
+    var torrentSummary = this.getTorrentSummary(torrentKey)
+    console.log('got infohash for %s torrent %s',
+      torrentSummary ? 'existing' : 'new', torrentKey)
+
+    if (!torrentSummary) {
+      var torrents = this.state.saved.torrents
+
+      // Check if an existing (non-active) torrent has the same info hash
+      if (torrents.find((t) => t.infoHash === infoHash)) {
+        ipcRenderer.send('wt-stop-torrenting', infoHash)
+        return dispatch('error', 'Cannot add duplicate torrent')
+      }
+
+      torrentSummary = {
+        torrentKey: torrentKey,
+        status: 'new'
+      }
+      torrents.unshift(torrentSummary)
+      sound.play('ADD')
+    }
+
+    torrentSummary.infoHash = infoHash
+    dispatch('update')
+  }
+
+  torrentWarning (torrentKey, message) {
+    console.log('warning for torrent %s: %s', torrentKey, message)
+  }
+
+  torrentError (torrentKey, message) {
+    // TODO: WebTorrent needs semantic errors
+    if (message.startsWith('Cannot add duplicate torrent')) {
+      // Remove infohash from the message
+      message = 'Cannot add duplicate torrent'
+    }
+    dispatch('error', message)
+
+    var torrentSummary = this.getTorrentSummary(torrentKey)
+    if (torrentSummary) {
+      console.log('Pausing torrent %s due to error: %s', torrentSummary.infoHash, message)
+      torrentSummary.status = 'paused'
+      dispatch('update')
+    }
+  }
+
+  torrentMetadata (torrentKey, torrentInfo) {
+    // Summarize torrent
+    var torrentSummary = this.getTorrentSummary(torrentKey)
+    torrentSummary.status = 'downloading'
+    torrentSummary.name = torrentSummary.displayName || torrentInfo.name
+    torrentSummary.path = torrentInfo.path
+    torrentSummary.magnetURI = torrentInfo.magnetURI
+    // TODO: make torrentInfo immutable, save separately as torrentSummary.info
+    // For now, check whether torrentSummary.files has already been set:
+    var hasDetailedFileInfo = torrentSummary.files && torrentSummary.files[0].path
+    if (!hasDetailedFileInfo) {
+      torrentSummary.files = torrentInfo.files
+    }
+    if (!torrentSummary.selections) {
+      torrentSummary.selections = torrentSummary.files.map((x) => true)
+    }
+    torrentSummary.defaultPlayFileIndex = TorrentPlayer.pickFileToPlay(torrentInfo.files)
+    dispatch('update')
+
+    // Save the .torrent file, if it hasn't been saved already
+    if (!torrentSummary.torrentFileName) ipcRenderer.send('wt-save-torrent-file', torrentKey)
+
+    // Auto-generate a poster image, if it hasn't been generated already
+    if (!torrentSummary.posterFileName) ipcRenderer.send('wt-generate-torrent-poster', torrentKey)
+  }
+
+  torrentDone (torrentKey, torrentInfo) {
+    // Update the torrent summary
+    var torrentSummary = this.getTorrentSummary(torrentKey)
+    torrentSummary.status = 'seeding'
+
+    // Notify the user that a torrent finished, but only if we actually DL'd at least part of it.
+    // Don't notify if we merely finished verifying data files that were already on disk.
+    if (torrentInfo.bytesReceived > 0) {
+      if (!this.state.window.isFocused) {
+        this.state.dock.badge += 1
+      }
+      showDoneNotification(torrentSummary)
+      ipcRenderer.send('downloadFinished', getTorrentPath(torrentSummary))
+    }
+
+    dispatch('update')
+  }
+
+  torrentProgress (progressInfo) {
+    // Overall progress across all active torrents, 0 to 1
+    var progress = progressInfo.progress
+    var hasActiveTorrents = progressInfo.hasActiveTorrents
+
+    // Hide progress bar when client has no torrents, or progress is 100%
+    // TODO: isn't this equivalent to: if (progress === 1) ?
+    if (!hasActiveTorrents || progress === 1) {
+      progress = -1
+    }
+
+    // Show progress bar under the WebTorrent taskbar icon, on OSX
+    this.state.dock.progress = progress
+
+    // Update progress for each individual torrent
+    progressInfo.torrents.forEach((p) => {
+      var torrentSummary = this.getTorrentSummary(p.torrentKey)
+      if (!torrentSummary) {
+        console.log('warning: got progress for missing torrent %s', p.torrentKey)
+        return
+      }
+      torrentSummary.progress = p
+    })
+
+    // TODO: Find an efficient way to re-enable this line, which allows subtitle
+    //       files which are completed after a video starts to play to be added
+    //       dynamically to the list of subtitles.
+    // checkForSubtitles()
+
+    dispatch('update')
+  }
+
+  torrentFileModtimes (torrentKey, fileModtimes) {
+    var torrentSummary = this.getTorrentSummary(torrentKey)
+    torrentSummary.fileModtimes = fileModtimes
+    dispatch('saveStateThrottled')
+  }
+
+  torrentFileSaved (torrentKey, torrentFileName) {
+    console.log('torrent file saved %s: %s', torrentKey, torrentFileName)
+    var torrentSummary = this.getTorrentSummary(torrentKey)
+    torrentSummary.torrentFileName = torrentFileName
+    dispatch('saveStateThrottled')
+  }
+
+  torrentPosterSaved (torrentKey, posterFileName) {
+    var torrentSummary = this.getTorrentSummary(torrentKey)
+    torrentSummary.posterFileName = posterFileName
+    dispatch('saveStateThrottled')
+  }
+
+  torrentAudioMetadata (infoHash, index, info) {
+    var torrentSummary = this.getTorrentSummary(infoHash)
+    var fileSummary = torrentSummary.files[index]
+    fileSummary.audioInfo = info
+    dispatch('update')
+  }
+
+  torrentServerRunning (serverInfo) {
+    this.state.server = serverInfo
+  }
+
+  // Gets a torrent summary {name, infoHash, status} from state.saved.torrents
+  // Returns undefined if we don't know that infoHash
+  getTorrentSummary (torrentKey) {
+    return TorrentSummary.getByKey(this.state, torrentKey)
+  }
+}
+
+function getTorrentPath (torrentSummary) {
+  var itemPath = TorrentSummary.getFileOrFolder(torrentSummary)
+  if (torrentSummary.files.length > 1) {
+    itemPath = path.dirname(itemPath)
+  }
+  return itemPath
+}
+
+function showDoneNotification (torrent) {
+  var notif = new window.Notification('Download Complete', {
+    body: torrent.name,
+    silent: true
+  })
+
+  notif.onclick = function () {
+    ipcRenderer.send('show')
+  }
+
+  sound.play('DONE')
+}
--- a/renderer/controllers/torrent-list-controller.js
+++ b/renderer/controllers/torrent-list-controller.js
@@ -0,0 +1,282 @@
+const fs = require('fs')
+const path = require('path')
+const electron = require('electron')
+
+const {dispatch} = require('../lib/dispatcher')
+const State = require('../lib/state')
+const sound = require('../lib/sound')
+const TorrentSummary = require('../lib/torrent-summary')
+
+const ipcRenderer = electron.ipcRenderer
+
+const instantIoRegex = /^(https:\/\/)?instant\.io\/#/
+
+// Controls the torrent list: creating, adding, deleting, & manipulating torrents
+module.exports = class TorrentListController {
+  constructor (state) {
+    this.state = state
+  }
+
+  // Adds a torrent to the list, starts downloading/seeding. TorrentID can be a
+  // magnet URI, infohash, or torrent file: https://github.com/feross/webtorrent#clientaddtorrentid-opts-function-ontorrent-torrent-
+  addTorrent (torrentId) {
+    if (torrentId.path) {
+      // Use path string instead of W3C File object
+      torrentId = torrentId.path
+    }
+    // Allow a instant.io link to be pasted
+    // TODO: remove this once support is added to webtorrent core
+    if (typeof torrentId === 'string' && instantIoRegex.test(torrentId)) {
+      torrentId = torrentId.slice(torrentId.indexOf('#') + 1)
+    }
+
+    var torrentKey = this.state.nextTorrentKey++
+    var path = this.state.saved.prefs.downloadPath
+
+    ipcRenderer.send('wt-start-torrenting', torrentKey, torrentId, path)
+
+    dispatch('backToList')
+  }
+
+  // Shows the Create Torrent page with options to seed a given file or folder
+  showCreateTorrent (files) {
+    // Files will either be an array of file objects, which we can send directly
+    // to the create-torrent screen
+    if (files.length === 0 || typeof files[0] !== 'string') {
+      this.state.location.go({
+        url: 'create-torrent',
+        files: files
+      })
+      return
+    }
+
+    // ... or it will be an array of mixed file and folder paths. We have to walk
+    // through all the folders and find the files
+    findFilesRecursive(files, (allFiles) => this.showCreateTorrent(allFiles))
+  }
+
+  // Switches between the advanced and simple Create Torrent UI
+  toggleCreateTorrentAdvanced () {
+    var info = this.state.location.current()
+    if (info.url !== 'create-torrent') return
+    info.showAdvanced = !info.showAdvanced
+  }
+
+  // Creates a new torrent and start seeeding
+  createTorrent (options) {
+    var state = this.state
+    var torrentKey = state.nextTorrentKey++
+    ipcRenderer.send('wt-create-torrent', torrentKey, options)
+    state.location.backToFirst(function () {
+      state.location.clearForward('create-torrent')
+    })
+  }
+
+  // Starts downloading and/or seeding a given torrentSummary.
+  startTorrentingSummary (torrentSummary) {
+    var s = torrentSummary
+
+    // Backward compatibility for config files save before we had torrentKey
+    if (!s.torrentKey) s.torrentKey = this.state.nextTorrentKey++
+
+    // Use Downloads folder by default
+    if (!s.path) s.path = this.state.saved.prefs.downloadPath
+
+    ipcRenderer.send('wt-start-torrenting',
+                      s.torrentKey,
+                      TorrentSummary.getTorrentID(s),
+                      s.path,
+                      s.fileModtimes,
+                      s.selections)
+  }
+
+  // TODO: use torrentKey, not infoHash
+  toggleTorrent (infoHash) {
+    var torrentSummary = TorrentSummary.getByKey(this.state, infoHash)
+    if (torrentSummary.status === 'paused') {
+      torrentSummary.status = 'new'
+      this.startTorrentingSummary(torrentSummary)
+      sound.play('ENABLE')
+    } else {
+      torrentSummary.status = 'paused'
+      ipcRenderer.send('wt-stop-torrenting', torrentSummary.infoHash)
+      sound.play('DISABLE')
+    }
+  }
+
+  toggleTorrentFile (infoHash, index) {
+    var torrentSummary = TorrentSummary.getByKey(this.state, infoHash)
+    torrentSummary.selections[index] = !torrentSummary.selections[index]
+
+    // Let the WebTorrent process know to start or stop fetching that file
+    ipcRenderer.send('wt-select-files', infoHash, torrentSummary.selections)
+  }
+
+  confirmDeleteTorrent (infoHash, deleteData) {
+    this.state.modal = {
+      id: 'remove-torrent-modal',
+      infoHash,
+      deleteData
+    }
+  }
+
+  // TODO: use torrentKey, not infoHash
+  deleteTorrent (infoHash, deleteData) {
+    ipcRenderer.send('wt-stop-torrenting', infoHash)
+
+    var index = this.state.saved.torrents.findIndex((x) => x.infoHash === infoHash)
+
+    if (index > -1) {
+      var summary = this.state.saved.torrents[index]
+
+      // remove torrent and poster file
+      deleteFile(TorrentSummary.getTorrentPath(summary))
+      deleteFile(TorrentSummary.getPosterPath(summary)) // TODO: will the css path hack affect windows?
+
+      // optionally delete the torrent data
+      if (deleteData) moveItemToTrash(summary)
+
+      // remove torrent from saved list
+      this.state.saved.torrents.splice(index, 1)
+      State.saveThrottled(this.state)
+    }
+
+    this.state.location.clearForward('player') // prevent user from going forward to a deleted torrent
+    sound.play('DELETE')
+  }
+
+  toggleSelectTorrent (infoHash) {
+    if (this.state.selectedInfoHash === infoHash) {
+      this.state.selectedInfoHash = null
+    } else {
+      this.state.selectedInfoHash = infoHash
+    }
+  }
+
+  openTorrentContextMenu (infoHash) {
+    var torrentSummary = TorrentSummary.getByKey(this.state, infoHash)
+    var menu = new electron.remote.Menu()
+
+    menu.append(new electron.remote.MenuItem({
+      label: 'Remove From List',
+      click: () => dispatch('confirmDeleteTorrent', torrentSummary.infoHash, false)
+    }))
+
+    menu.append(new electron.remote.MenuItem({
+      label: 'Remove Data File',
+      click: () => dispatch('confirmDeleteTorrent', torrentSummary.infoHash, true)
+    }))
+
+    menu.append(new electron.remote.MenuItem({
+      type: 'separator'
+    }))
+
+    if (torrentSummary.files) {
+      menu.append(new electron.remote.MenuItem({
+        label: process.platform === 'darwin' ? 'Show in Finder' : 'Show in Folder',
+        click: () => showItemInFolder(torrentSummary)
+      }))
+      menu.append(new electron.remote.MenuItem({
+        type: 'separator'
+      }))
+    }
+
+    menu.append(new electron.remote.MenuItem({
+      label: 'Copy Magnet Link to Clipboard',
+      click: () => electron.clipboard.writeText(torrentSummary.magnetURI)
+    }))
+
+    menu.append(new electron.remote.MenuItem({
+      label: 'Copy Instant.io Link to Clipboard',
+      click: () => electron.clipboard.writeText(`https://instant.io/#${torrentSummary.infoHash}`)
+    }))
+
+    menu.append(new electron.remote.MenuItem({
+      label: 'Save Torrent File As...',
+      click: () => saveTorrentFileAs(torrentSummary)
+    }))
+
+    menu.popup(electron.remote.getCurrentWindow())
+  }
+}
+
+// Recursively finds {name, path, size} for all files in a folder
+// Calls `cb` on success, calls `onError` on failure
+function findFilesRecursive (paths, cb) {
+  if (paths.length > 1) {
+    var numComplete = 0
+    var ret = []
+    paths.forEach(function (path) {
+      findFilesRecursive([path], function (fileObjs) {
+        ret = ret.concat(fileObjs)
+        if (++numComplete === paths.length) {
+          ret.sort((a, b) => a.path < b.path ? -1 : a.path > b.path)
+          cb(ret)
+        }
+      })
+    })
+    return
+  }
+
+  var fileOrFolder = paths[0]
+  fs.stat(fileOrFolder, function (err, stat) {
+    if (err) return dispatch('error', err)
+
+    // Files: return name, path, and size
+    if (!stat.isDirectory()) {
+      var filePath = fileOrFolder
+      return cb([{
+        name: path.basename(filePath),
+        path: filePath,
+        size: stat.size
+      }])
+    }
+
+    // Folders: recurse, make a list of all the files
+    var folderPath = fileOrFolder
+    fs.readdir(folderPath, function (err, fileNames) {
+      if (err) return dispatch('error', err)
+      var paths = fileNames.map((fileName) => path.join(folderPath, fileName))
+      findFilesRecursive(paths, cb)
+    })
+  })
+}
+
+function deleteFile (path) {
+  if (!path) return
+  fs.unlink(path, function (err) {
+    if (err) dispatch('error', err)
+  })
+}
+
+// Delete all files in a torrent
+function moveItemToTrash (torrentSummary) {
+  var filePath = TorrentSummary.getFileOrFolder(torrentSummary)
+  ipcRenderer.send('moveItemToTrash', filePath)
+}
+
+function showItemInFolder (torrentSummary) {
+  ipcRenderer.send('showItemInFolder', TorrentSummary.getFileOrFolder(torrentSummary))
+}
+
+function saveTorrentFileAs (torrentSummary) {
+  var downloadPath = this.state.saved.prefs.downloadPath
+  var newFileName = path.parse(torrentSummary.name).name + '.torrent'
+  var opts = {
+    title: 'Save Torrent File',
+    defaultPath: path.join(downloadPath, newFileName),
+    filters: [
+      { name: 'Torrent Files', extensions: ['torrent'] },
+      { name: 'All Files', extensions: ['*'] }
+    ]
+  }
+  electron.remote.dialog.showSaveDialog(electron.remote.getCurrentWindow(), opts, function (savePath) {
+    var torrentPath = TorrentSummary.getTorrentPath(torrentSummary)
+    fs.readFile(torrentPath, function (err, torrentFile) {
+      if (err) return dispatch('error', err)
+      fs.writeFile(savePath, torrentFile, function (err) {
+        if (err) return dispatch('error', err)
+      })
+    })
+  })
+}
--- a/renderer/controllers/update-controller.js
+++ b/renderer/controllers/update-controller.js
@@ -0,0 +1,26 @@
+const State = require('../lib/state')
+
+// Controls the UI checking for new versions of the app, prompting install
+module.exports = class UpdateController {
+  constructor (state) {
+    this.state = state
+  }
+
+  // Shows a modal saying that we have an update
+  updateAvailable (version) {
+    var skipped = this.state.saved.skippedVersions
+    if (skipped && skipped.includes(version)) {
+      console.log('new version skipped by user: v' + version)
+      return
+    }
+    this.state.modal = { id: 'update-available-modal', version: version }
+  }
+
+  // Don't show the modal again until the next version
+  skipVersion (version) {
+    var skipped = this.state.saved.skippedVersions
+    if (!skipped) skipped = this.state.saved.skippedVersions = []
+    skipped.push(version)
+    State.saveThrottled(this.state)
+  }
+}
--- a/renderer/lib/cast.js
+++ b/renderer/lib/cast.js
@@ -3,8 +3,9 @@
 // * Starts and stops casting, provides remote video controls
 module.exports = {
  init,
-  open,
-  close,
+  toggleMenu,
+  selectDevice,
+  stop,
  play,
  pause,
  seek,
@@ -12,9 +13,8 @@ module.exports = {
  setRate
 }

-var airplayer = require('airplayer')()
-var chromecasts = require('chromecasts')()
-var dlnacasts = require('dlnacasts')()
+// Lazy load these for a ~300ms improvement in startup time
+var airplayer, chromecasts, dlnacasts

 var config = require('../../config')

@@ -32,24 +32,54 @@ function init (appState, callback) {
  state = appState
  update = callback

+  // Load modules, scan the network for devices
+  airplayer = require('airplayer')()
+  chromecasts = require('chromecasts')()
+  dlnacasts = require('dlnacasts')()
+
+  state.devices.chromecast = chromecastPlayer()
+  state.devices.dlna = dlnaPlayer()
+  state.devices.airplay = airplayPlayer()
+
  // Listen for devices: Chromecast, DLNA and Airplay
-  chromecasts.on('update', function (player) {
-    state.devices.chromecast = chromecastPlayer(player)
+  chromecasts.on('update', function (device) {
+    // TODO: how do we tell if there are *no longer* any Chromecasts available?
+    // From looking at the code, chromecasts.players only grows, never shrinks
+    state.devices.chromecast.addDevice(device)
  })

-  dlnacasts.on('update', function (player) {
-    state.devices.dlna = dlnaPlayer(player)
+  dlnacasts.on('update', function (device) {
+    state.devices.dlna.addDevice(device)
  })

-  airplayer.on('update', function (player) {
-    state.devices.airplay = airplayPlayer(player)
+  airplayer.on('update', function (device) {
+    state.devices.airplay.addDevice(device)
  })
 }

 // chromecast player implementation
-function chromecastPlayer (player) {
-  function addEvents () {
-    player.on('error', function (err) {
+function chromecastPlayer () {
+  var ret = {
+    device: null,
+    addDevice,
+    getDevices,
+    open,
+    play,
+    pause,
+    stop,
+    status,
+    seek,
+    volume
+  }
+  return ret
+
+  function getDevices () {
+    return chromecasts.players
+  }
+
+  function addDevice (device) {
+    device.on('error', function (err) {
+      if (device !== ret.device) return
      state.playing.location = 'local'
      state.errors.push({
        time: new Date().getTime(),
@@ -57,7 +87,8 @@ function chromecastPlayer (player) {
      })
      update()
    })
-    player.on('disconnect', function () {
+    device.on('disconnect', function () {
+      if (device !== ret.device) return
      state.playing.location = 'local'
      update()
    })
@@ -65,7 +96,7 @@ function chromecastPlayer (player) {

  function open () {
    var torrentSummary = state.saved.torrents.find((x) => x.infoHash === state.playing.infoHash)
-    player.play(state.server.networkURL, {
+    ret.device.play(state.server.networkURL, {
      type: 'video/mp4',
      title: config.APP_NAME + ' - ' + torrentSummary.name
    }, function (err) {
@@ -83,19 +114,19 @@ function chromecastPlayer (player) {
  }

  function play (callback) {
-    player.play(null, null, callback)
+    ret.device.play(null, null, callback)
  }

  function pause (callback) {
-    player.pause(callback)
+    ret.device.pause(callback)
  }

  function stop (callback) {
-    player.stop(callback)
+    ret.device.stop(callback)
  }

  function status () {
-    player.status(function (err, status) {
+    ret.device.status(function (err, status) {
      if (err) return console.log('error getting %s status: %o', state.playing.location, err)
      state.playing.isPaused = status.playerState === 'PAUSED'
      state.playing.currentTime = status.currentTime
@@ -105,30 +136,31 @@ function chromecastPlayer (player) {
  }

  function seek (time, callback) {
-    player.seek(time, callback)
+    ret.device.seek(time, callback)
  }

  function volume (volume, callback) {
-    player.volume(volume, callback)
-  }
-
-  addEvents()
-
-  return {
-    player: player,
-    open: open,
-    play: play,
-    pause: pause,
-    stop: stop,
-    status: status,
-    seek: seek,
-    volume: volume
+    ret.device.volume(volume, callback)
  }
 }

 // airplay player implementation
-function airplayPlayer (player) {
-  function addEvents () {
+function airplayPlayer () {
+  var ret = {
+    device: null,
+    addDevice,
+    getDevices,
+    open,
+    play,
+    pause,
+    stop,
+    status,
+    seek,
+    volume
+  }
+  return ret
+
+  function addDevice (player) {
    player.on('event', function (event) {
      switch (event.state) {
        case 'loading':
@@ -146,8 +178,12 @@ function airplayPlayer (player) {
    })
  }

+  function getDevices () {
+    return airplayer.players
+  }
+
  function open () {
-    player.play(state.server.networkURL, function (err, res) {
+    ret.device.play(state.server.networkURL, function (err, res) {
      if (err) {
        state.playing.location = 'local'
        state.errors.push({
@@ -162,19 +198,19 @@ function airplayPlayer (player) {
  }

  function play (callback) {
-    player.resume(callback)
+    ret.device.resume(callback)
  }

  function pause (callback) {
-    player.pause(callback)
+    ret.device.pause(callback)
  }

  function stop (callback) {
-    player.stop(callback)
+    ret.device.stop(callback)
  }

  function status () {
-    player.playbackInfo(function (err, res, status) {
+    ret.device.playbackInfo(function (err, res, status) {
      if (err) {
        state.playing.location = 'local'
        state.errors.push({
@@ -190,7 +226,7 @@ function airplayPlayer (player) {
  }

  function seek (time, callback) {
-    player.scrub(time, callback)
+    ret.device.scrub(time, callback)
  }

  function volume (volume, callback) {
@@ -198,25 +234,31 @@ function airplayPlayer (player) {
    // TODO: We should just disable the volume slider
    state.playing.volume = volume
  }
-
-  addEvents()
-
-  return {
-    player: player,
-    open: open,
-    play: play,
-    pause: pause,
-    stop: stop,
-    status: status,
-    seek: seek,
-    volume: volume
-  }
 }

 // DLNA player implementation
 function dlnaPlayer (player) {
-  function addEvents () {
-    player.on('error', function (err) {
+  var ret = {
+    device: null,
+    addDevice,
+    getDevices,
+    open,
+    play,
+    pause,
+    stop,
+    status,
+    seek,
+    volume
+  }
+  return ret
+
+  function getDevices () {
+    return dlnacasts.players
+  }
+
+  function addDevice (device) {
+    device.on('error', function (err) {
+      if (device !== ret.device) return
      state.playing.location = 'local'
      state.errors.push({
        time: new Date().getTime(),
@@ -224,7 +266,8 @@ function dlnaPlayer (player) {
      })
      update()
    })
-    player.on('disconnect', function () {
+    device.on('disconnect', function () {
+      if (device !== ret.device) return
      state.playing.location = 'local'
      update()
    })
@@ -232,7 +275,7 @@ function dlnaPlayer (player) {

  function open () {
    var torrentSummary = state.saved.torrents.find((x) => x.infoHash === state.playing.infoHash)
-    player.play(state.server.networkURL, {
+    ret.device.play(state.server.networkURL, {
      type: 'video/mp4',
      title: config.APP_NAME + ' - ' + torrentSummary.name,
      seek: state.playing.currentTime > 10 ? state.playing.currentTime : 0
@@ -251,19 +294,19 @@ function dlnaPlayer (player) {
  }

  function play (callback) {
-    player.play(null, null, callback)
+    ret.device.play(null, null, callback)
  }

  function pause (callback) {
-    player.pause(callback)
+    ret.device.pause(callback)
  }

  function stop (callback) {
-    player.stop(callback)
+    ret.device.stop(callback)
  }

  function status () {
-    player.status(function (err, status) {
+    ret.device.status(function (err, status) {
      if (err) return console.log('error getting %s status: %o', state.playing.location, err)
      state.playing.isPaused = status.playerState === 'PAUSED'
      state.playing.currentTime = status.currentTime
@@ -273,61 +316,78 @@ function dlnaPlayer (player) {
  }

  function seek (time, callback) {
-    player.seek(time, callback)
+    ret.device.seek(time, callback)
  }

  function volume (volume, callback) {
-    player.volume(volume, function (err) {
+    ret.device.volume(volume, function (err) {
      // quick volume update
      state.playing.volume = volume
      callback(err)
    })
  }
-
-  addEvents()
-
-  return {
-    player: player,
-    open: open,
-    play: play,
-    pause: pause,
-    stop: stop,
-    status: status,
-    seek: seek,
-    volume: volume
-  }
 }

 // Start polling cast device state, whenever we're connected
 function startStatusInterval () {
  statusInterval = setInterval(function () {
-    var device = getDevice()
-    if (device) {
-      device.status()
-    }
+    var player = getPlayer()
+    if (player) player.status()
  }, 1000)
 }

-function open (location) {
+/*
+ * Shows the device menu for a given cast type ('chromecast', 'airplay', etc)
+ * The menu lists eg. all Chromecasts detected; the user can click one to cast.
+ * If the menu was already showing for that type, hides the menu.
+ */
+function toggleMenu (location) {
+  // If the menu is already showing, hide it
+  if (state.devices.castMenu && state.devices.castMenu.location === location) {
+    state.devices.castMenu = null
+    return
+  }
+
+  // Never cast to two devices at the same time
  if (state.playing.location !== 'local') {
    throw new Error('You can\'t connect to ' + location + ' when already connected to another device')
  }

-  state.playing.location = location + '-pending'
-  var device = getDevice(location)
-  if (device) {
-    getDevice(location).open()
-    startStatusInterval()
-  }
+  // Find all cast devices of the given type
+  var player = getPlayer(location)
+  var devices = player ? player.getDevices() : []
+  if (devices.length === 0) throw new Error('No ' + location + ' devices available')

+  // Show a menu
+  state.devices.castMenu = {location, devices}
+}
+
+function selectDevice (index) {
+  var {location, devices} = state.devices.castMenu
+
+  // Start casting
+  var player = getPlayer(location)
+  player.device = devices[index]
+  player.open()
+
+  // Poll the casting device's status every few seconds
+  startStatusInterval()
+
+  // Show the Connecting... screen
+  state.devices.castMenu = null
+  state.playing.castName = devices[index].name
+  state.playing.location = location + '-pending'
  update()
 }

 // Stops casting, move video back to local screen
-function close () {
-  var device = getDevice()
-  if (device) {
-    device.stop(stoppedCasting)
+function stop () {
+  var player = getPlayer()
+  if (player) {
+    player.stop(function () {
+      player.device = null
+      stoppedCasting()
+    })
    clearInterval(statusInterval)
  } else {
    stoppedCasting()
@@ -340,8 +400,8 @@ function stoppedCasting () {
  update()
 }

-function getDevice (location) {
-  if (location && state.devices[location]) {
+function getPlayer (location) {
+  if (location) {
    return state.devices[location]
  } else if (state.playing.location === 'chromecast') {
    return state.devices.chromecast
@@ -355,29 +415,25 @@ function getDevice (location) {
 }

 function play () {
-  var device = getDevice()
-  if (device) {
-    device.play(castCallback)
-  }
+  var player = getPlayer()
+  if (player) player.play(castCallback)
 }

 function pause () {
-  var device = getDevice()
-  if (device) {
-    device.pause(castCallback)
-  }
+  var player = getPlayer()
+  if (player) player.pause(castCallback)
 }

 function setRate (rate) {
-  var device
+  var player
  var result = true
  if (state.playing.location === 'chromecast') {
    // TODO find how to control playback rate on chromecast
    castCallback()
    result = false
  } else if (state.playing.location === 'airplay') {
-    device = state.devices.airplay
-    device.rate(rate, castCallback)
+    player = state.devices.airplay
+    player.rate(rate, castCallback)
  } else {
    result = false
  }
@@ -385,17 +441,13 @@ function setRate (rate) {
 }

 function seek (time) {
-  var device = getDevice()
-  if (device) {
-    device.seek(time, castCallback)
-  }
+  var player = getPlayer()
+  if (player) player.seek(time, castCallback)
 }

 function setVolume (volume) {
-  var device = getDevice()
-  if (device) {
-    device.volume(volume, castCallback)
-  }
+  var player = getPlayer()
+  if (player) player.volume(volume, castCallback)
 }

 function castCallback () {
--- a/renderer/lib/state.js
+++ b/renderer/lib/state.js
@@ -1,15 +1,17 @@
-module.exports = {
-  getDefaultPlayState,
-  load,
-  save
-}
-
 var appConfig = require('application-config')('WebTorrent')
 var path = require('path')
+var {EventEmitter} = require('events')

 var config = require('../../config')
 var migrations = require('./migrations')

+var State = module.exports = Object.assign(new EventEmitter(), {
+  getDefaultPlayState,
+  load,
+  save,
+  saveThrottled
+})
+
 appConfig.filePath = path.join(config.CONFIG_PATH, 'config.json')

 function getDefaultState () {
@@ -32,10 +34,7 @@ function getDefaultState () {
    },
    selectedInfoHash: null, /* the torrent we've selected to view details. see state.torrents */
    playing: getDefaultPlayState(), /* the media (audio or video) that we're currently playing */
-    devices: { /* playback devices like Chromecast and AppleTV */
-      airplay: null, /* airplay client. finds and manages AppleTVs */
-      chromecast: null /* chromecast client. finds and manages Chromecasts */
-    },
+    devices: {}, /* playback devices like Chromecast and AppleTV */
    dock: {
      badge: 0,
      progress: 0
@@ -183,8 +182,7 @@ function load (cb) {
 // Write state.saved to the JSON state file
 function save (state, cb) {
  console.log('Saving state to ' + appConfig.filePath)
-
-  var electron = require('electron')
+  delete state.saveStateTimeout

  // Clean up, so that we're not saving any pending state
  var copy = Object.assign({}, state.saved)
@@ -206,10 +204,17 @@ function save (state, cb) {
      return torrent
    })

-  appConfig.write(copy, function (err) {
+  appConfig.write(copy, (err) => {
    if (err) console.error(err)
-
-    // TODO: this doesn't belong here
-    electron.ipcRenderer.send('savedState')
+    else State.emit('savedState')
  })
 }
+
+// Write, but no more than once a second
+function saveThrottled (state) {
+  if (state.saveStateTimeout) return
+  state.saveStateTimeout = setTimeout(function () {
+    if (!state.saveStateTimeout) return
+    save(state)
+  }, 1000)
+}
--- a/renderer/lib/telemetry.js
+++ b/renderer/lib/telemetry.js
@@ -0,0 +1,152 @@
+// Collects anonymous usage stats and uncaught errors
+// Reports back so that we can improve WebTorrent Desktop
+module.exports = {
+  init,
+  logUncaughtError,
+  logPlayAttempt
+}
+
+const crypto = require('crypto')
+const electron = require('electron')
+const https = require('https')
+const os = require('os')
+const url = require('url')
+
+const config = require('../../config')
+
+var telemetry
+
+function init (state) {
+  telemetry = state.saved.telemetry
+  if (!telemetry) {
+    telemetry = state.saved.telemetry = createSummary()
+    reset()
+  }
+
+  var now = new Date()
+  telemetry.timestamp = now.toISOString()
+  telemetry.localTime = now.toTimeString()
+  telemetry.screens = getScreenInfo()
+  telemetry.system = getSystemInfo()
+  telemetry.approxNumTorrents = getApproxNumTorrents(state)
+
+  if (config.IS_PRODUCTION) {
+    postToServer()
+  } else {
+    // Development: telemetry used only for local debugging
+    // Empty uncaught errors, etc at the start of every run
+    reset()
+  }
+}
+
+function reset () {
+  telemetry.uncaughtErrors = []
+  telemetry.playAttempts = {
+    total: 0,
+    success: 0,
+    timeout: 0,
+    error: 0,
+    abandoned: 0
+  }
+}
+
+function postToServer () {
+  // Serialize the telemetry summary
+  var payload = new Buffer(JSON.stringify(telemetry), 'utf8')
+
+  // POST to our server
+  var options = url.parse(config.TELEMETRY_URL)
+  options.method = 'POST'
+  options.headers = {
+    'Content-Type': 'application/json',
+    'Content-Length': payload.length
+  }
+
+  var req = https.request(options, function (res) {
+    if (res.statusCode === 200) {
+      console.log('Successfully posted telemetry summary')
+      reset()
+    } else {
+      console.error('Couldn\'t post telemetry summary, got HTTP ' + res.statusCode)
+    }
+  })
+  req.on('error', function (e) {
+    console.error('Couldn\'t post telemetry summary', e)
+  })
+  req.write(payload)
+  req.end()
+}
+
+// Creates a new telemetry summary. Gives the user a unique ID,
+// collects screen resolution, etc
+function createSummary () {
+  // Make a 256-bit random unique ID
+  var userID = crypto.randomBytes(32).toString('hex')
+  return { userID }
+}
+
+// Track screen resolution
+function getScreenInfo () {
+  return electron.screen.getAllDisplays().map((screen) => ({
+    width: screen.size.width,
+    height: screen.size.height,
+    scaleFactor: screen.scaleFactor
+  }))
+}
+
+// Track basic system info like OS version and amount of RAM
+function getSystemInfo () {
+  return {
+    osPlatform: process.platform,
+    osRelease: os.type() + ' ' + os.release(),
+    architecture: os.arch(),
+    totalMemoryMB: os.totalmem() / (1 << 20),
+    numCores: os.cpus().length
+  }
+}
+
+// Get the number of torrents, rounded to the nearest power of two
+function getApproxNumTorrents (state) {
+  var exactNum = state.saved.torrents.length
+  if (exactNum === 0) return 0
+  // Otherwise, return 1, 2, 4, 8, etc by rounding in log space
+  var log2 = Math.log(exactNum) / Math.log(2)
+  return 1 << Math.round(log2)
+}
+
+// An uncaught error happened in the main process or in one of the windows
+function logUncaughtError (procName, err) {
+  console.error('uncaught error', procName, err)
+
+  // Not initialized yet? Ignore.
+  // Hopefully uncaught errors immediately on startup are fixed in dev
+  if (!telemetry) return
+
+  var message, stack
+  if (err instanceof Error) {
+    message = err.message
+    stack = err.stack
+  } else {
+    message = String(err)
+    stack = ''
+  }
+
+  // We need to POST the telemetry object, make sure it stays < 100kb
+  if (telemetry.uncaughtErrors.length > 20) return
+  if (message.length > 1000) message = message.substring(0, 1000)
+  if (stack.length > 1000) stack = stack.substring(0, 1000)
+
+  telemetry.uncaughtErrors.push({process: procName, message, stack})
+}
+
+// The user pressed play. It either worked, timed out, or showed the
+// "Play in VLC" codec error
+function logPlayAttempt (result) {
+  if (!['success', 'timeout', 'error', 'abandoned'].includes(result)) {
+    return console.error('Unknown play attempt result', result)
+  }
+
+  var attempts = telemetry.playAttempts
+  attempts.total = (attempts.total || 0) + 1
+  attempts[result] = (attempts[result] || 0) + 1
+}
--- a/renderer/lib/torrent-player.js
+++ b/renderer/lib/torrent-player.js
@@ -2,20 +2,21 @@ module.exports = {
  isPlayable,
  isVideo,
  isAudio,
-  isPlayableTorrent
+  isTorrent,
+  isPlayableTorrentSummary,
+  pickFileToPlay
 }

 var path = require('path')

-/**
- * Determines whether a file in a torrent is audio/video we can play
- */
+// Checks whether a fileSummary or file path is audio/video that we can play,
+// based on the file extension
 function isPlayable (file) {
  return isVideo(file) || isAudio(file)
 }

+// Checks whether a fileSummary or file path is playable video
 function isVideo (file) {
-  var ext = path.extname(file.name).toLowerCase()
  return [
    '.avi',
    '.m4v',
@@ -24,21 +25,59 @@ function isVideo (file) {
    '.mp4',
    '.mpg',
    '.ogv',
-    '.webm'
-  ].includes(ext)
+    '.webm',
+    '.wmv'
+  ].includes(getFileExtension(file))
 }

+// Checks whether a fileSummary or file path is playable audio
 function isAudio (file) {
-  var ext = path.extname(file.name).toLowerCase()
  return [
    '.aac',
    '.ac3',
    '.mp3',
    '.ogg',
    '.wav'
-  ].includes(ext)
+  ].includes(getFileExtension(file))
 }

-function isPlayableTorrent (torrentSummary) {
+// Checks if the argument is either:
+// - a string that's a valid filename ending in .torrent
+// - a file object where obj.name is ends in .torrent
+// - a string that's a magnet link (magnet://...)
+function isTorrent (file) {
+  var isTorrentFile = getFileExtension(file) === '.torrent'
+  var isMagnet = typeof file === 'string' && /^(stream-)?magnet:/.test(file)
+  return isTorrentFile || isMagnet
+}
+
+function getFileExtension (file) {
+  var name = typeof file === 'string' ? file : file.name
+  return path.extname(name).toLowerCase()
+}
+
+function isPlayableTorrentSummary (torrentSummary) {
  return torrentSummary.files && torrentSummary.files.some(isPlayable)
 }
+
+// Picks the default file to play from a list of torrent or torrentSummary files
+// Returns an index or undefined, if no files are playable
+function pickFileToPlay (files) {
+  // first, try to find the biggest video file
+  var videoFiles = files.filter(isVideo)
+  if (videoFiles.length > 0) {
+    var largestVideoFile = videoFiles.reduce(function (a, b) {
+      return a.length > b.length ? a : b
+    })
+    return files.indexOf(largestVideoFile)
+  }
+
+  // if there are no videos, play the first audio file
+  var audioFiles = files.filter(isAudio)
+  if (audioFiles.length > 0) {
+    return files.indexOf(audioFiles[0])
+  }
+
+  // no video or audio means nothing is playable
+  return undefined
+}
--- a/renderer/lib/torrent-poster.js
+++ b/renderer/lib/torrent-poster.js
@@ -16,7 +16,7 @@ function torrentPoster (torrent, cb) {
  if (videoFile) return torrentPosterFromVideo(videoFile, torrent, cb)

  // Third, try to use the largest image file
-  var imgFile = getLargestFileByExtension(torrent, ['.gif', '.jpg', '.png'])
+  var imgFile = getLargestFileByExtension(torrent, ['.gif', '.jpg', '.jpeg', '.png'])
  if (imgFile) return torrentPosterFromImage(imgFile, torrent, cb)

  // TODO: generate a waveform from the largest sound file
--- a/renderer/lib/torrent-summary.js
+++ b/renderer/lib/torrent-summary.js
@@ -1,6 +1,9 @@
 module.exports = {
  getPosterPath,
-  getTorrentPath
+  getTorrentPath,
+  getByKey,
+  getTorrentID,
+  getFileOrFolder
 }

 var path = require('path')
@@ -22,3 +25,32 @@ function getPosterPath (torrentSummary) {
  // Backslashes in URLS in CSS cause bizarre string encoding issues
  return posterPath.replace(/\\/g, '/')
 }
+
+// Expects a torrentSummary
+// Returns a torrentID: filename, magnet URI, or infohash
+function getTorrentID (torrentSummary) {
+  var s = torrentSummary
+  if (s.torrentFileName) { // Load torrent file from disk
+    return getTorrentPath(s)
+  } else { // Load torrent from DHT
+    return s.magnetURI || s.infoHash
+  }
+}
+
+// Expects a torrentKey or infoHash
+// Returns the corresponding torrentSummary, or undefined
+function getByKey (state, torrentKey) {
+  if (!torrentKey) return undefined
+  return state.saved.torrents.find((x) =>
+    x.torrentKey === torrentKey || x.infoHash === torrentKey)
+}
+
+// Returns the path to either the file (in a single-file torrent) or the root
+// folder (in  multi-file torrent)
+// WARNING: assumes that multi-file torrents consist of a SINGLE folder.
+// TODO: make this assumption explicit, enforce it in the `create-torrent`
+// module. Store root folder explicitly to avoid hacky path processing below.
+function getFileOrFolder (torrentSummary) {
+  var ts = torrentSummary
+  return path.join(ts.path, ts.files[0].path.split('/')[0])
+}
--- a/renderer/main.css
+++ b/renderer/main.css
@@ -260,7 +260,7 @@ table {

 .modal .modal-content {
  position: fixed;
-  top: 45px;
+  top: 38px;
  left: 0;
  right: 0;
  margin: 0 auto;
@@ -326,7 +326,6 @@ table {
 }

 .create-torrent input.torrent-is-private {
-  width: initial;
  margin: 0;
 }

@@ -404,7 +403,7 @@ button.button-raised:active {
 * OTHER FORM ELEMENT DEFAULTS
 */

-input {
+input[type='text'] {
  background: transparent;
  width: 300px;
  padding: 6px;
@@ -848,7 +847,7 @@ body.drag .app::after {
  height: 14px;
 }

-.player .controls .subtitles-list {
+.player .controls .options-list {
  position: fixed;
  background: rgba(40, 40, 40, 0.8);
  min-width: 100px;
@@ -862,7 +861,7 @@ body.drag .app::after {
  color: rgba(255, 255, 255, 0.8);
 }

-.player .controls .subtitles-list .icon {
+.player .controls .options-list .icon {
  display: inline;
  font-size: 17px;
  vertical-align: bottom;
--- a/renderer/main.js
+++ b/renderer/main.js
--- a/renderer/views/app.js
+++ b/renderer/views/app.js
@@ -4,7 +4,7 @@ var hx = require('../lib/hx')
 var Header = require('./header')

 var Views = {
-  'home': require('./home'),
+  'home': require('./torrent-list'),
  'player': require('./player'),
  'create-torrent': require('./create-torrent'),
  'preferences': require('./preferences')
@@ -12,6 +12,7 @@ var Views = {

 var Modals = {
  'open-torrent-address-modal': require('./open-torrent-address-modal'),
+  'remove-torrent-modal': require('./remove-torrent-modal'),
  'update-available-modal': require('./update-available-modal'),
  'unsupported-media-modal': require('./unsupported-media-modal')
 }
--- a/renderer/views/create-torrent.js
+++ b/renderer/views/create-torrent.js
@@ -65,7 +65,8 @@ function CreateTorrentPage (state) {
        <label>Path:</label>
        <div class='torrent-attribute'>${pathPrefix}</div>
      </p>
-      <div class='expand-collapse ${collapsedClass}' onclick=${handleToggleShowAdvanced}>
+      <div class='expand-collapse ${collapsedClass}'
+           onclick=${dispatcher('toggleCreateTorrentAdvanced')}>
        ${info.showAdvanced ? 'Basic' : 'Advanced'}
      </div>
      <div class="create-torrent-advanced ${collapsedClass}">
@@ -87,7 +88,7 @@ function CreateTorrentPage (state) {
        </p>
      </div>
      <p class="float-right">
-        <button class='button-flat light' onclick=${handleCancel}>Cancel</button>
+        <button class='button-flat light' onclick=${dispatcher('back')}>Cancel</button>
        <button class='button-raised' onclick=${handleOK}>Create Torrent</button>
      </p>
    </div>
@@ -114,17 +115,6 @@ function CreateTorrentPage (state) {
    }
    dispatch('createTorrent', options)
  }
-
-  function handleCancel () {
-    dispatch('back')
-  }
-
-  function handleToggleShowAdvanced () {
-    // TODO: what's the clean way to handle this?
-    // Should every button on every screen have its own dispatch()?
-    info.showAdvanced = !info.showAdvanced
-    dispatch('update')
-  }
 }

 function CreateTorrentErrorPage () {
--- a/renderer/views/open-torrent-address-modal.js
+++ b/renderer/views/open-torrent-address-modal.js
@@ -1,6 +1,6 @@
 module.exports = OpenTorrentAddressModal

-var {dispatch} = require('../lib/dispatcher')
+var {dispatch, dispatcher} = require('../lib/dispatcher')
 var hx = require('../lib/hx')

 function OpenTorrentAddressModal (state) {
@@ -11,8 +11,8 @@ function OpenTorrentAddressModal (state) {
        <input id='add-torrent-url' type='text' onkeypress=${handleKeyPress} />
      </p>
      <p class='float-right'>
-        <button class='button button-flat' onclick=${handleCancel}>CANCEL</button>
-          <button class='button button-raised' onclick=${handleOK}>OK</button>
+        <button class='button button-flat' onclick=${dispatcher('exitModal')}>Cancel</button>
+        <button class='button button-raised' onclick=${handleOK}>OK</button>
      </p>
      <script>document.querySelector('#add-torrent-url').focus()</script>
    </div>
@@ -27,7 +27,3 @@ function handleOK () {
  dispatch('exitModal')
  dispatch('addTorrent', document.querySelector('#add-torrent-url').value)
 }
-
-function handleCancel () {
-  dispatch('exitModal')
-}
--- a/renderer/views/player.js
+++ b/renderer/views/player.js
@@ -43,7 +43,7 @@ function renderMedia (state) {
      mediaElement.play()
    }
    // When the user clicks or drags on the progress bar, jump to that position
-    if (state.playing.jumpToTime) {
+    if (state.playing.jumpToTime != null) {
      mediaElement.currentTime = state.playing.jumpToTime
      state.playing.jumpToTime = null
    }
@@ -73,6 +73,15 @@ function renderMedia (state) {
    var file = state.getPlayingFileSummary()
    file.currentTime = state.playing.currentTime = mediaElement.currentTime
    file.duration = state.playing.duration = mediaElement.duration
+
+    // Save selected subtitle
+    if (state.playing.subtitles.selectedIndex !== -1) {
+      var index = state.playing.subtitles.selectedIndex
+      file.selectedSubtitle = state.playing.subtitles.tracks[index].filePath
+    } else if (file.selectedSubtitle != null) {
+      delete file.selectedSubtitle
+    }
+
    state.playing.volume = mediaElement.volume
  }

@@ -143,6 +152,7 @@ function renderMedia (state) {
    } else if (elem.webkitAudioDecodedByteCount === 0) {
      dispatch('mediaError', 'Audio codec unsupported')
    } else {
+      dispatch('mediaSuccess')
      elem.play()
    }
  }
@@ -279,8 +289,10 @@ function renderCastScreen (state) {
  }

  var isStarting = state.playing.location.endsWith('-pending')
+  var castName = state.playing.castName
  var castStatus
-  if (isCast) castStatus = isStarting ? 'Connecting...' : 'Connected'
+  if (isCast && isStarting) castStatus = 'Connecting to ' + castName + '...'
+  else if (isCast && !isStarting) castStatus = 'Connected to ' + castName
  else castStatus = ''

  // Show a nice title image, if possible
@@ -299,6 +311,30 @@ function renderCastScreen (state) {
  `
 }

+function renderCastOptions (state) {
+  if (!state.devices.castMenu) return
+
+  var {location, devices} = state.devices.castMenu
+  var player = state.devices[location]
+
+  var items = devices.map(function (device, ix) {
+    var isSelected = player.device === device
+    var name = device.name
+    return hx`
+      <li onclick=${dispatcher('selectCastDevice', ix)}>
+        <i.icon>${isSelected ? 'radio_button_checked' : 'radio_button_unchecked'}</i>
+        ${name}
+      </li>
+    `
+  })
+
+  return hx`
+    <ul.options-list>
+      ${items}
+    </ul>
+  `
+}
+
 function renderSubtitlesOptions (state) {
  var subtitles = state.playing.subtitles
  if (!subtitles.tracks.length || !subtitles.showMenu) return
@@ -316,7 +352,7 @@ function renderSubtitlesOptions (state) {
  var noneSelected = state.playing.subtitles.selectedIndex === -1
  var noneClass = 'radio_button_' + (noneSelected ? 'checked' : 'unchecked')
  return hx`
-    <ul.subtitles-list>
+    <ul.options-list>
      ${items}
      <li onclick=${dispatcher('selectSubtitle', -1)}>
        <i.icon>${noneClass}</i>
@@ -378,72 +414,49 @@ function renderPlayerControls (state) {
  }

  // If we've detected a Chromecast or AppleTV, the user can play video there
-  var isOnChromecast = state.playing.location.startsWith('chromecast')
-  var isOnAirplay = state.playing.location.startsWith('airplay')
-  var isOnDlna = state.playing.location.startsWith('dlna')
-  var chromecastClass, chromecastHandler
-  var airplayClass, airplayHandler
-  var dlnaClass, dlnaHandler
-  if (isOnChromecast) {
-    chromecastClass = 'active'
-    dlnaClass = 'disabled'
-    airplayClass = 'disabled'
-    chromecastHandler = dispatcher('closeDevice')
-    airplayHandler = undefined
-    dlnaHandler = undefined
-  } else if (isOnAirplay) {
-    chromecastClass = 'disabled'
-    dlnaClass = 'disabled'
-    airplayClass = 'active'
-    chromecastHandler = undefined
-    airplayHandler = dispatcher('closeDevice')
-    dlnaHandler = undefined
-  } else if (isOnDlna) {
-    chromecastClass = 'disabled'
-    dlnaClass = 'active'
-    airplayClass = 'disabled'
-    chromecastHandler = undefined
-    airplayHandler = undefined
-    dlnaHandler = dispatcher('closeDevice')
-  } else {
-    chromecastClass = ''
-    airplayClass = ''
-    dlnaClass = ''
-    chromecastHandler = dispatcher('openDevice', 'chromecast')
-    airplayHandler = dispatcher('openDevice', 'airplay')
-    dlnaHandler = dispatcher('openDevice', 'dlna')
-  }
-  if (state.devices.chromecast || isOnChromecast) {
-    var castIcon = isOnChromecast ? 'cast_connected' : 'cast'
-    elements.push(hx`
-      <i.icon.device.float-right
-        class=${chromecastClass}
-        onclick=${chromecastHandler}>
-        ${castIcon}
-      </i>
-    `)
-  }
-  if (state.devices.airplay || isOnAirplay) {
-    elements.push(hx`
-      <i.icon.device.float-right
-        class=${airplayClass}
-        onclick=${airplayHandler}>
-        airplay
-      </i>
-    `)
-  }
-  if (state.devices.dlna || isOnDlna) {
-    elements.push(hx`
-      <i
-        class='icon device float-right'
-        class=${dlnaClass}
-        onclick=${dlnaHandler}>
-        tv
-      </i>
-    `)
-  }
+  var castTypes = ['chromecast', 'airplay', 'dlna']
+  var isCastingAnywhere = castTypes.some(
+    (castType) => state.playing.location.startsWith(castType))

-  // render volume
+  // Add the cast buttons. Icons for each cast type, connected/disconnected:
+  var buttonIcons = {
+    'chromecast': {true: 'cast_connected', false: 'cast'},
+    'airplay': {true: 'airplay', false: 'airplay'},
+    'dlna': {true: 'tv', false: 'tv'}
+  }
+  castTypes.forEach(function (castType) {
+    // Do we show this button (eg. the Chromecast button) at all?
+    var isCasting = state.playing.location.startsWith(castType)
+    var player = state.devices[castType]
+    if ((!player || player.getDevices().length === 0) && !isCasting) return
+
+    // Show the button. Three options for eg the Chromecast button:
+    var buttonClass, buttonHandler
+    if (isCasting) {
+      // Option 1: we are currently connected to Chromecast. Button stops the cast.
+      buttonClass = 'active'
+      buttonHandler = dispatcher('stopCasting')
+    } else if (isCastingAnywhere) {
+      // Option 2: we are currently connected somewhere else. Button disabled.
+      buttonClass = 'disabled'
+      buttonHandler = undefined
+    } else {
+      // Option 3: we are not connected anywhere. Button opens Chromecast menu.
+      buttonClass = ''
+      buttonHandler = dispatcher('toggleCastMenu', castType)
+    }
+    var buttonIcon = buttonIcons[castType][isCasting]
+
+    elements.push(hx`
+      <i.icon.device.float-right
+        class=${buttonClass}
+        onclick=${buttonHandler}>
+        ${buttonIcon}
+      </i>
+    `)
+  })
+
+  // Render volume slider
  var volume = state.playing.volume
  var volumeIcon = 'volume_' + (
    volume === 0 ? 'off'
@@ -496,6 +509,7 @@ function renderPlayerControls (state) {
  return hx`
    <div class='controls'>
      ${elements}
+      ${renderCastOptions(state)}
      ${renderSubtitlesOptions(state)}
    </div>
  `
@@ -510,11 +524,12 @@ function renderPlayerControls (state) {

  // Handles a click or drag to scrub (jump to another position in the video)
  function handleScrub (e) {
+    if (!e.clientX) return
    dispatch('mediaMouseMoved')
    var windowWidth = document.querySelector('body').clientWidth
    var fraction = e.clientX / windowWidth
    var position = fraction * state.playing.duration /* seconds */
-    dispatch('playbackJump', position)
+    dispatch('skipTo', position)
  }

  // Handles volume muting and Unmuting
--- a/renderer/views/remove-torrent-modal.js
+++ b/renderer/views/remove-torrent-modal.js
@@ -0,0 +1,26 @@
+module.exports = RemoveTorrentModal
+
+var {dispatch, dispatcher} = require('../lib/dispatcher')
+var hx = require('../lib/hx')
+
+function RemoveTorrentModal (state) {
+  var message = state.modal.deleteData
+    ? 'Are you sure you want to remove this torrent from the list and delete the data file?'
+    : 'Are you sure you want to remove this torrent from the list?'
+  var buttonText = state.modal.deleteData ? 'Remove Data' : 'Remove'
+
+  return hx`
+    <div>
+      <p><strong>${message}</strong></p>
+      <p class='float-right'>
+        <button class='button button-flat' onclick=${dispatcher('exitModal')}>Cancel</button>
+        <button class='button button-raised' onclick=${handleRemove}>${buttonText}</button>
+      </p>
+    </div>
+  `
+
+  function handleRemove () {
+    dispatch('deleteTorrent', state.modal.infoHash, state.modal.deleteData)
+    dispatch('exitModal')
+  }
+}
--- a/renderer/views/torrent-list.js
+++ b/renderer/views/torrent-list.js
@@ -148,12 +148,12 @@ function TorrentList (state) {

    // Only show the play button for torrents that contain playable media
    var playButton
-    if (TorrentPlayer.isPlayableTorrent(torrentSummary)) {
+    if (TorrentPlayer.isPlayableTorrentSummary(torrentSummary)) {
      playButton = hx`
        <i.button-round.icon.play
          title=${playTooltip}
          class=${playClass}
-          onclick=${dispatcher('play', infoHash)}>
+          onclick=${dispatcher('playFile', infoHash)}>
          ${playIcon}
        </i>
      `
@@ -172,7 +172,7 @@ function TorrentList (state) {
        <i
          class='icon delete'
          title='Remove torrent'
-          onclick=${dispatcher('deleteTorrent', infoHash)}>
+          onclick=${dispatcher('confirmDeleteTorrent', infoHash, false)}>
          close
        </i>
      </div>
@@ -242,7 +242,7 @@ function TorrentList (state) {
    var handleClick
    if (isPlayable) {
      icon = 'play_arrow' /* playable? add option to play */
-      handleClick = dispatcher('play', infoHash, index)
+      handleClick = dispatcher('playFile', infoHash, index)
    } else {
      icon = 'description' /* file icon, opens in OS default app */
      handleClick = dispatcher('openItem', infoHash, index)
--- a/renderer/views/update-available-modal.js
+++ b/renderer/views/update-available-modal.js
@@ -10,9 +10,9 @@ function UpdateAvailableModal (state) {
    <div class='update-available-modal'>
      <p><strong>A new version of WebTorrent is available: v${state.modal.version}</strong></p>
      <p>We have an auto-updater for Windows and Mac. We don't have one for Linux yet, so you'll have to download the new version manually.</p>
-      <p>
-        <button class='primary' onclick=${handleOK}>Show Download Page</button>
-        <button class='cancel' onclick=${handleCancel}>Skip This Release</button>
+      <p class='float-right'>
+        <button class='button button-flat' onclick=${handleCancel}>Skip This Release</button>
+        <button class='button button-raised' onclick=${handleOK}>Show Download Page</button>
      </p>
    </div>
  `
--- a/renderer/webtorrent.js
+++ b/renderer/webtorrent.js
@@ -63,6 +63,10 @@ function init () {

  ipc.send('ipcReadyWebTorrent')

+  window.addEventListener('error', (e) =>
+    ipc.send('wt-uncaught-error', {message: e.error.message, stack: e.error.stack}),
+    true)
+
  setInterval(updateTorrentProgress, 1000)
 }

--- a/static/PauseThumbnailBarButton.png
+++ b/static/PauseThumbnailBarButton.png
--- a/static/PlayThumbnailBarButton.png
+++ b/static/PlayThumbnailBarButton.png
--- a/static/linux/webtorrent-desktop.desktop
+++ b/static/linux/webtorrent-desktop.desktop
@@ -13,7 +13,7 @@ Exec=$EXEC_PATH %U
 TryExec=$TRY_EXEC_PATH
 StartupNotify=false
 Categories=Network;FileTransfer;P2P;
-MimeType=application/x-bittorrent;x-scheme-handler/magnet;
+MimeType=application/x-bittorrent;x-scheme-handler/magnet;x-scheme-handler/stream-magnet;

 Actions=CreateNewTorrent;OpenTorrentFile;OpenTorrentAddress;
Author	SHA1	Message	Date
DC	3cfdf857cf	Fix scrubbing bug: don't skip to 0s after drag	2016-07-21 01:09:43 -07:00
DC	c59abb251b	Fix play/pause toggle bug Sometimes, while casting, WT thinks the video isn't visible and the play/pause toggle stops working	2016-07-21 01:03:45 -07:00
DC	2fc1034cc5	changelog	2016-07-21 00:17:00 -07:00
DC	a8fd60f46e	authors	2016-07-20 23:47:32 -07:00
DC	0cbae6b4d5	0.9.0	2016-07-20 23:18:23 -07:00
DC	d0733d3370	Fix bug in PlaybackController	2016-07-17 17:34:58 -07:00
DC	7b8751312a	Refactor main.js: torrent controller	2016-07-17 15:52:09 -07:00
DC	6d664f2086	Refactor main.js: TorrentPlayer.isTorrent	2016-07-17 15:52:09 -07:00
Mathias Rasmussen	4ebf7e25b7	fix showItemInFolder (#723 )	2016-07-17 15:51:50 -07:00
Mathias Rasmussen	54e70e7158	Remove torrent/data confirmation modal	2016-07-16 14:33:01 -07:00
DC	b950829de3	TorrentSummary.getFileOrFolder	2016-07-16 12:09:49 -07:00
Mathias Rasmussen	a489397f84	remove torrent data (single file / folder)	2016-07-16 12:09:49 -07:00
DC	897dac354d	onError -> error (#716 )	2016-07-16 12:08:42 -07:00
Mathias Rasmussen	beb4af1311	Remove torrent file and poster (#711 ) * remove torrent file and poster * Delete file instead of moving to trash	2016-07-14 15:41:05 -07:00
Mathias Rasmussen	f0aeab0207	Fix unhandled 'error' dispatch (#708 ) * fix 'error' dispatch * directly call functions defined in main	2016-07-14 14:04:25 -07:00
Mathias Rasmussen	be1314422d	Improve error logging (#707 ) e.g. undefined <video> errors	2016-07-14 14:01:58 -07:00
Mathias Rasmussen	c15711aae8	Save selected subtitle (#702 )	2016-07-08 18:26:30 -07:00
DC	1668c4c614	Refactor main.js: fix Create Torrent modal	2016-07-08 11:58:15 -07:00
DC	7050ee849b	Refactor main.js: fix state save on exit	2016-07-08 11:58:15 -07:00
DC	dfe1e3b631	Fix Cast lazy loading Move all the heavy initialization, which takes ~300ms, from require('./lib/cast') to Cast.init()	2016-07-08 11:58:15 -07:00
Adam Gotlib	50c47dd657	Refactor main.js: controllers.playback.skip() (#706 ) * Fixes bug with Step Forward/Backward commands not working * Fix 'invalid torrent identifier' error	2016-07-08 11:58:15 -07:00
DC	a373141a93	Refactor main.js: replace dispatch() if-else with hash	2016-07-08 11:58:15 -07:00
DC	24f5856649	Refactor main.js: playback and subtitles controllers	2016-07-08 11:58:15 -07:00
DC	f85e0a61b1	Refactor main.js: torrent list controller	2016-07-08 11:58:15 -07:00
DC	4319ef2853	Refactor main.js: prefs controller	2016-07-08 11:58:15 -07:00
DC	c3a27dbebe	Refactor main.js: media and update controllers	2016-07-08 11:58:15 -07:00
DC	bac43509d2	Refactoring main.js: simplify startup	2016-07-08 11:58:15 -07:00
DC	59b012e527	Fix README	2016-07-08 11:58:15 -07:00
Rémi Jouannet	c615e285db	add debian jessie dependencies (#601 ) * add debian jessie dependencies * update dep for deb package * gconf2, libgtk2.0-0, libnss3, libxss1	2016-07-05 19:54:59 -03:00
DC	1aca9fe753	Only send telemetry from production (#668 )	2016-07-04 00:37:57 -07:00
Feross Aboukhadijeh	349c5ee22e	Clean up thumbar (thumbnail) code (#670 ) * Cleanup thumbnail bar code - rename thumbnail method names for succinctness - Get rid of 'updateThumbnailBar' event -- use existing events - Get rid of 'blockPowerSave' and 'unblockPowerSave' events -- use a new combined 'onPlayerPlay' and 'onPlayerPause' events which apply to power save and updating the thumbbar * Consistent naming for enable/disable methods	2016-06-28 06:32:28 -07:00
Adam Gotlib	c44943cef7	Fix state.playing.jumpToTime behavior (#672 ) Previously, state.playing.jumpToTime = 0 didn't do anything. This commit fixes that.	2016-06-28 06:25:26 -07:00
DC	7a61b52d64	changelog	2016-06-27 02:42:04 -07:00
DC	e5df96c82e	authors	2016-06-27 02:39:53 -07:00
DC	770327c3fa	0.8.1	2016-06-27 02:38:45 -07:00
Adam Gotlib	4bdc6e3d65	Fix typo in renderer/views/player.js (#673 )	2016-06-27 00:28:19 -07:00
Feross Aboukhadijeh	4799a032e5	Fixes for PR #640	2016-06-23 18:57:08 -07:00
Feross Aboukhadijeh	b2d2a6a7a5	Merge pull request #640 from anonymlol/master new protocol handler: stream-magnet	2016-06-23 18:37:53 -07:00
DC	7676106914	changelog	2016-06-23 07:45:02 -07:00
DC	fe5ea31f2c	authors	2016-06-23 07:32:28 -07:00
DC	e34223fc94	0.8.0	2016-06-23 07:31:18 -07:00
Gediminas Petrikas	15f733f11c	Windows Thumbnail Bar * While in the player view, show a play/pause toggle in the thumbnail	2016-06-23 07:12:32 -07:00
DC	7526b18507	Show which cast device you're connected to	2016-06-23 07:09:49 -07:00
DC	0af6007632	Refactor cast menu	2016-06-23 07:09:49 -07:00
DC	1bc3cd1d51	Make check-deps handle older verions of node	2016-06-23 07:09:49 -07:00
DC	92bafd695d	Listen to events on new cast devices	2016-06-23 07:09:49 -07:00
DC	78a2ee4e85	Cast menu Fixes #301	2016-06-23 07:09:49 -07:00
Feross Aboukhadijeh	8b9346d767	Prevent playback continues after minimize (#662 ) Fixes #649.	2016-06-23 06:59:55 -07:00
DC	06d3bd3f93	Seeding: sort files by path (#663 ) Fixes a bug where you could create duplicate torrents by adding the same folder multiple times, because the file order & therefore the infohash was nondeterministic	2016-06-23 02:14:23 -07:00
Mathias Rasmussen	1af7e4ef19	Remove torrent data support (#641 ) * add moveItemToTrash to shell * delete torrent/data + context menu items	2016-06-22 18:58:16 -07:00
DC	8e64e4120b	Telemetry: add Privacy section to README	2016-06-21 21:58:15 -07:00
DC	b983559763	Telemetry: address PR comments	2016-06-21 21:58:15 -07:00
DC	e62527de23	Telemetry: limit POST to 100kb	2016-06-21 04:20:12 -07:00
DC	1f51f35f8e	Telemetry: report uncaught errors	2016-06-21 03:45:34 -07:00
DC	c3686417e3	Telemetry	2016-06-20 22:33:17 -07:00
Feross Aboukhadijeh	746e10c025	author email	2016-06-15 17:41:04 -07:00
Feross Aboukhadijeh	98389fc07c	Merge pull request #644 from feross/dc/ux Support .wmv video via VLC	2016-06-15 16:35:12 -07:00
DC	aaebf93db4	Support .wmv video via VLC. Fixes #625	2016-06-15 16:22:16 -07:00
anonymlol	8f03ecedaa	fix 'isMagnet' is already defined error	2016-06-14 13:53:01 +02:00
anonymlol	db20bd8eaf	New Handler: stream-magnet only tested on windows	2016-06-14 13:30:38 +02:00
Feross Aboukhadijeh	12500dfb64	modals should stick to title bar	2016-06-13 16:15:45 -07:00
Feross Aboukhadijeh	acc8e7923a	Update modal: improve buttons	2016-06-13 16:15:01 -07:00
Feross Aboukhadijeh	9aa5775528	Merge pull request #636 from mathiasvr/modals fix modal inconsistencies	2016-06-13 16:08:05 -07:00
Mathias Rasmussen	2a2d71289a	fix modal inconsistencies	2016-06-13 16:18:43 +02:00
Feross Aboukhadijeh	ae28e34fd5	Merge pull request #634 from feross/dc/fix Make posters from jpeg files	2016-06-11 23:31:20 -07:00
DC	6b175e7d40	Make posters from jpeg files	2016-06-11 23:10:48 -07:00
Feross Aboukhadijeh	2c6d74e8ef	Merge pull request #632 from mathiasvr/patch handle play/pause when window is hidden	2016-06-10 20:23:58 -07:00
Mathias Rasmussen	3b832595fe	handle play/pause when window is hidden using `webkitvisibilitychange` event	2016-06-10 04:56:33 +02:00
Feross Aboukhadijeh	bf372029fb	changelog	2016-06-03 15:10:11 -07:00
Feross Aboukhadijeh	17ce7e519c	Merge pull request #623 from feross/tray Fix Windows tray state	2016-06-02 23:24:33 -07:00
Feross Aboukhadijeh	1f6a112df7	changelog	2016-06-02 23:14:37 -07:00
Feross Aboukhadijeh	0ec6fb5a93	Fix Windows tray state After this PR, the Windows tray state will be correct. "Show WebTorrent" vs. "Hide WebTorrent"	2016-06-02 21:16:10 -07:00