def afterComplete(self, download_item):
start_thread = False
if download_item.after_complete == 1: #play option
Thread(target=main.play, args=(download_item.dest_file, os.path.split(download_item.dest_file)[1],
self.settings.media_player)).start()
elif download_item.after_complete == 2: #convert to Ogg Vorbis
self.convert_thread = Convert(main.convert, download_item.dest_file)
start_thread = True
elif download_item.after_complete == 3: #convert to Ogg Theora
self.convert_thread = Convert(main.convert, download_item.dest_file, audio_only=False)
start_thread = True
elif download_item.after_complete == 4: #rip audio option
self.convert_thread = Convert(main.rip, download_item.dest_file)
start_thread = True
if start_thread:
self.convert_thread.start()
self.convert_timer.start(750)
class Gui(QtGui.QMainWindow):
"""WatchVideo's main class."""
#gotVideo = Signal(tuple)
def __init__(self, app=None, options=None, args=None):
"""Initialize the GUI and many variables and load the configuration."""
super(Gui, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.playlistWidget.hide()
self.app = app
# Load settings
self.settings = Settings()
self.download_urls = {}
self.download_folder = c.HOME_FOLDER
self.convert_thread = None
self.active_download_items = []
self.downloads_trash = []
self.match_url = None
self.action = ""
self.namelabel = None
self.menu_active = None
self.show_confirm_dialog = True
self.active_tree_widget = None
self.ignoreMovement = 0
self.quality_options = ["custom", "ask", "low", "high"]
#the user can use different temporary quality
self.global_quality = self.settings.global_quality
self.clipboard = QtGui.QApplication.clipboard()
self.visited_urls = []
self.searchIconSize = QSize(0, 0)
#create actions for downloads, search and player's right click menu
self.start = QAction(QIcon(c.PATH_MEDIA + "start.png"), self.tr("Start"), self)
self.stop = QAction(QIcon(c.PATH_MEDIA + "stop.png"), self.tr("Stop"), self)
self.remove = QAction(QIcon(c.ICON_REMOVE), self.tr("Remove"), self)
self.remove_delete = QAction(QIcon(c.ICON_DELETE), self.tr("Remove and delete file"), self)
self.opendir = QAction(QIcon(c.ICON_OPEN_FOLDER), self.tr("Open Folder"), self)
self.copyurl = QAction(QIcon(c.ICON_COPY), self.tr("Copy original URL"), self)
self.a_play_local = QAction(self.tr("Play local file"), self)
self.a_download = QAction(QIcon(c.ICON_DOWNLOAD), self.tr("Download"), self)
if HAS_PLAYER and c.HAS_FFMPEG:
self.player = Player(self)
#self.ui.horizontalLayout.addWidget(self.player.slider)
self.ui.videoWidget.installEventFilter(self)
self.ui.playlistWidget.installEventFilter(self)
self.videoWidgetParent = self.ui.videoWidget.parentWidget()
#player's right click menu
self.ui.videoWidget.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.menu_player = QMenu(self)
self.menu_player.addAction(self.copyurl)
self.menu_player.addAction(self.a_download)
self.ui.videoWidget.customContextMenuRequested.connect(self.showPlayerRightClickMenu)
self.ui.nameLabel.setTextInteractionFlags(QtCore.Qt.TextSelectableByMouse)
#repeat button
self.disabled_replay_icon = gui_utils.getGreyedIcon(c.ICON_REPEAT)
self.enabled_replay_icon = QIcon(c.ICON_REPEAT)
self.ui.btn_replay.setFlat(True)
self.onReplayClicked(next=False)#update button's icon
else:
self.ui.tab_widget.removeTab(0)
self.player = None
#cancel button
self.b_cancelSearch = QPushButton("Cancel", self.ui.statusbar)
self.b_cancelSearch.clicked.connect(self.cancelSearch)
self.b_cancelSearch.hide()
#quality button
self.btn_quality = QPushButton(self.ui.statusbar)
self.btn_quality.setFlat(True)
self.ui.statusbar.addPermanentWidget(self.btn_quality)
self.switchQuality(next=False)
#create tray icon
self.trayicon = QSystemTrayIcon(QIcon(c.ICON_WATCHVIDEO), self.app)
self.trayicon.show()
self.notification = Notification(self.trayicon, self.settings)
self.dialogs = {
'about': None, # The instance of the "About..." window will be stored here
'preferences': None, # The instance of the "Preferences" window will be stored here
'add_videos': None,
}
if c.FIREFOX_SESSION is None:
self.ui.a_searchBrowser.setDisabled(True)
self.ui.tree_downloads.setColumnCount(5)
self.ui.tree_downloads.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.menu = QMenu(self)
#Timers
self.timer_check_downloads = QTimer(self)
self.timer_check_downloads.timeout.connect(self.updateDownloads)
self.convert_timer = QTimer(self)
self.convert_timer.timeout.connect(self.isConversionDone)
self.timer_match_urls = QTimer(self)
self.timer_match_urls.timeout.connect(self.isCheckingDone)
self.close_timer = QTimer(self)
self.close_timer.timeout.connect(self.close_window)
self.close_timer.setSingleShot(True)
#stuff related to the search
self.search = None
self.ui.searchLine.addResultsWidget(self.ui.resultsWidget)
self.ui.resultsWidget.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.ui.searchLine.setFocus(QtCore.Qt.MouseFocusReason)
self.ui.dockWidget.addAction(self.ui.a_viewSearch)
self.abort_search_timer = QTimer(self)
self.abort_search_timer.timeout.connect(self.searchYoutube)
self.abort_search_timer.setSingleShot(True)
#add actions to the search's right click menu
self.search_menu = QMenu(self)
self.search_menu.addAction(self.copyurl)
self.search_menu.addAction(self.a_download)
#add actions to the download's right click menu
self.menu.addAction(self.start)
self.menu.addAction(self.stop)
self.menu.addSeparator()
self.menu.addAction(self.remove)
self.menu.addAction(self.remove_delete)
self.menu.addSeparator()
self.menu.addAction(self.opendir)
self.menu.addAction(self.copyurl)
self.menu.addAction(self.a_play_local)
# connect signals with slots
self.ui.a_addVideos.triggered.connect(self.showAddVideos)
self.ui.a_searchBrowser.triggered.connect(self.searchBrowser)
self.ui.a_clearCompleted.triggered.connect(self.clearCompleted)
self.ui.a_preferences.triggered.connect(self.showPreferences)
self.ui.a_about.triggered.connect(self.showAbout)
self.ui.a_quit.triggered.connect(self.close)
self.ui.a_clipboard.triggered.connect(self.addFromClipboard)
self.ui.a_clipboard.hovered.connect(self.showStatusMessage)
self.ui.a_play.triggered.connect(self.addFromClipboard)
self.ui.a_play.hovered.connect(self.showStatusMessage)
self.ui.a_download.triggered.connect(self.addFromClipboard)
self.ui.a_download.hovered.connect(self.showStatusMessage)
self.copyurl.triggered.connect(self.copyOriginalUrl)
self.ui.tree_downloads.customContextMenuRequested.connect(self.showRightClickMenu)
self.ui.tree_downloads.itemDoubleClicked.connect(self.onDownloadDoubleClick)
self.start.triggered.connect(self.startDownloads)
self.stop.triggered.connect(self.stopDownloads)
self.remove.triggered.connect(self.removeTriggered)
self.remove_delete.triggered.connect(self.removeAndDelete)
self.opendir.triggered.connect(self.openDir)
self.trayicon.activated.connect(self.openWindow)
self.a_play_local.triggered.connect(self.play)
self.clipboard.dataChanged.connect(self.clipboardDataChanged)
self.ui.btn_replay.clicked.connect(self.onReplayClicked)
self.btn_quality.clicked.connect(self.switchQuality)
#search related signals
self.ui.searchLine.returnPressed.connect(self.searchYoutube)
self.ui.b_search.pressed.connect(self.searchYoutube)
self.ui.resultsWidget.itemDoubleClicked.connect(self.onSearchDoubleClick)
self.a_download.triggered.connect(self.onDownloadActionPressed)
self.ui.resultsWidget.customContextMenuRequested.connect(self.showResultsRightClickMenu)
self.ui.a_viewSearch.toggled.connect(lambda state: self.ui.dockWidget.setVisible(state))
self.loadWindow() #loads window geometry, widgets' size, etc
if len(args) > 0:
if options.down:
self.action = "download"
self.getFilesUrl(args)
elif options.more:
self.action = "clipboard"
self.getFilesUrl(args)
else:
self.action = "play"
self.getFilesUrl(args)
def clipboardDataChanged(self):
if not self.settings.check_links_auto: return
if "http" in self.clipboard.text():
text = self.clipboard.text().split()
text = [ url for url in text if url not in self.visited_urls and "http://" in url ]
if text:
self.action = "clipboard-auto"
self.getFilesUrl(text)
def showPlayerRightClickMenu(self):
if self.player and self.player.download:
self.menu_active = "player"
point = QtGui.QCursor.pos()
self.menu_player.exec_(point)
def onDownloadActionPressed(self):
"""Used by the player and search"""
if self.menu_active == "player":
download_item = self.player.getDownloadItem()
name = os.path.split(download_item.dest_file)[1]
download_item.copyAfterComplete(self.settings.download_folder, name)
tree_item = TreeWidgetItem([name, "-", "", "0", "00:00:00"],
download_item)
#insert QProgressBar
self.ui.tree_downloads.addTopLevelItem(tree_item)
self.ui.tree_downloads.setItemWidget(tree_item, 2, QProgressBar(self.ui.tree_downloads))
self.active_download_items.append(tree_item)
if not self.timer_check_downloads.isActive():
self.timer_check_downloads.start(1000)
else:
urls = [ item.getOriginalUrl() for item in self.ui.resultsWidget.selectedItems()]
self.action = "download"
self.getFilesUrl(urls)
def onSearchDoubleClick(self, item, pos):
"""On double click play the video - ToDo: Add option in preferences"""
last_index = self.ui.resultsWidget.topLevelItemCount() - 1
if not self.search.isRunning() and self.ui.resultsWidget.indexOfTopLevelItem(item) == last_index:
self.ui.resultsWidget.takeTopLevelItem(last_index)
self.searchYoutube(False)
return
self.action = "play"
self.getFilesUrl([item.getOriginalUrl()])
def searchYoutube(self, clear_previous_search=True):
if self.ui.searchLine.isEmpty():
return
if self.search and self.search.isRunning():
self.search.abort()
self.abort_search_timer.start(1000)
return
if clear_previous_search:
for i in xrange(self.ui.resultsWidget.topLevelItemCount()-1, -1, -1):
self.ui.resultsWidget.takeTopLevelItem(i)
start_pos = self.ui.resultsWidget.topLevelItemCount() + 1
self.search = Search(self, start_pos)
self.search.start()
def addResult(self, item):
image = item[0]
if image:
if image != QImage(c.ICON_ADD) and (image.width() > self.searchIconSize.width() and
image.height() > self.searchIconSize.height()):
self.searchIconSize = QSize(image.width(), image.height())
self.ui.resultsWidget.setIconSize(QSize(image.width(),image.height()))
#image = gui_utils.setTextOnImage(image, "")
item[1].setIcon(0, QIcon(QPixmap.fromImage(image)))
self.ui.resultsWidget.addTopLevelItem(item[1])
def onReplayClicked(self, checked=False, next=True):
if next:
i = self.player.repeat_modes.index(self.player.repeat)
if i == len(self.player.repeat_modes) - 1:
i = 0
else:
i += 1
self.player.repeat = self.player.repeat_modes[i]
if self.player.repeat == "none":
self.ui.btn_replay.setIcon(self.disabled_replay_icon)
self.ui.btn_replay.setToolTip(self.tr("Don't repeat"))
elif self.player.repeat == "one":
self.ui.btn_replay.setIcon(self.enabled_replay_icon)
self.ui.btn_replay.setToolTip(self.tr("Repeat track"))
else:
self.ui.btn_replay.setIcon(QIcon(c.ICON_PLAYLIST_REPEAT))
self.ui.btn_replay.setToolTip(self.tr("Repeat playlist"))
def switchQuality(self, checked=False, next=True):
if next: #when clicking in the button
quality_options = self.quality_options
if self.settings.global_video_quality: #remove the "custom" key
quality_options = quality_options[1:]
try:
i = quality_options.index(self.global_quality)
if i == len(quality_options) - 1: i = 0
else: i += 1
except ValueError:
i = 0
option = quality_options[i]
else:
option = self.global_quality = self.settings.global_quality
if option == "ask":
icon = QIcon(c.ICON_ASK_QUALITY)
msg = self.tr("A dialog to choose the format will appear for all videos with more than one format available.")
img = "<img src='%s'><br></br>" % c.ICON_ASK_QUALITY
elif option == "low":
icon = QIcon(c.ICON_LOW_QUALITY)
msg = self.tr("All videos are played/downloaded in the lowest quality available.")
img = "<img src='%s'><br></br>" % c.ICON_LOW_QUALITY
elif option == "high":
icon = QIcon(c.ICON_HIGH_QUALITY)
msg = self.tr("All videos are played/downloaded in the highest quality available.")
img = "<img src='%s'><br></br>" % c.ICON_HIGH_QUALITY
else:
icon = QIcon(c.ICON_CUSTOM_QUALITY)
msg = self.tr("The videos are played/downloaded according to what " + \
"was defined in preferences. If it's the first time accessing a particular " + \
"website through WatchVideo, the default action will be to ask for the quality.")
img = "<img src='%s'><br></br>" % c.ICON_CUSTOM_QUALITY
self.global_quality = img.split(":/media/")[1].split("-")[0]
self.btn_quality.setToolTip(img+msg)
self.btn_quality.setIcon(icon)
def onDownloadDoubleClick(self, item, pos):
#Open the folder containing the video or play it.
download = item.getDownload()
if not self.settings.play_downloaded:
self.playDownload(download)
else:
self.openDir(os.path.split(download.dest_file)[0])
def playDownload(self, download):
if os.path.exists(download.dest_file):
filename = os.path.split(download.dest_file)[1]
Thread(target=main.play, args=(download.dest_file, filename,
self.settings.media_player)).start()
def startDownloads(self):
if self.active_tree_widget is None: return
for item in self.active_tree_widget.selectedItems():
download = item.getDownload().resume()
def stopDownloads(self):
if self.active_tree_widget is None: return
for item in self.active_tree_widget.selectedItems():
download = item.getDownload()
download.stop()
item.setText(3, "Paused")
item.setText(4, "Paused")
def removeTriggered(self):
downloads_removed = []
if self.active_tree_widget is None: return
answer = None
for item in self.active_tree_widget.selectedItems():
download = item.getDownload()
if answer is None:
if not download.isActive():
answer = QtGui.QMessageBox.Yes
else:
answer = gui_utils.confirm(self, "Abort Download(s)", self.tr("This will abort the download(s) too, are you sure?"))
if answer == QtGui.QMessageBox.No: return
if "playlist" in self.active_tree_widget.objectName():
if download == self.player.download:
self.player.stop()
if item in self.player.treeWidgetItems:
self.player.treeWidgetItems.remove(item)
if download.isActive():
download.abort()
self.downloads_trash.append(download)
#remove the item
self.removeDownloadItem(item)
downloads_removed.append(download)
if ( "downloads" in self.active_tree_widget.objectName()
and self.active_tree_widget.topLevelItemCount() == 0 ):
self.ui.a_clearCompleted.setDisabled(True)
return downloads_removed
def removeAndDelete(self):
downloads_removed = self.removeTriggered()
for download in downloads_removed:
os.remove(download.dest_file)
def showResultsRightClickMenu(self, point):
if self.ui.resultsWidget.selectedItems():
self.menu_active = "search"
point = QtGui.QCursor.pos()
self.search_menu.exec_(point)
def showRightClickMenu(self, point):
if self.ui.tree_downloads.selectedItems():
self.active_tree_widget = self.ui.tree_downloads
paused_found = False
active_found = False
completed_found = False
self.menu_active = "download"
for item in self.ui.tree_downloads.selectedItems():
download = item.getDownload()
if download.isStopped():
paused_found = True
elif download.completed:
completed_found = True
else:
active_found = True
if completed_found:
self.a_play_local.setEnabled(True)
else:
self.a_play_local.setEnabled(False)
if active_found: #if an active download is found
if not self.stop.isEnabled(): self.stop.setEnabled(True)
else:
if self.stop.isEnabled(): self.stop.setEnabled(False)
if paused_found: #if a paused download is found
if not self.start.isEnabled(): self.start.setEnabled(True)
else:
if self.start.isEnabled(): self.start.setEnabled(False)
point = QtGui.QCursor.pos()
self.menu.exec_(point)
def addNewDownloads(self, videos):
self.action = ""
if not videos: return
if videos[0].down: #download
self.ui.tab_widget.setCurrentIndex(1)
for video in videos:
if len(video.name) * 7 > self.ui.tree_downloads.header().sectionSize(0):
self.ui.tree_downloads.header().resizeSection(0, len(video.name)*7)
download_item = DownloadItem(video.url, video.dl_url, video.filepath, video.after_complete, self)
item = TreeWidgetItem([video.name, "-", "", "0", "00:00:00"], download_item)
#insert QProgressBar
self.ui.tree_downloads.addTopLevelItem(item)
self.ui.tree_downloads.setItemWidget(item, 2, QProgressBar(self.ui.tree_downloads))
download_item.start()
self.active_download_items.append(item)
if not self.timer_check_downloads.isActive():
self.timer_check_downloads.start(750)
else: #Play
self.ui.tab_widget.setCurrentIndex(0)
if self.settings.use_builtin_player:
for video in videos:
item = DownloadItem(video.url, video.dl_url, video.filepath, video.after_complete, self)
self.player.loadfile(video.filepath, item)
else:
#names = [video.name for video in videos]
#urls = [video.dl_url for video in videos]
for video in videos:
Thread(target=main.play, args=(video.dl_url, video.name,
self.settings.media_player)).start()
time.sleep(2)
def afterComplete(self, download_item):
start_thread = False
if download_item.after_complete == 1: #play option
Thread(target=main.play, args=(download_item.dest_file, os.path.split(download_item.dest_file)[1],
self.settings.media_player)).start()
elif download_item.after_complete == 2: #convert to Ogg Vorbis
self.convert_thread = Convert(main.convert, download_item.dest_file)
start_thread = True
elif download_item.after_complete == 3: #convert to Ogg Theora
self.convert_thread = Convert(main.convert, download_item.dest_file, audio_only=False)
start_thread = True
elif download_item.after_complete == 4: #rip audio option
self.convert_thread = Convert(main.rip, download_item.dest_file)
start_thread = True
if start_thread:
self.convert_thread.start()
self.convert_timer.start(750)
def isConversionDone(self):
if self.convert_thread.type == "rip":
message_waiting = self.tr("Ripping audio of") + " " + self.convert_thread.filename
title_done = self.tr("Audio Ripped")
title_error = self.tr("Error ripping audio")
else:
message_waiting = self.tr("Converting video:") + " " + self.convert_thread.filename
title_done = self.tr("Video Converted")
title_error = self.tr("Error converting video")
if self.convert_thread.isDone():
self.convert_timer.stop()
if self.convert_thread.successful:
if self.settings.notify_done:
self.notification.show(title_done, self.convert_thread.filename)
self.ui.statusbar.showMessage(title_done + ": " + self.convert_thread.filename)
else:
self.notification.show(title_error, self.convert_thread.filename)
self.ui.statusbar.showMessage(title_error + ": " + self.convert_thread.filename)
if self.settings.notify_error:
self.notification.show(title_error, self.convert_thread.filename)
self.convert_thread = None
else:
self.ui.statusbar.showMessage(message_waiting)
def searchBrowser(self):
session = json.loads(open(c.FIREFOX_SESSION).read().strip("()"))
urls = []
#search windows and tabs open in firefox
for window in session["windows"]:
for tab in window["tabs"]:
for entry in tab["entries"]:
try:
urls.append(entry["url"])
except IndexError:
pass
self.getFilesUrl(urls, fast=True)
def getFilesUrl(self, urls, fast=False):
if self.match_url: return
urls = [url for url in urls if "http" in url and len(url) > len("http")]
if urls:
print urls
#add cancel button
self.b_cancelSearch.show()
self.ui.statusbar.insertPermanentWidget(0, self.b_cancelSearch)
self.cleanStatusTip()
if "clipboard" in self.action:
quality = "ask"
else:
quality = self.global_quality
self.match_url = main.Match(urls, quality, fast=False) #start a check thread
Thread(target=self.match_url.match, args=()).start()
self.timer_match_urls.start(750)
else:
self.ui.statusbar.showMessage(self.tr("No valid URLs found."))
def isCheckingDone(self):
"""Called in intervals of 750ms to see if the url thread is ready"""
if self.match_url.done:
self.timer_match_urls.stop()
mediums = self.match_url.mediums
ready_mediums = self.match_url.ready_mediums
#a new website might have been added to the settings file
#through ConfigParser, so we need to sync the QSettings instance with
#the settings' file
if self.match_url.update_settings: self.settings.sync()
self.match_url = None
self.resetStatusBar()
if not mediums and not ready_mediums:
self.ui.statusbar.showMessage(self.tr("No supported services were found"))
self.b_cancelSearch.setText(self.tr("Close"))
return
#append mediums' urls to the visited urls
for medium in mediums.keys() + ready_mediums.keys():
self.visited_urls.append(medium.url)
if self.action == "clipboard-auto":
for medium in mediums:
self.notification.show("WatchVideo", medium.title)
self.action = "clipboard"
if "clipboard" in self.action:
for medium in ready_mediums:
mediums[medium] = [ready_mediums[medium]]
ready_mediums = None
if mediums:
if "clipboard" in self.action:
self.showAddVideos(mediums)
else:
self.showAddVideos(mediums, format_mode=True)
if ready_mediums:
self.processVideos(ready_mediums)
elif self.match_url.url: #if the url is valid, show it
self.ui.statusbar.showMessage(self.tr("Currently checking: ") + self.match_url.url)
def clearCompleted(self):
for i in xrange(self.ui.tree_downloads.topLevelItemCount()-1, -1, -1):
item = self.ui.tree_downloads.topLevelItem(i)
download = item.getDownload()
if download.completed:
self.ui.tree_downloads.takeTopLevelItem(i)
self.ui.a_clearCompleted.setDisabled(True)
def updateDownloads(self):
if not self.active_download_items:
if self.timer_check_downloads.isActive():
self.timer_check_downloads.stop()
return
for download in self.downloads_trash:
if download.aborted: self.downloads_trash.remove(download)
for download_item in self.active_download_items:
download = download_item.getDownload()
if download.isStopped(): continue
progressBar = self.ui.tree_downloads.itemWidget(download_item, 2)
total_size = download.size
unit = download.size_unit
downloaded = download.downloaded
speed = round(download.speed, 2)
speed_unit = download.speed_unit
time_left_str = download.time_left_str
if download.completed:
progressBar.setMaximum(download.size_kib)
progressBar.setValue(download.size_kib)
download_item.setText(3, "Completed") #Cleans the 'speed' column
download_item.setText(4, "Completed") #Cleans the 'time left' column
self.active_download_items.remove(download_item)
if not self.ui.a_clearCompleted.isEnabled():
self.ui.a_clearCompleted.setEnabled(True)
if self.settings.notify_done:
self.notification.show(self.tr("Download Finished"),
os.path.split(download.dest_file)[1])
self.afterComplete(download)
else:
download_item.setText(1, str(total_size) + " " + unit)
progressBar.setMaximum(download.size_kib)
progressBar.setValue(downloaded)
download_item.setText(3, str(speed) + " " + speed_unit)
download_item.setText(4, time_left_str)
def openDir(self, dir=None):
if not dir:
directories = set()
for item in self.active_tree_widget.selectedItems():
download = item.getDownload()
directories.add(os.path.split(download.dest_file)[0])
filemanager = None
else:
directories = (dir,)
for manager in c.FILEMANAGERS:
if is_command(manager):
filemanager = manager
break
if filemanager:
for directory in directories:
subprocess.Popen((filemanager, directory))
self.ui.statusbar.showMessage(self.tr("Opening download directory %s with %s") % (" ".join(directories), filemanager), 5000)
def processVideos(self, mediums=None):
if mediums is None: return
videos = []
for medium in mediums:
format = mediums[medium]
videos.append(VideoInfo(medium.title, medium.url, format.url))
if self.action == "download":
for video in videos:
video.folder = self.settings.download_folder
video.after_complete = self.settings.after_download
elif self.action == "play":
for video in videos: video.toPlay()
self.addNewDownloads(videos)
#dialogs
def showAddVideos(self, urls=None, format_mode=False):
if self.dialogs["add_videos"] is None:
from watchvideo.add_videos import AddVideosDialog
self.dialogs["add_videos"] = AddVideosDialog(self, self.settings)
self.dialogs["add_videos"].load(urls, format_mode)
if self.isVisible():
self.dialogs["add_videos"].show()
self.dialogs["add_videos"].activateWindow()
def showPreferences(self):
"""Displays the Preferences dialog."""
self.dialogs['preferences'] = Preferences(self, self.settings)
self.dialogs['preferences'].show()
self.dialogs['preferences'].activateWindow()
def showAbout(self):
"""Displays the About dialog."""
if self.dialogs['about'] is None:
from watchvideo.about import AboutDialog
self.dialogs['about'] = AboutDialog(self)
self.dialogs['about'].show()
self.dialogs['about'].activateWindow()
def addFromClipboard(self):
urls = self.getClipboardText().split()
objname = self.sender().objectName()
if "a_" in objname:
objname = objname.split("a_")[1]
self.action = objname
self.getFilesUrl(urls)
def getClipboardText(self):
return self.clipboard.text()
def copyOriginalUrl(self):
"""Copies the original url to the Clipboard"""
if self.menu_active == "download":
urls = [item.getOriginalUrl() for item in self.ui.tree_downloads.selectedItems()]
elif self.menu_active == "search":
urls = [item.getOriginalUrl() for item in self.ui.resultsWidget.selectedItems()]
elif self.menu_active == "playlist":
urls = [item.getOriginalUrl() for item in self.ui.playlistWidget.selectedItems()]
else:
urls = [self.player.getOriginalUrl()]
self.clipboard.setText("\n".join(urls))
def showStatusMessage(self):
if not self.match_url:
self.sender().setStatusTip(self.getClipboardText())
self.sender().showStatusText()
def cleanStatusTip(self):
self.ui.a_clipboard.setStatusTip("")
self.ui.a_download.setStatusTip("")
self.ui.a_play.setStatusTip("")
def cancelSearch(self):
self.stopChecking()
self.resetStatusBar()
def stopChecking(self):
if self.match_url:
self.match_url.stop = True
self.timer_match_urls.stop()
self.match_url = None
def resetStatusBar(self):
self.ui.statusbar.showMessage("")
self.ui.statusbar.removeWidget(self.b_cancelSearch)
def play(self, video):
if self.settings.use_builtin_player:
item = DownloadItem(video.url, video.dl_url, video.filepath, video.after_complete, self)
self.player.loadfile(video.filepath, item)
else:
Thread(target=main.play, args=(video.dl_url, video.name,
self.settings.media_player)).start()
def removeDownloadItem(self, item, rmFromGui=True):
"""item: is a TreeWidgetItem
rmFromGui: if true, removes the item from the QTreeWidget """
if item in self.active_download_items:
self.active_download_items.remove(item)
if rmFromGui:
i = self.active_tree_widget.indexOfTopLevelItem(item)
if i != -1:
if "playlist" in self.active_tree_widget.objectName():
del self.player.counters[i]
self.active_tree_widget.takeTopLevelItem(i)
def openWindow(self, activation):
if activation in (3, 2): #show/hide window
if self.isVisible():
self.hide()
for dialog in self.dialogs:
if self.dialogs[dialog] and self.dialogs[dialog].isVisible():
self.dialogs[dialog].hide()
else:
self.show()
for dialog in self.dialogs:
if self.dialogs[dialog] and self.dialogs[dialog].visible:
self.dialogs[dialog].show()
if self.dialogs['add_videos'] and self.dialogs['add_videos'].mediums:
self.dialogs['add_videos'].show()
def eventFilter(self, obj, event):
if obj == self.ui.videoWidget:
if self.ignoreMovement:
self.ignoreMovement -= 1
return False
if event.type() == QEvent.MouseMove:
if self.ui.videoWidget.width() - 50 < event.x() < self.ui.videoWidget.width():
self.ui.playlistWidget.show()
self.ignoreMovement = 8
self.player.startTextMoveTimer()
else:
self.ui.playlistWidget.hide()
self.player.stopTextMoveTimer()
return True
elif event.type() == QEvent.MouseButtonDblClick:
self.player.setFullscreen()
return True
else:
return False
elif obj == self.ui.playlistWidget:
if self.ignoreMovement:
self.ignoreMovement -= 1
return False
if event.type() == QEvent.MouseMove:
if event.x() < 0 or event.x() > self.ui.playlistWidget.width() or\
event.y() < 0 or event.y() > self.ui.playlistWidget.height():
self.ui.playlistWidget.hide()
self.player.stopTextMoveTimer()
self.ignoreMovement = 10
return True
else:
return False
return QtGui.QMainWindow.eventFilter(obj, event)
def isEverythingAborted(self):
abortCompleted = True
for download_item in self.active_download_items:
if not download_item.getDownload().aborted:
download_item.getDownload().abort()
return False
if self.player and self.player.areDownloadsActive():
return False
#just a measure for extra security when closing the app
for download in self.downloads_trash:
if not download.aborted:
return False
if self.dialogs["add_videos"] and not self.dialogs["add_videos"].isFinished():
return False
return True
def abortDownloads(self):
for download_item in self.active_download_items:
download = download_item.getDownload()
if download.isActive(): download.abort()
if self.player:
self.player.reset(downloads=True)
if self.dialogs["add_videos"] and not self.dialogs["add_videos"].isFinished():
self.dialogs["add_videos"].close()
def saveWindow(self):
self.settings.window_state = self.saveState()
self.settings.window_geometry = self.saveGeometry()
self.settings.show_search = self.ui.a_viewSearch.isChecked()
def loadWindow(self):
if self.settings.window_geometry:
self.restoreGeometry(self.settings.window_geometry)
if self.settings.window_state:
self.restoreState(self.settings.window_state)
self.ui.a_viewSearch.setChecked(self.settings.show_search)
def close_window(self):
"""called by self.close_timer"""
self.show_confirm_dialog = False
self.close()
def closeEvent(self, event):
if self.active_download_items or (self.player and self.player.isActive()) or (
self.dialogs["add_videos"] and not self.dialogs["add_videos"].isFinished()):
if self.show_confirm_dialog:
answer = gui_utils.confirm(self, title="Quit?",
msg=self.tr("There are still some tasks active, do you really want to quit?" +
"\n(you won't be able to continue them after quitting)"))
else:
answer = QtGui.QMessageBox.Yes
if answer == QtGui.QMessageBox.Yes:
self.abortDownloads()
if not self.isEverythingAborted():
#hide GUI so it gets out of the user's way while the app is closing
self.hide()
self.close_timer.start(750)
event.ignore()
return
else:
event.ignore()
return
self.saveWindow()