eric: comparison WebBrowser/Download/DownloadManager.py

-:dd4a8b507144
+:35ec993034e1
 Module implementing the download manager class.
 """
 from __future__ import unicode_literals
-from PyQt5.QtCore import pyqtSlot, pyqtSignal, Qt, QModelIndex, QFileInfo, QUrl
+from PyQt5.QtCore import pyqtSlot, pyqtSignal, Qt, QModelIndex, QFileInfo, \
+QUrl, QBasicTimer
 from PyQt5.QtGui import QCursor, QKeySequence
 from PyQt5.QtWidgets import QDialog, QStyle, QFileIconProvider, QMenu, \
 QApplication, QShortcut
 from E5Gui import E5MessageBox
 from .Ui_DownloadManager import Ui_DownloadManager
 from .DownloadModel import DownloadModel
+from .DownloadUtilities import speedString, timeString
 from WebBrowser.WebBrowserWindow import WebBrowserWindow
 from Utilities.AutoSaver import AutoSaver
 import UI.PixmapCache
 import Preferences
+import Globals
 class DownloadManager(QDialog, Ui_DownloadManager):
 """
 Class implementing the download manager.
 """
 RemoveNever = 0
 RemoveExit = 1
 RemoveSuccessFullDownload = 2
+UpdateTimerTimeout = 1000
 downloadsCountChanged = pyqtSignal()
 def __init__(self, parent=None):
 """
 Constructor
 @param parent reference to the parent widget (QWidget)
 """
 super(DownloadManager, self).__init__(parent)
 self.setupUi(self)
 self.setWindowFlags(Qt.Window)
+self.__winTaskbarButton = None
 self.__saveTimer = AutoSaver(self, self.save)
 self.__model = DownloadModel(self)
 self.__manager = WebBrowserWindow.networkManager()
 self.__clearShortcut = QShortcut(QKeySequence("Ctrl+L"), self)
 self.__clearShortcut.activated.connect(self.on_cleanupButton_clicked)
 self.__load()
+self.__updateTimer = QBasicTimer()
 def __customContextMenuRequested(self, pos):
 """
 Private slot to handle the context menu request for the bookmarks tree.
 if not res:
 self.show()
 return False
 return True
+def __testWebBrowserView(self, view, url):
+"""
+Private method to test a web browser view against an URL.
+@param view reference to the web browser view to be tested
+@type WebBrowserView
+@param url URL to test against
+@type QUrl
+@return flag indicating, that the view is the one for the URL
+@rtype bool
+"""
+if view.tabWidget().count() < 2:
+return False
+page = view.page()
+if page.history().count() != 0:
+return False
+if not page.url().isEmpty() and \
+page.url().host() == url.host():
+return True
+requestedUrl = page.requestedUrl()
+if requestedUrl.isEmpty():
+requestedUrl = QUrl(view.tabWidget().urlBarForView(view).text())
+return requestedUrl.isEmpty() or requestedUrl.host() == url.host()
+def __closeDownloadTab(self, url):
+"""
+Private method to close an empty tab, that was opened only for loading
+the download URL.
+@param url download URL
+@type QUrl
+"""
+if self.__testWebBrowserView(
+WebBrowserWindow.getWindow().currentBrowser(), url):
+WebBrowserWindow.getWindow().closeCurrentBrowser()
+return
+for window in WebBrowserWindow.mainWindows():
+for browser in window.browsers():
+if self.__testWebBrowserView(browser, url):
+window.closeBrowser(browser)
+return
 def download(self, downloadItem):
 """
 Public method to download a file.
 @param downloadItem reference to the download object containing the
 @type QWebEngineDownloadItem
 """
 url = downloadItem.url()
 if url.isEmpty():
 return
+self.__closeDownloadTab(url)
 # Safe Browsing
 from WebBrowser.SafeBrowsing.SafeBrowsingManager import \
 SafeBrowsingManager
 if SafeBrowsingManager.isEnabled():
 from .DownloadItem import DownloadItem
 itm = DownloadItem(downloadItem=downloadItem, pageUrl=pageUrl,
 parent=self)
 self.__addItem(itm)
-if itm.canceledFileSelect():
+self.__startUpdateTimer()
-return
+def show(self):
-if not self.isVisible():
+"""
-self.show()
+Public slot to show the download manager dialog.
+"""
+self.__startUpdateTimer()
+super(DownloadManager, self).show()
 self.activateWindow()
 self.raise_()
 def __addItem(self, itm, append=False):
 """
 self.downloadsView.setRowHeight(
 row, itm.sizeHint().height() * self.__rowHeightMultiplier)
 # just in case the download finished before the constructor returned
 self.__updateRow(itm)
 self.changeOccurred()
-self.__updateActiveItemCount()
 self.downloadsCountChanged.emit()
 def __updateRow(self, itm):
 """
 self.__addItem(itm, append=True)
 self.cleanupButton.setEnabled(
 (self.downloadsCount() - self.activeDownloadsCount()) > 0)
 self.__loaded = True
-self.__updateActiveItemCount()
 self.downloadsCountChanged.emit()
 def closeEvent(self, evt):
 """
 self.on_cleanupButton_clicked()
 @pyqtSlot()
 def on_cleanupButton_clicked(self):
 """
-Private slot cleanup the downloads.
+Private slot to cleanup the downloads.
 """
 if self.downloadsCount() == 0:
 return
 self.__model.removeRows(0, self.downloadsCount())
 if self.downloadsCount() == 0 and \
 self.__iconProvider is not None:
 self.__iconProvider = None
 self.changeOccurred()
-self.__updateActiveItemCount()
 self.downloadsCountChanged.emit()
-def __updateItemCount(self):
-"""
-Private method to update the count label.
-"""
-count = self.downloadsCount()
-self.countLabel.setText(self.tr("%n Download(s)", "", count))
-def __updateActiveItemCount(self):
-"""
-Private method to update the window title.
-"""
-count = self.activeDownloadsCount()
-if count > 0:
-self.setWindowTitle(
-self.tr("Downloading %n file(s)", "", count))
-else:
-self.setWindowTitle(self.tr("Downloads"))
 def __finished(self):
 """
 Private slot to handle a finished download.
 """
-self.__updateActiveItemCount()
 if self.isVisible():
 QApplication.alert(self)
 self.downloadsCountChanged.emit()
 def changeOccurred(self):
 """
 Public method to signal a change.
 """
 self.__saveTimer.changeOccurred()
-self.__updateItemCount()
+def __taskbarButton(self):
+"""
+Private method to get a reference to the task bar button (Windows
+only).
+@return reference to the task bar button
+@rtype QWinTaskbarButton or None
+"""
+if Globals.isWindowsPlatform():
+from PyQt5.QtWinExtras import QWinTaskbarButton
+if self.__winTaskbarButton is None:
+window = WebBrowserWindow.mainWindow()
+self.__winTaskbarButton = QWinTaskbarButton(
+window.windowHandle())
+self.__winTaskbarButton.progress().setRange(0, 100)
+return self.__winTaskbarButton
+def timerEvent(self, evt):
+"""
+Protected event handler for timer events.
+@param evt reference to the timer event
+@type QTimerEvent
+"""
+if evt.timerId() == self.__updateTimer.timerId():
+if self.activeDownloadsCount() == 0:
+self.__stopUpdateTimer()
+self.infoLabel.clear()
+self.setWindowTitle(self.tr("Download Manager"))
+if Globals.isWindowsPlatform():
+self.__taskbarButton.progress().hide()
+else:
+progresses = []
+for itm in self.__downloads:
+if itm is None or \
+itm.downloadCanceled() or \
+not itm.downloading():
+continue
+progresses.append((
+itm.downloadProgress(),
+itm.remainingTime(),
+itm.currentSpeed()
+))
+if not progresses:
+return
+remaining = 0
+progress = 0
+speed = 0.0
+for progressData in progresses:
+if progressData[1] > remaining:
+remaining = progressData[1]
+progress += progressData[0]
+speed += progressData[2]
+progress = progress / len(progresses)
+if self.isVisible():
+self.infoLabel.setText(self.tr(
+"{0}% of %n file(s) ({1}) {2}", "",
+len(progresses)).format(
+progress,
+speedString(speed),
+timeString(remaining),
+))
+self.setWindowTitle(self.tr("{0}% - Download Manager"))
+if Globals.isWindowsPlatform():
+self.taskbarButton().progress().show()
+self.taskbarButton().progress().setValue(progress)
+super(DownloadManager, self).timerEvent(evt)
+def __startUpdateTimer(self):
+"""
+Private slot to start the update timer.
+"""
+if self.activeDownloadsCount() and not self.__updateTimer.isActive():
+self.__updateTimer.start(DownloadManager.UpdateTimerTimeout, self)
+def __stopUpdateTimer(self):
+"""
+Private slot to stop the update timer.
+"""
+self.__updateTimer.stop()
 ###########################################################################
 ## Context menu related methods below
 ###########################################################################

Mercurial Repositories > eric / file comparison

comparison: WebBrowser/Download/DownloadManager.py

WebBrowser/Download/DownloadManager.py