def _createImageContextMenu(self, menu, hitTest):
'''
@param: menu QMenu
@param: hitTest WebHitTestResult
'''
menu.addSeparator()
if hitTest.imageUrl() != self.url():
act = Action(_('Show i&mage'), menu)
act.setData(hitTest.imageUrl())
act.triggered.connect(self._openActionUrl)
act.ctrlTriggered.connect(lambda: self.userDefinedOpenUrlInNewTab())
menu.addAction(act)
menu.addAction(_('Copy image'), self._copyImageToClipboard)
act = menu.addAction(QIcon.fromTheme('edit-copy'), _('Copy image ad&dress'),
self._copyLinkToClipboard)
act.setData(hitTest.imageUrl())
menu.addSeparator()
menu.addAction(QIcon.fromTheme('document-save'), _('&Save image as...'),
self._downloadImageToDisk)
act = menu.addAction(QIcon.fromTheme('mail-message-new'), _('Send image...'),
self._sendTextByMail)
act.setData(hitTest.imageUrl().toEncoded())
menu.addSeparator()
if self.selectedText():
menu.addAction(self.pageAction(QWebEnginePage.Copy))
def setThemeIcon(self, icon):
'''
@param: icon QString
'''
# QIcon ic
ic = QIcon.fromTheme(icon)
if not ic.isNull():
self._themeIcon = icon
self.setIcon(QIcon.fromTheme(self._themeIcon))
def _updateSiteIcon(self):
if self._completer.isVisible():
self._siteIcon.setIcon(
QIcon.fromTheme('edit-find',
QIcon(':/icons/menu/search-icon.svg')))
else:
icon = IconProvider.emptyWebIcon()
secured = self.property('secured')
if secured:
icon = QIcon.fromTheme('document-encrypted', icon)
self._siteIcon.setIcon(icon.pixmap(16))
def _createSelectedTextContextMenu(self, menu, hitTest):
'''
@param: menu QMenu
@param: hitTest WebHitTestResult
'''
selectedText = self.page().selectedText()
menu.addSeparator()
if self.pageAction(QWebEnginePage.Copy) not in menu.actions():
menu.addAction(self.pageAction(QWebEnginePage.Copy))
menu.addAction(QIcon.fromTheme('mail-message-new'), _('Send text...'),
self._sendTextByMail).setData(selectedText)
menu.addSeparator()
# 379: Remove newlines
selectedString = selectedText.strip()
if '.' not in selectedString:
# Try to add .com
selectedString += '.com'
guessedUrl = QUrl.fromUserInput(selectedString)
if self.isUrlValid(guessedUrl):
act = Action(QIcon.fromTheme('document-open-remote'), _('Go to &web address'), menu)
act.setData(guessedUrl)
act.triggered.connect(self._openActionUrl)
act.ctrlTriggered.connect(lambda: self.userDefinedOpenUrlInNewTab())
menu.addAction(act)
menu.addSeparator()
selectedText = selectedText[:20]
# KDE is displaying newlines in menu actions ... weird
selectedText = selectedText.replace('\n', ' ').replace('\t', ' ')
engine = gVar.app.searchEnginesManager().defaultEngine()
act = Action(engine.icon, _('Search "%s .." with %s') % (selectedText, engine.name), menu)
act.triggered.connect(self._searchSelectedText)
act.ctrlTriggered.connect(self._searchSelectedTextInBackgroundTab)
menu.addAction(act)
# Search with ...
swMenu = Menu(_('Search with...'), menu)
swMenu.setCloseOnMiddleClick(True)
searchManager = gVar.app.searchEnginesManager()
for en in searchManager.allEngines():
act = Action(en.icon, en.name, swMenu)
act.setData(en)
act.triggered.connect(self._searchSelectedText)
act.ctrlTriggered.connect(self._searchSelectedTextInBackgroundTab)
swMenu.addAction(act)
menu.addMenu(swMenu)
def _createContextMenu(self, pos):
'''
@param: pos QPoint
'''
menu = QMenu()
actNewTab = menu.addAction(IconProvider.newTabIcon(),
_('Open in new tab'))
actNewWindow = menu.addAction(IconProvider.newWindowIcon(),
_('Open in new window'))
actNewPrivateWindow = menu.addAction(
IconProvider.privateBrowsingIcon(),
_('Open in new private window'))
menu.addSeparator()
actDelete = menu.addAction(QIcon.fromTheme('edit-delete'), _('Delete'))
actNewTab.triggered.connect(lambda x: self._openUrlInNewTab())
actNewWindow.triggered.connect(lambda x: self._openUrlInNewWindow())
actNewPrivateWindow.triggered.connect(
lambda x: self._openUrlInNewPrivateWindow())
actDelete.triggered.connect(self.ui.historyTree.removeSelectedItems)
if self.ui.historyTree.selectedUrl().isEmpty():
actNewTab.setDisabled(True)
actNewWindow.setDisabled(True)
actNewPrivateWindow.setDisabled(True)
menu.exec_(pos)
def __init__(self, fileName, downloadItem, parent=None):
'''
@param: fileName QString
@param: downloadItem QWebEngineDownloadItem
@param: parent QWidget
'''
super().__init__(parent)
self._ui = uic.loadUi('mc/downloads/DownloadOptionsDialog.ui', self)
self._downloadItem = downloadItem
self._signalEmited = False
self._ui.fileName.setText('<b>%s</b>' % fileName)
self._ui.fromServer.setText(self._downloadItem.url().host())
fileIcon = IconProvider.standardIcon(QStyle.SP_FileIcon)
db = QMimeDatabase()
# QMimeType
mime = db.mimeTypeForName(downloadItem.mimeType())
if mime.isValid() and not mime.isDefault():
self._ui.mimeName.setText(mime.comment())
self._ui.iconLabel.setPixmap(QIcon.fromTheme(mime.iconName(), fileIcon).pixmap(22))
else:
self._ui.mimeFrame.hide()
self.iconLabel.setPixmap(fileIcon.pixmap(22))
self.setWindowTitle(_('Opening %s') % fileName)
self._ui.buttonBox.setFocus()
self._ui.copyDownloadLink.clicked.connect(self._copyDownloadLink)
self._ui.finished.connect(self._emitDialogFinished)
def _createContextMenu(self, pos):
menu = QMenu()
actNewTab = menu.addAction(IconProvider.newTabIcon(),
_("Open in new tab"))
actNewWindow = menu.addAction(IconProvider.newWindowIcon(),
_("Open in new window"))
actNewPrivateWindow = menu.addAction(
IconProvider.privateBrowsingIcon(),
_("Open in new private window"))
menu.addSeparator()
actCopyUrl = menu.addAction(_("Copy url"), self._copyUrl)
actCopyTitle = menu.addAction(_("Copy title"), self._copyTitle)
menu.addSeparator()
actDelete = menu.addAction(QIcon.fromTheme("edit-delete"), _("Delete"))
actNewTab.triggered.connect(self._openUrlInNewTab)
actNewWindow.triggered.connect(self._openUrlInNewWindow)
actNewPrivateWindow.triggered.connect(self._openUrlInNewPrivateWindow)
actDelete.triggered.connect(self._ui.historyTree.removeSelectedItems)
if self._ui.historyTree.selectedUrl().isEmpty():
actNewTab.setDisabled(True)
actNewWindow.setDisabled(True)
actNewPrivateWindow.setDisabled(True)
actCopyTitle.setDisabled(True)
actCopyUrl.setDisabled(True)
menu.exec_(pos)
def _downloadFinished(self, success):
'''
@param: success bool
'''
self._activeDownloadsCount = 0
downloadingAllFilesFinished = True
for idx in range(self._ui.list.count()):
downItem = self._ui.list.itemWidget(self._ui.list.item(idx))
if not isinstance(downItem, DownloadItem):
continue
if downItem.isDownloading():
self._activeDownloadsCount += 1
if downItem.isCancelled() or not downItem.isDownloading():
continue
downloadingAllFilesFinished = False
self.downloadsCountChanged.emit()
if downloadingAllFilesFinished:
if success and gVar.app.activeWindow() != self:
icon = QIcon.fromTheme('download',
QIcon(':/icons/other/download.svg'))
gVar.app.desktopNotifications().showNotification(
icon.pixmap(48), _('App: Download Finished'),
_('All files have been successfully downloaded.'))
if not self._closeOnFinish:
self.raise_()
self.activateWindow()
self._ui.speedLabel.clear()
self.setWindowTitle(_('Download Manager'))
if const.OS_WIN:
self.taskbarButton().progress().hide()
if self._closeOnFinish:
self.close()
def _contextMenuRequested(self, pos):
'''
@param: pos QPoint
'''
# BookmarksToolbarButton
button = self._buttonAt(pos)
if button:
self._clickedBookmark = button.bookmark()
else:
self._clickedBookmark = None
menu = QMenu()
actNewTab = menu.addAction(IconProvider.newTabIcon(),
_('Open in new tab'))
actNewWindow = menu.addAction(IconProvider.newWindowIcon(),
_('Open in new window'))
actNewPrivateWindow = menu.addAction(
IconProvider.privateBrowsingIcon(),
_('Open in new private window'))
menu.addSeparator()
actEdit = menu.addAction(_('Edit'))
actDelete = menu.addAction(QIcon.fromTheme('edit-delete'), _('Delete'))
menu.addSeparator()
self._actShowOnlyIcons = menu.addAction(_('Show Only Icons'))
self._actShowOnlyIcons.setCheckable(True)
self._actShowOnlyIcons.setChecked(
self._bookmarks.showOnlyIconsInToolbar())
self._actShowOnlyIcons.toggled.connect(self._showOnlyIconsChanged)
self._actShowOnlyText = menu.addAction(_('Show Only Text'))
self._actShowOnlyText.setCheckable(True)
self._actShowOnlyText.setChecked(
self._bookmarks.showOnlyTextInToolbar())
self._actShowOnlyText.toggled.connect(self._showOnlyTextChanged)
actNewTab.triggered.connect(self._openBookmarkInNewTab)
actNewWindow.triggered.connect(self._openBookmarkInNewWindow)
actNewPrivateWindow.triggered.connect(
self._openBookmarkInNewPrivateWindow)
actEdit.triggered.connect(self._editBookmark)
actDelete.triggered.connect(self._deleteBookmark)
canBeModify = self._clickedBookmark and self._bookmarks.canBeModified(
self._clickedBookmark)
actEdit.setEnabled(canBeModify)
actDelete.setEnabled(canBeModify)
canOpen = self._clickedBookmark and self._clickedBookmark.isUrl()
actNewTab.setEnabled(canOpen)
actNewWindow.setEnabled(canOpen)
actNewPrivateWindow.setEnabled(canOpen)
menu.exec_(self.mapToGlobal(pos))
if button:
# Clear mouse over state after closing menu
button.update()
self._clickedBookmark = None
self._actShowOnlyIcons = None
self._actShowOnlyText = None
def _imagesCustomContextMenuRequested(self, point):
'''
@param: point QPoint
'''
item = self._ui.treeImages.itemAt(point)
if not item:
return
menu = QMenu()
action = menu.addAction(QIcon.fromTheme('edit-copy'), _('Copy Image Location'),
self._copyActionData)
action.setData(item.text(1))
menu.addSeparator()
menu.addAction(QIcon.fromTheme('document-save'), _('Save Image to Disk'),
self._saveImage)
menu.exec_(self._ui.treeImages.viewport().mapToGlobal(point))
def _init(self):
self.setTitle('Hi&story')
icon = IconProvider.standardIcon(QStyle.SP_ArrowBack)
act = self.addAction(icon, '&Back', self._goBack)
act.setShortcut(
gVar.appTools.actionShortcut(QKeySequence.Back,
Qt.ALT + Qt.Key_Left,
QKeySequence.Forward,
Qt.ALT + Qt.Key_Right))
icon = IconProvider.standardIcon(QStyle.SP_ArrowForward)
act = self.addAction(icon, '&Forward', self._goForward)
act.setShortcut(
gVar.appTools.actionShortcut(QKeySequence.Forward,
Qt.ALT + Qt.Key_Right,
QKeySequence.Back,
Qt.ALT + Qt.Key_Left))
act = self.addAction(QIcon.fromTheme('go-home'), '&Home', self._goHome)
act.setShortcut(QKeySequence(Qt.ALT + Qt.Key_Home))
icon = QIcon.fromTheme('deep-history',
QIcon(':/icons/menu/history.svg'))
act = self.addAction(icon, 'Show &All History')
act.triggered.connect(self._showHistoryManager)
act.setShortcut(QKeySequence(Qt.CTRL + Qt.SHIFT + Qt.Key_H))
self.addSeparator()
self.aboutToShow.connect(self._aboutToHide)
self.aboutToHide.connect(self._aboutToShow)
self._menuMostVisited = Menu('Most Visited', self)
self._menuMostVisited.aboutToShow.connect(self._aboutToShowMostVisited)
self._menuClosedTabs = Menu('Closed Tabs')
self._menuClosedTabs.aboutToShow.connect(self._aboutToShowClosedTabs)
self._menuClosedWindows = Menu('Closed Windows')
self._menuClosedWindows.aboutToShow.connect(
self._aboutToShowClosedWindows)
self.addMenu(self._menuMostVisited)
self.addMenu(self._menuClosedTabs)
self.addMenu(self._menuClosedWindows)
def _updateIcon(self):
if self._themeIcon:
icon = QIcon.fromTheme(self._themeIcon)
if not icon.isNull():
self.setPixmap(icon.pixmap(self.size()))
return
if self._fallbackIcon:
self.setPixmap(self._fallbackIcon.pixmap(self.size()))
def data(self):
'''
@return: Data
'''
if self._s_data is None:
self._s_data = data = self.Data()
data.animationInterval = 70
data.animationPixmap = QIcon(':/icons/other/loading.png').pixmap(
288, 16)
data.framesCount = data.animationPixmap.width(
) / data.animationPixmap.height()
data.audioPlayingPixmap = QIcon.fromTheme(
'audio-volume-high',
QIcon(':/icons/other/audioplaying.svg')).pixmap(16)
data.audioMutedPixmap = QIcon.fromTheme(
'audio-volume-muted',
QIcon(':/icons/other/audiomuted.svg')).pixmap(16)
return self._s_data
def _createMediaContextMenu(self, menu, hitTest):
'''
@param: menu QMenu
@param: hitTest WebHitTestResult
'''
paused = hitTest.mediaPaused()
muted = hitTest.mediaMuted()
menu.addSeparator()
act = menu.addAction(paused and _('&Paly') or _('&Pause'), self._toggleMediaPause)
act.setIcon(QIcon.fromTheme(paused and 'media-playback-start' or 'media-playback-pause'))
act = menu.addAction(muted and _('Un&mute') or _('&Mute'), self._toggleMediaMute)
act.setIcon(QIcon.fromTheme(muted and 'audio-volume-muted' or 'audio-volume-high'))
menu.addSeparator()
act = menu.addAction(QIcon.fromTheme('edit-copy'), _('&Copy Media Address'), self._copyLinkToClipboard)
act.setData(hitTest.mediaUrl())
act = menu.addAction(QIcon.fromTheme('mail-message-new'), _('&Send Media Address'), self._sendTextByMail)
act.setData(hitTest.mediaUrl().toEncoded())
menu.addAction(QIcon.fromTheme('document-save'), _('Save Media To &Disk'), self._downloadMediaToDisk)
def __init__(self, parent=None):
super().__init__(parent)
self._manager = gVar.app.downloadManager() # DownloadManager
self.setIcon(QIcon.fromTheme('edit-download', QIcon(':/icons/menu/download.svg')))
self.setTitle('Downloads')
self.setToolTip('Open Download Manager')
self.clicked.connect(self._clicked)
self._manager.downloadsCountChanged.connect(self._updateState)
self._updateState()
def _textEdited(self, text):
self._oldTextLength = self._currentTextLength
self._currentTextLength = len(text)
if text:
self._completer.complete(text)
icon = QIcon.fromTheme('edit-find',
QIcon(':/icons/menu/search-icon.svg'))
self._siteIcon.setIcon(icon)
else:
self._completer.closePopup()
self._setGoIconVisible(True)
def path_input(name: str,
directory: bool,
preamble: Optional[str] = None) -> QLineEdit:
line_edit = QLineEdit()
button = QPushButton()
if directory:
button.setIcon(
QIcon.fromTheme(
"folder-open",
QApplication.style().standardIcon(QStyle.SP_DirIcon)))
else:
button.setIcon(
QIcon.fromTheme(
"document-open",
QApplication.style().standardIcon(QStyle.SP_FileIcon)))
def press_callback() -> None:
if directory:
if preamble:
QMessageBox.information(None, "How to use", preamble)
path = QFileDialog.getExistingDirectory(
caption=f"Select your {name} directory")
else:
path, filter = QFileDialog.getOpenFileName(
caption=f"Select your {name} file")
if path:
line_edit.setText(path)
button.pressed.connect(press_callback)
row = grid_layout.rowCount()
grid_layout.addWidget(QLabel(name), row, 0)
grid_layout.addWidget(line_edit, row, 1)
grid_layout.addWidget(button, row, 2)
return line_edit
def _customContextMenuRequested(self, pos):
'''
@param: pos QPoint
'''
menu = QMenu()
menu.addAction(QIcon.fromTheme('document-open'), _('Open File'),
self.__openFile)
menu.addAction(_('Open Folder'), self._openFolder)
menu.addSeparator()
menu.addAction(QIcon.fromTheme('edit-copy'), _('Copy Download Link'),
self._copyDownloadLink)
menu.addSeparator()
menu.addAction(QIcon.fromTheme('process-stop'),
_('Cancel downloading'),
self._stop).setEnabled(self._downloading)
menu.addAction(QIcon.fromTheme('list-remove'), _('Remove From List'),
self._clear).setEnabled(not self._downloading)
if self._downloading or self._ui.downloadInfo.text().startswith(_('Cancelled')) or \
self._ui.downloadInfo.text().startswith(_('Error')):
menu.actions()[0].setEnabled(False)
menu.exec_(self.mapToGlobal(pos))
def _createLinkContextMenu(self, menu, hitTest):
'''
@param: menu QMenu
@param: hitTest WebHitTestResult
'''
menu.addSeparator()
act = Action(IconProvider.newTabIcon(), _('Open link in new &tab'), menu)
act.setData(hitTest.linkUrl())
act.triggered.connect(lambda: self.userDefinedOpenUrlInNewTab())
act.ctrlTriggered.connect(lambda: self.userDefineOpenUrlInBgTab())
menu.addAction(act)
act = menu.addAction(IconProvider.newWindowIcon(), _('Open link in new &window'),
self._openUrlInNewWindow)
act.setData(hitTest.linkUrl())
act = menu.addAction(IconProvider.privateBrowsingIcon(), _('Open link in &private window'),
gVar.app.startPrivateBrowsing)
act.setData(hitTest.linkUrl())
menu.addSeparator()
bData = [hitTest.linkUrl(), hitTest.linkTitle()] # QVariantList
act = menu.addAction(QIcon.fromTheme('bookmark-new'), _('B&ookmark link'),
self._bookmarkLink)
act.setData(bData)
menu.addAction(QIcon.fromTheme('document-save'), _('&Save link as...'),
self._downloadLinkToDisk)
act = menu.addAction(QIcon.fromTheme('mail-message-new'), _('Send link...'),
self._sendTextByMail)
act.setData(hitTest.linkUrl().toEncoded())
act = menu.addAction(QIcon.fromTheme('edit-copy'), _('&Copy link address'),
self._copyLinkToClipboard)
act.setData(hitTest.linkUrl())
menu.addSeparator()
if self.selectedText():
menu.addAction(self.pageAction(QWebEnginePage.Copy))
def icon_data_for_filename(fname, size=64):
''' Return the file type icon (as bytes) for the given filename '''
raw = b''
if fname:
if not hasattr(icon_data_for_filename, 'md'):
icon_data_for_filename.md = QMimeDatabase()
for mt in icon_data_for_filename.md.mimeTypesForFileName(fname):
icname = mt.iconName()
if icname:
ic = QIcon.fromTheme(icname)
if not ic.isNull():
raw = icon_to_data(ic)
if raw:
break
return raw
def icon_data_for_filename(fname, size=64):
''' Return the file type icon (as bytes) for the given filename '''
raw = b''
if fname:
if not hasattr(icon_data_for_filename, 'md'):
icon_data_for_filename.md = QMimeDatabase()
for mt in icon_data_for_filename.md.mimeTypesForFileName(fname):
icname = mt.iconName()
if icname:
ic = QIcon.fromTheme(icname)
if not ic.isNull():
raw = icon_to_data(ic)
if raw:
break
return raw
def _createPageContextMenu(self, menu):
'''
@param: menu QMenu
'''
action = menu.addAction(_('&Back'), self.back)
action.setIcon(IconProvider.standardIcon(QStyle.SP_ArrowBack))
action.setEnabled(self.history().canGoBack())
action = menu.addAction(_('&Forward'), self.forward)
action.setIcon(IconProvider.standardIcon(QStyle.SP_ArrowForward))
action.setEnabled(self.history().canGoForward())
# Special menu for Speed Dial page
if self.url().toString() == 'app:speeddial':
menu.addSeparator()
menu.addAction(QIcon.fromTheme('list-add'), _('&Add New Page'),
self._addSpeedDial)
menu.addAction(IconProvider.settingsIcon(), _('&Configure Speed Dial'),
self._configureSpeedDial)
menu.addSeparator()
menu.addAction(QIcon.fromTheme('view-refresh'), _('Reload All Dials'),
self._reloadAllSpeedDials)
return
reloadAct, pageReloadAct = self._addPageActionToMenu(menu, QWebEnginePage.Reload)
reloadAct.setVisible(pageReloadAct.isEnabled())
def reloadCb():
reloadAct.setVisible(pageReloadAct.isEnabled())
pageReloadAct.changed.connect(reloadCb)
menu.clearActions.append([pageReloadAct.changed, reloadCb])
stopAct, pageStopAct = self._addPageActionToMenu(menu, QWebEnginePage.Stop)
stopAct.setVisible(pageStopAct.isEnabled())
def stopCb():
stopAct.setVisible(pageStopAct.isEnabled())
pageStopAct.changed.connect(stopCb)
menu.clearActions.append([pageStopAct.changed, stopCb])
menu.addSeparator()
menu.addAction(QIcon.fromTheme('bookmark-new'), _('Book&mark page'), self._bookmarkLink)
menu.addAction(QIcon.fromTheme('document-save'), _('&Save page as...'), self._savePageAs)
act = menu.addAction(QIcon.fromTheme('edit-copy'), _('&Copy page link...'), self._copyLinkToClipboard)
act.setData(self.url())
menu.addAction(QIcon.fromTheme('mail-message-new'), _('Send page link...'), self.sendPageByEmail)
menu.addSeparator()
menu.addAction(QIcon.fromTheme('edit-select-all'), _('Select &all'), self.editSelectAll)
menu.addSeparator()
def _aboutToShowClosedTabsMenu(self):
self._menuClosedTabs.clear()
closedTabs = self.closedTabsManager().closedTabs()
for idx, tab in enumerate(closedTabs):
title = gVar.appTools.truncatedText(tab.tabState.title, 40)
self._menuClosedTabs.addAction(tab.tabState.icon, title,
self.restoreClosedTab).setData(idx)
if self._menuClosedTabs.isEmpty():
self._menuClosedTabs.addAction('Empty').setEnabled(False)
else:
self._menuClosedTabs.addSeparator()
self._menuClosedTabs.addAction('Restore All Closed Tabs',
self.restoreAllClosedTabs)
self._menuClosedTabs.addAction(QIcon.fromTheme('edit-clear'),
'Clear list',
self.clearClosedTabsList)
def _init(self):
self.setTitle('&Bookmarks')
act = self.addAction('Bookmark &This Page', self._bookmarkPage)
act.setShortcut(QKeySequence('Ctrl+D'))
self.addAction('Bookmark &All Tabs', self._bookmarkAllTabs)
act = self.addAction(QIcon.fromTheme('bookmarks-organize'),
'Organize &Bookmarks')
# NOTE: if use self.addAction(icon, label, self._showBookmarksManager)
# will cause connection random invalid, so here connect triggered
# separately.
act.triggered.connect(self._showBookmarksManager)
act.setShortcut(QKeySequence('Ctrl+Shift+O'))
self.addSeparator()
self.aboutToShow.connect(self._aboutToShow)
self.aboutToShow.connect(self._menuAboutToShow)
self.menuMiddleClicked.connect(self._menuMiddleClicked)
def __init__(self, item, downloadItem, path, fileName, openFile, manager):
'''
@param: item QListWidgetItem
@param: downloadItem QWebEngineDownloadItem
@param: path QString
@param: fileName QString
@param: openFile bool
@param: manager DownloadManager
'''
super().__init__()
self._ui = uic.loadUi('mc/downloads/DownloadItem.ui', self)
self._item = item # QListWidgetItem
self._download = downloadItem # QWebEngineDownloadItem
self._path = path
self._fileName = fileName
self._downTimer = QTime()
self._remTime = QTime()
self._downUrl = downloadItem.url()
self._openFile = openFile
self._downloading = False
self._downloadStopped = False
self._currSpeed = 0.0
self._received = downloadItem.receivedBytes()
self._total = downloadItem.totalBytes()
if self.DEBUG:
print(
'DEBUG: %s::__init__ %s %s %s %s' %
(self.__class__.__name__, item, downloadItem, path, fileName))
self.setMaximumWidth(525)
self._ui.button.setPixmap(
QIcon.fromTheme('process-stop').pixmap(20, 20))
self._ui.fileName.setText(self._fileName)
self._ui.downloadInfo.setText(_('Remaining time unavailable'))
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.customContextMenuRequested.connect(
self._customContextMenuRequested)
self._ui.button.clicked.connect(self._stop)
manager.resized.connect(self._parentResized)
def _createContextMenu(self, pos):
'''
@param: pos QPoint
'''
menu = QMenu()
actNewTab = menu.addAction(IconProvider.newTabIcon(), _('Open in new tab'))
actNewWindow = menu.addAction(IconProvider.newWindowIcon(), _('Open in new window'))
actNewPrivateWindow = menu.addAction(IconProvider.privateBrowsingIcon(), _('Open in new private window'))
menu.addSeparator()
actNewBookmark = menu.addAction(_('New Bookmark'), self._addBookmark)
actNewFolder = menu.addAction(_('New Folder'), self._addFolder)
actNewSeparator = menu.addAction(_('New Separator'), self._addSeparator)
menu.addSeparator()
actDelete = menu.addAction(QIcon.fromTheme('edit-delete'), _('Delete'))
actNewTab.triggered.connect(self._openBookmarkInNewTab)
actNewWindow.triggered.connect(self._openBookmarkInNewWindow)
actNewPrivateWindow.triggered.connect(self._openBookmarkInNewPrivateWindow)
actDelete.triggered.connect(self._deleteBookmarks)
canBeDelete = False
# QList<BookmarkItem>
items = self._ui.tree.selectedBookmarks()
for item in items:
if self._bookmarks.canBeModified(item):
canBeDelete = True
break
if not canBeDelete:
actDelete.setDisabled(True)
if not self._selectedBookmark or not self._selectedBookmark.isUlr():
actNewTab.setDisabled(True)
actNewWindow.setDisabled(True)
actNewPrivateWindow.setDisabled(True)
if not self._selectedBookmark:
actNewBookmark.setDisabled(True)
actNewFolder.setDisabled(True)
actNewSeparator.setDisabled(True)
menu.exec_(pos)
def _initializeActions(self):
for type_, text, shortcut, useCtx, theme in [
(QWebEnginePage.Undo, _('&Undo'), 'Ctrl+Z', True, 'edit-undo'),
(QWebEnginePage.Redo, _('&Redo'), 'Ctrl+Shift+Z', True, 'edit-redo'),
(QWebEnginePage.Cut, _('&Cut'), 'Ctrl+X', True, 'edit-cut'),
(QWebEnginePage.Copy, _('&Copy'), 'Ctrl+C', True, 'edit-copy'),
(QWebEnginePage.Paste, _('&Paste'), 'Ctrl+V', True, 'edit-paste'),
(QWebEnginePage.SelectAll, _('Select All'), 'Ctrl+A', True, 'edit-select-all'),
(QWebEnginePage.Reload, _('&Reload'), '', False, 'view-refresh'),
(QWebEnginePage.Stop, _('S&top'), '', False, 'process-stop'),
]:
act = self.pageAction(type_)
act.setText(text)
if shortcut:
act.setShortcut(QKeySequence(shortcut))
if useCtx:
act.setShortcutContext(Qt.WidgetWithChildrenShortcut)
if not useCtx:
self.addAction(act)
act.setIcon(QIcon.fromTheme(theme))
def _parseTheme(self, path, name):
'''
@param: path QString
@param: name QString
@return self._Theme
'''
info = self._Theme()
info.isValid = False
if not QFile(path + 'main.css').exists() or not QFile(
path + 'metadata.desktop').exists():
info.isValid = False
return info
metadata = DesktopFile('metadata.desktop')
info.name = metadata.name()
info.description = metadata.comment()
info.author = metadata.value('X-App-Author')
# QString
iconName = metadata.icon()
if iconName:
if QFileInfo.exists(path + iconName):
info.icon = QIcon(path + iconName)
else:
info.icon = QIcon.fromTheme(iconName)
licensePath = metadata.value('X-App-License')
if licensePath and QFileInfo.exists(path + licensePath):
info.license = gVar.appTools.readAllFileContents(path +
licensePath)
if not info.name or name in self._themeHash:
return info
info.isValid = True
self._themeHash[name] = info
return info
def __init__(self, parent=None):
super().__init__(parent)
self.ui = None # Ui::DownloadManager
self._timer = QBasicTimer()
self._lastDownloadPath = ''
self._downloadPath = ''
self._useNativeDialog = False
self._isClosing = False
self._closeOnFinish = False
self._activeDownloadsCount = 0
self._useExternalManager = False
self._externalExecutable = ''
self._externalArguments = ''
self._lastDownloadOption = self.NoOption # DownloadOption
self._taskbarButton = None # QPointer<QWinTaskbarButton>
self._ui = uic.loadUi('mc/downloads/DownloadManager.ui', self)
self.setWindowFlags(self.windowFlags() ^ Qt.WindowMaximizeButtonHint)
if const.OS_WIN:
if QtWin.isCompositionEnabled(): # TODO: ?
QtWin.extendFrameIntoClientArea(self, -1, -1, -1, -1)
self._ui.clearButton.setIcon(QIcon.fromTheme('edit-clear'))
gVar.appTools.centerWidgetOnScreen(self)
self._ui.clearButton.clicked.connect(self._clearList)
clearShortcut = QShortcut(QKeySequence('CTRL+L'), self)
clearShortcut.activated.connect(self._clearList)
self.loadSettings()
gVar.appTools.setWmClass('Download Manager', self)
def initialize(self, library_path, db, listener, actions, show_gui=True):
opts = self.opts
self.preferences_action, self.quit_action = actions
self.library_path = library_path
self.content_server = None
self._spare_pool = None
self.must_restart_before_config = False
self.listener = Listener(listener)
self.check_messages_timer = QTimer()
self.check_messages_timer.timeout.connect(
self.another_instance_wants_to_talk)
self.check_messages_timer.start(1000)
for ac in self.iactions.values():
try:
ac.do_genesis()
except Exception:
# Ignore errors in third party plugins
import traceback
traceback.print_exc()
if getattr(ac, 'plugin_path', None) is None:
raise
self.donate_action = QAction(QIcon(I('donate.png')),
_('&Donate to support calibre'), self)
for st in self.istores.values():
st.do_genesis()
MainWindowMixin.init_main_window_mixin(self, db)
# Jobs Button {{{
self.job_manager = JobManager()
self.jobs_dialog = JobsDialog(self, self.job_manager)
self.jobs_button = JobsButton(horizontal=True, parent=self)
self.jobs_button.initialize(self.jobs_dialog, self.job_manager)
# }}}
LayoutMixin.init_layout_mixin(self)
DeviceMixin.init_device_mixin(self)
self.progress_indicator = ProgressIndicator(self)
self.progress_indicator.pos = (0, 20)
self.verbose = opts.verbose
self.get_metadata = GetMetadata()
self.upload_memory = {}
self.metadata_dialogs = []
self.default_thumbnail = None
self.tb_wrapper = textwrap.TextWrapper(width=40)
self.viewers = collections.deque()
self.system_tray_icon = None
if config['systray_icon']:
self.system_tray_icon = factory(
app_id='com.calibre-ebook.gui').create_system_tray_icon(
parent=self, title='calibre')
if self.system_tray_icon is not None:
self.system_tray_icon.setIcon(
QIcon(I('lt.png', allow_user_override=False)))
if not (iswindows or isosx):
self.system_tray_icon.setIcon(
QIcon.fromTheme('calibre-gui',
self.system_tray_icon.icon()))
self.system_tray_icon.setToolTip(self.jobs_button.tray_tooltip())
self.system_tray_icon.setVisible(True)
self.jobs_button.tray_tooltip_updated.connect(
self.system_tray_icon.setToolTip)
elif config['systray_icon']:
prints(
'Failed to create system tray icon, your desktop environment probably does not support the StatusNotifier spec'
)
self.system_tray_menu = QMenu(self)
self.toggle_to_tray_action = self.system_tray_menu.addAction(
QIcon(I('page.png')), '')
self.toggle_to_tray_action.triggered.connect(
self.system_tray_icon_activated)
self.system_tray_menu.addAction(self.donate_action)
self.donate_button.clicked.connect(self.donate_action.trigger)
self.donate_button.setToolTip(self.donate_action.text().replace(
'&', ''))
self.donate_button.setIcon(self.donate_action.icon())
self.donate_button.setStatusTip(self.donate_button.toolTip())
self.eject_action = self.system_tray_menu.addAction(
QIcon(I('eject.png')), _('&Eject connected device'))
self.eject_action.setEnabled(False)
self.addAction(self.quit_action)
self.system_tray_menu.addAction(self.quit_action)
self.keyboard.register_shortcut('quit calibre',
_('Quit calibre'),
default_keys=('Ctrl+Q', ),
action=self.quit_action)
if self.system_tray_icon is not None:
self.system_tray_icon.setContextMenu(self.system_tray_menu)
self.system_tray_icon.activated.connect(
self.system_tray_icon_activated)
self.quit_action.triggered[bool].connect(self.quit)
self.donate_action.triggered[bool].connect(self.donate)
self.minimize_action = QAction(_('Minimize the calibre window'), self)
self.addAction(self.minimize_action)
self.keyboard.register_shortcut('minimize calibre',
self.minimize_action.text(),
default_keys=(),
action=self.minimize_action)
self.minimize_action.triggered.connect(self.showMinimized)
self.esc_action = QAction(self)
self.addAction(self.esc_action)
self.keyboard.register_shortcut('clear current search',
_('Clear the current search'),
default_keys=('Esc', ),
action=self.esc_action)
self.esc_action.triggered.connect(self.esc)
self.shift_esc_action = QAction(self)
self.addAction(self.shift_esc_action)
self.keyboard.register_shortcut('focus book list',
_('Focus the book list'),
default_keys=('Shift+Esc', ),
action=self.shift_esc_action)
self.shift_esc_action.triggered.connect(self.shift_esc)
self.ctrl_esc_action = QAction(self)
self.addAction(self.ctrl_esc_action)
self.keyboard.register_shortcut('clear virtual library',
_('Clear the virtual library'),
default_keys=('Ctrl+Esc', ),
action=self.ctrl_esc_action)
self.ctrl_esc_action.triggered.connect(self.ctrl_esc)
self.alt_esc_action = QAction(self)
self.addAction(self.alt_esc_action)
self.keyboard.register_shortcut('clear additional restriction',
_('Clear the additional restriction'),
default_keys=('Alt+Esc', ),
action=self.alt_esc_action)
self.alt_esc_action.triggered.connect(
self.clear_additional_restriction)
# ###################### Start spare job server ########################
QTimer.singleShot(1000, self.create_spare_pool)
# ###################### Location Manager ########################
self.location_manager.location_selected.connect(self.location_selected)
self.location_manager.unmount_device.connect(
self.device_manager.umount_device)
self.location_manager.configure_device.connect(
self.configure_connected_device)
self.location_manager.update_device_metadata.connect(
self.update_metadata_on_device)
self.eject_action.triggered.connect(self.device_manager.umount_device)
# ################### Update notification ###################
UpdateMixin.init_update_mixin(self, opts)
# ###################### Search boxes ########################
SearchRestrictionMixin.init_search_restriction_mixin(self)
SavedSearchBoxMixin.init_saved_seach_box_mixin(self)
# ###################### Library view ########################
LibraryViewMixin.init_library_view_mixin(self, db)
SearchBoxMixin.init_search_box_mixin(self) # Requires current_db
if show_gui:
self.show()
if self.system_tray_icon is not None and self.system_tray_icon.isVisible(
) and opts.start_in_tray:
self.hide_windows()
self.library_view.model().count_changed_signal.connect(
self.iactions['Choose Library'].count_changed)
if not gprefs.get('quick_start_guide_added', False):
try:
add_quick_start_guide(self.library_view)
except:
import traceback
traceback.print_exc()
for view in ('library', 'memory', 'card_a', 'card_b'):
v = getattr(self, '%s_view' % view)
v.selectionModel().selectionChanged.connect(self.update_status_bar)
v.model().count_changed_signal.connect(self.update_status_bar)
self.library_view.model().count_changed()
self.bars_manager.database_changed(self.library_view.model().db)
self.library_view.model().database_changed.connect(
self.bars_manager.database_changed, type=Qt.QueuedConnection)
# ########################## Tags Browser ##############################
TagBrowserMixin.init_tag_browser_mixin(self, db)
# ######################## Search Restriction ##########################
if db.prefs['virtual_lib_on_startup']:
self.apply_virtual_library(db.prefs['virtual_lib_on_startup'])
self.rebuild_vl_tabs()
# ########################## Cover Flow ################################
CoverFlowMixin.init_cover_flow_mixin(self)
self._calculated_available_height = min(max_available_height() - 15,
self.height())
self.resize(self.width(), self._calculated_available_height)
self.build_context_menus()
for ac in self.iactions.values():
try:
ac.gui_layout_complete()
except:
import traceback
traceback.print_exc()
if ac.plugin_path is None:
raise
if config['autolaunch_server']:
self.start_content_server()
self.read_settings()
self.finalize_layout()
if self.bars_manager.showing_donate:
self.donate_button.start_animation()
self.set_window_title()
for ac in self.iactions.values():
try:
ac.initialization_complete()
except:
import traceback
traceback.print_exc()
if ac.plugin_path is None:
raise
self.set_current_library_information(current_library_name(),
db.library_id, db.field_metadata)
register_keyboard_shortcuts()
self.keyboard.finalize()
self.auto_adder = AutoAdder(gprefs['auto_add_path'], self)
self.save_layout_state()
# Collect cycles now
gc.collect()
QApplication.instance().shutdown_signal_received.connect(self.quit)
if show_gui and self.gui_debug is not None:
QTimer.singleShot(10, self.show_gui_debug_msg)
self.iactions['Connect Share'].check_smartdevice_menus()
QTimer.singleShot(1, self.start_smartdevice)
QTimer.singleShot(100, self.update_toggle_to_tray_action)
def initialize(self, library_path, db, listener, actions, show_gui=True):
opts = self.opts
self.preferences_action, self.quit_action = actions
self.library_path = library_path
self.content_server = None
self._spare_pool = None
self.must_restart_before_config = False
self.listener = Listener(listener)
self.check_messages_timer = QTimer()
self.check_messages_timer.timeout.connect(self.another_instance_wants_to_talk)
self.check_messages_timer.start(1000)
for ac in self.iactions.values():
try:
ac.do_genesis()
except Exception:
# Ignore errors in third party plugins
import traceback
traceback.print_exc()
if getattr(ac, 'plugin_path', None) is None:
raise
self.donate_action = QAction(QIcon(I('donate.png')),
_('&Donate to support calibre'), self)
for st in self.istores.values():
st.do_genesis()
MainWindowMixin.init_main_window_mixin(self, db)
# Jobs Button {{{
self.job_manager = JobManager()
self.jobs_dialog = JobsDialog(self, self.job_manager)
self.jobs_button = JobsButton(horizontal=True, parent=self)
self.jobs_button.initialize(self.jobs_dialog, self.job_manager)
# }}}
LayoutMixin.init_layout_mixin(self)
DeviceMixin.init_device_mixin(self)
self.progress_indicator = ProgressIndicator(self)
self.progress_indicator.pos = (0, 20)
self.verbose = opts.verbose
self.get_metadata = GetMetadata()
self.upload_memory = {}
self.metadata_dialogs = []
self.default_thumbnail = None
self.tb_wrapper = textwrap.TextWrapper(width=40)
self.viewers = collections.deque()
self.system_tray_icon = None
if config['systray_icon']:
self.system_tray_icon = factory(app_id='com.calibre-ebook.gui').create_system_tray_icon(parent=self, title='calibre')
if self.system_tray_icon is not None:
self.system_tray_icon.setIcon(QIcon(I('lt.png')))
if not (iswindows or isosx):
self.system_tray_icon.setIcon(QIcon.fromTheme('calibre-gui', QIcon(I('lt.png'))))
self.system_tray_icon.setToolTip(self.jobs_button.tray_tooltip())
self.system_tray_icon.setVisible(True)
self.jobs_button.tray_tooltip_updated.connect(self.system_tray_icon.setToolTip)
elif config['systray_icon']:
prints('Failed to create system tray icon, your desktop environment probably does not support the StatusNotifier spec')
self.system_tray_menu = QMenu(self)
self.toggle_to_tray_action = self.system_tray_menu.addAction(QIcon(I('page.png')), '')
self.toggle_to_tray_action.triggered.connect(self.system_tray_icon_activated)
self.system_tray_menu.addAction(self.donate_action)
self.donate_button.clicked.connect(self.donate_action.trigger)
self.donate_button.setToolTip(self.donate_action.text().replace('&', ''))
self.donate_button.setIcon(self.donate_action.icon())
self.donate_button.setStatusTip(self.donate_button.toolTip())
self.eject_action = self.system_tray_menu.addAction(
QIcon(I('eject.png')), _('&Eject connected device'))
self.eject_action.setEnabled(False)
self.addAction(self.quit_action)
self.system_tray_menu.addAction(self.quit_action)
self.keyboard.register_shortcut('quit calibre', _('Quit calibre'),
default_keys=('Ctrl+Q',), action=self.quit_action)
if self.system_tray_icon is not None:
self.system_tray_icon.setContextMenu(self.system_tray_menu)
self.system_tray_icon.activated.connect(self.system_tray_icon_activated)
self.quit_action.triggered[bool].connect(self.quit)
self.donate_action.triggered[bool].connect(self.donate)
self.minimize_action = QAction(_('Minimize the calibre window'), self)
self.addAction(self.minimize_action)
self.keyboard.register_shortcut('minimize calibre', self.minimize_action.text(),
default_keys=(), action=self.minimize_action)
self.minimize_action.triggered.connect(self.showMinimized)
self.esc_action = QAction(self)
self.addAction(self.esc_action)
self.keyboard.register_shortcut('clear current search',
_('Clear the current search'), default_keys=('Esc',),
action=self.esc_action)
self.esc_action.triggered.connect(self.esc)
self.shift_esc_action = QAction(self)
self.addAction(self.shift_esc_action)
self.keyboard.register_shortcut('focus book list',
_('Focus the book list'), default_keys=('Shift+Esc',),
action=self.shift_esc_action)
self.shift_esc_action.triggered.connect(self.shift_esc)
self.ctrl_esc_action = QAction(self)
self.addAction(self.ctrl_esc_action)
self.keyboard.register_shortcut('clear virtual library',
_('Clear the virtual library'), default_keys=('Ctrl+Esc',),
action=self.ctrl_esc_action)
self.ctrl_esc_action.triggered.connect(self.ctrl_esc)
self.alt_esc_action = QAction(self)
self.addAction(self.alt_esc_action)
self.keyboard.register_shortcut('clear additional restriction',
_('Clear the additional restriction'), default_keys=('Alt+Esc',),
action=self.alt_esc_action)
self.alt_esc_action.triggered.connect(self.clear_additional_restriction)
# ###################### Start spare job server ########################
QTimer.singleShot(1000, self.create_spare_pool)
# ###################### Location Manager ########################
self.location_manager.location_selected.connect(self.location_selected)
self.location_manager.unmount_device.connect(self.device_manager.umount_device)
self.location_manager.configure_device.connect(self.configure_connected_device)
self.location_manager.update_device_metadata.connect(self.update_metadata_on_device)
self.eject_action.triggered.connect(self.device_manager.umount_device)
# ################### Update notification ###################
UpdateMixin.init_update_mixin(self, opts)
# ###################### Search boxes ########################
SearchRestrictionMixin.init_search_restriction_mixin(self)
SavedSearchBoxMixin.init_saved_seach_box_mixin(self)
# ###################### Library view ########################
LibraryViewMixin.init_library_view_mixin(self, db)
SearchBoxMixin.init_search_box_mixin(self) # Requires current_db
if show_gui:
self.show()
if self.system_tray_icon is not None and self.system_tray_icon.isVisible() and opts.start_in_tray:
self.hide_windows()
self.library_view.model().count_changed_signal.connect(
self.iactions['Choose Library'].count_changed)
if not gprefs.get('quick_start_guide_added', False):
try:
add_quick_start_guide(self.library_view)
except:
import traceback
traceback.print_exc()
for view in ('library', 'memory', 'card_a', 'card_b'):
v = getattr(self, '%s_view' % view)
v.selectionModel().selectionChanged.connect(self.update_status_bar)
v.model().count_changed_signal.connect(self.update_status_bar)
self.library_view.model().count_changed()
self.bars_manager.database_changed(self.library_view.model().db)
self.library_view.model().database_changed.connect(self.bars_manager.database_changed,
type=Qt.QueuedConnection)
# ########################## Tags Browser ##############################
TagBrowserMixin.init_tag_browser_mixin(self, db)
# ######################## Search Restriction ##########################
if db.prefs['virtual_lib_on_startup']:
self.apply_virtual_library(db.prefs['virtual_lib_on_startup'])
self.rebuild_vl_tabs()
# ########################## Cover Flow ################################
CoverFlowMixin.init_cover_flow_mixin(self)
self._calculated_available_height = min(max_available_height()-15,
self.height())
self.resize(self.width(), self._calculated_available_height)
self.build_context_menus()
for ac in self.iactions.values():
try:
ac.gui_layout_complete()
except:
import traceback
traceback.print_exc()
if ac.plugin_path is None:
raise
if config['autolaunch_server']:
self.start_content_server()
self.keyboard_interrupt.connect(self.quit, type=Qt.QueuedConnection)
self.read_settings()
self.finalize_layout()
if self.bars_manager.showing_donate:
self.donate_button.start_animation()
self.set_window_title()
for ac in self.iactions.values():
try:
ac.initialization_complete()
except:
import traceback
traceback.print_exc()
if ac.plugin_path is None:
raise
self.set_current_library_information(current_library_name(), db.library_id,
db.field_metadata)
register_keyboard_shortcuts()
self.keyboard.finalize()
self.auto_adder = AutoAdder(gprefs['auto_add_path'], self)
self.save_layout_state()
# Collect cycles now
gc.collect()
if show_gui and self.gui_debug is not None:
QTimer.singleShot(10, self.show_gui_debug_msg)
self.iactions['Connect Share'].check_smartdevice_menus()
QTimer.singleShot(1, self.start_smartdevice)
QTimer.singleShot(100, self.update_toggle_to_tray_action)
def _init(self):
# Standard actions - needed on Mac to be placed correctly in
# "application" menu
action = QAction(QIcon.fromTheme('help-about'), '&About App', self)
action.setMenuRole(QAction.AboutRole)
action.triggered.connect(self._showAboutDialog)
self._actions['Standard/About'] = action
action = QAction(IconProvider.settingsIcon(), 'Pr&eferences', self)
action.setMenuRole(QAction.PreferencesRole)
action.setShortcut(QKeySequence(QKeySequence.Preferences))
action.triggered.connect(self._showPreferences)
self._actions['Standard/Preferences'] = action
action = QAction(QIcon.fromTheme('application-exit'), 'Quit', self)
action.setMenuRole(QAction.QuitRole)
# Shortcut set from browserWindow
action.triggered.connect(self._quitApplication)
self._actions['Standard/Quit'] = action
# File menu
self._menuFile = QMenu('&File', self)
self._menuFile.aboutToShow.connect(self._aboutToShowFileMenu)
self._ADD_ACTION('File/NewTab', self._menuFile, IconProvider.newTabIcon(),
'New Tab', self._newTab, 'Ctrl+T')
self._ADD_ACTION('File/NewWindow', self._menuFile, IconProvider.newWindowIcon(),
'&New Window', self._newWindow, 'Ctrl+N')
self._ADD_ACTION('File/NewPrivateWindow', self._menuFile, IconProvider.privateBrowsingIcon(),
'New &Private Window', self._newPrivateWindow, 'Ctrl+Shift+P')
self._ADD_ACTION('File/OpenLocation', self._menuFile, QIcon.fromTheme('document-open-remote'),
'Open Location', self._openLocation, 'Ctrl+L')
self._ADD_ACTION('File/OpenFile', self._menuFile, QIcon.fromTheme('document-open'),
'Open &File...', self._openFile, 'Ctrl+O')
self._ADD_ACTION('File/CloseWindow', self._menuFile, QIcon.fromTheme('window-close'),
'Close Window', self._closeWindow, 'Ctrl+Shift+W')
self._menuFile.addSeparator()
sessionManager = gVar.app.sessionManager()
if sessionManager:
sessionsSubmenu = QMenu('Sessions', self)
sessionsSubmenu.aboutToShow.connect(sessionManager._aboutToShowSessionsMenu)
self._menuFile.addMenu(sessionsSubmenu)
action = QAction('Session Manager', self)
action.triggered.connect(sessionManager.openSessionManagerDialog)
self._actions['File/SessionManager'] = action
self._menuFile.addAction(action)
self._menuFile.addSeparator()
self._ADD_ACTION('File/SavePageAs', self._menuFile, QIcon.fromTheme('document-save'),
'&Save Page As...', self._savePageAs, 'Ctrl+S')
self._ADD_ACTION('File/SendLink', self._menuFile, QIcon.fromTheme('mail-message-new'),
'Send Link...', self._sendLink, '')
self._ADD_ACTION('File/Print', self._menuFile, QIcon.fromTheme('document-print'),
'&Print...', self._printPage, 'Ctrl+P')
self._menuFile.addSeparator()
self._menuFile.addAction(self._actions['Standard/Quit'])
# Edit Menu
self._menuEdit = QMenu('&Edit', self)
self._menuEdit.aboutToShow.connect(self._aboutToShowEditMenu)
action = self._ADD_ACTION('Edit/Undo', self._menuEdit, QIcon.fromTheme('edit-undo'),
'&Undo', self._editUndo, 'Ctrl+Z')
action.setShortcutContext(Qt.WidgetShortcut)
action = self._ADD_ACTION('Edit/Redo', self._menuEdit, QIcon.fromTheme('edit-redo'),
'&Redo', self._editRedo, 'Ctrl+Shift+Z')
action.setShortcutContext(Qt.WidgetShortcut)
self._menuEdit.addSeparator()
action = self._ADD_ACTION('Edit/Cut', self._menuEdit, QIcon.fromTheme('edit-cut'),
'&Cut', self._editCut, 'Ctrl+X')
action.setShortcutContext(Qt.WidgetShortcut)
action = self._ADD_ACTION('Edit/Copy', self._menuEdit, QIcon.fromTheme('edit-copy'),
'C&opy', self._editCopy, 'Ctrl+C')
action.setShortcutContext(Qt.WidgetShortcut)
action = self._ADD_ACTION('Edit/Paste', self._menuEdit, QIcon.fromTheme('edit-paste'),
'&Paste', self._editPaste, 'Ctrl+V')
action.setShortcutContext(Qt.WidgetShortcut)
self._menuEdit.addSeparator()
action = self._ADD_ACTION('Edit/SelectAll', self._menuEdit, QIcon.fromTheme('edit-select-all'),
'Select &All', self._editSelectAll, 'Ctrl+A')
action.setShortcutContext(Qt.WidgetShortcut)
action = self._ADD_ACTION('Edit/Find', self._menuEdit, QIcon.fromTheme('edit-find'),
'&Find', self._editFind, 'Ctrl+F')
action.setShortcutContext(Qt.WidgetShortcut)
self._menuFile.addSeparator()
# View menu
self._menuView = QMenu('&View', self)
self._menuView.aboutToShow.connect(self._aboutToShowViewMenu)
toolbarsMenu = QMenu('Toolbars', self._menuView)
toolbarsMenu.aboutToShow.connect(self._aboutToShowtoolbarsMenu)
sidebarMenu = QMenu('Sidebar', self._menuView)
sidebarMenu.aboutToShow.connect(self._aboutToShowSidebarsMenu)
encodingMenu = QMenu('Character &Encoding', self._menuView)
encodingMenu.aboutToShow.connect(self._aboutToShowEncodingMenu)
# Create menus to make shortcuts available event before first showing
# the menu
self._window.createToolbarsMenu(toolbarsMenu)
self._window.createSidebarsMenu(sidebarMenu)
self._menuView.addMenu(toolbarsMenu)
self._menuView.addMenu(sidebarMenu)
self._ADD_CHECKABLE_ACTION('View/ShowStatusBar', self._menuView, QIcon(),
'Sta&tus Bar', self._showStatusBar, '')
self._menuView.addSeparator()
self._ADD_ACTION('View/Stop', self._menuView, QIcon.fromTheme('process-stop'),
'&Stop', self._stop, 'Esc')
self._ADD_ACTION('View/Reload', self._menuView, QIcon.fromTheme('view-refresh'),
'&Reload', self._reload, 'F5')
self._menuView.addSeparator()
self._ADD_ACTION('View/ZoomIn', self._menuView, QIcon.fromTheme('zoom-in'),
'Zoom &In', self._zoomIn, 'Ctrl++')
self._ADD_ACTION('View/ZoomOut', self._menuView, QIcon.fromTheme('zoom-out'),
'Zoom &Out', self._zoomOut, 'Ctrl+-')
self._ADD_ACTION('View/ZoomReset', self._menuView, QIcon.fromTheme('zoom-original'),
'Reset', self._zoomReset, 'Ctrl+0')
self._menuView.addSeparator()
self._menuView.addMenu(encodingMenu)
self._menuView.addSeparator()
action = self._ADD_ACTION('View/PageSource', self._menuView, QIcon.fromTheme('text-html'),
'&Page Source', self._showPageSource, 'Ctrl+U')
action.setShortcutContext(Qt.WidgetShortcut)
self._ADD_CHECKABLE_ACTION('View/FullScreen', self._menuView, QIcon.fromTheme('view-fullscreen'),
'&FullScreen', self._showFullScreen, 'F11')
# Tool menu
self._menuTools = QMenu('&Tools', self)
self._menuTools.aboutToShow.connect(self._aboutToShowToolsMenu)
self._ADD_ACTION('Tools/WebSearch', self._menuTools, QIcon.fromTheme('edit-find'),
'&Web Search', self._webSearch, 'Ctrl+K')
action = self._ADD_ACTION('Tools/SiteInfo', self._menuTools, QIcon.fromTheme('dialog-information'),
'Site &Info', self._showSiteInfo, 'Ctrl+I')
action.setShortcutContext(Qt.WidgetShortcut)
self._menuTools.addSeparator()
self._ADD_ACTION('Tools/DownloadManager', self._menuTools, QIcon.fromTheme('download'),
'&Download Manager', self._showDownloadManager, 'Ctrl+Y')
self._ADD_ACTION('Tools/CookiesManager', self._menuTools, QIcon(),
'&Cookies Manager', self._showCookieManager, '')
self._ADD_ACTION('Tools/WebInspector', self._menuTools, QIcon(),
'Web In&spector', self._toggleWebInspector, 'Ctrl+Shift+I')
self._ADD_ACTION('Tools/ClearRecentHistory', self._menuTools, QIcon.fromTheme('edit-clear'),
'Clear Recent &History', self._showClearRecentHistoryDialog, 'Ctrl+Shift+Del')
if not WebInspector.isEnabled():
self._actions['Tools/WebInspector'].setVisible(False)
self._submenuExtensions = QMenu('&Extensions', self)
self._submenuExtensions.menuAction().setVisible(False)
self._menuTools.addMenu(self._submenuExtensions)
self._menuTools.addSeparator()
# Help menu
self._menuHelp = QMenu('&Help', self)
# ifndef Q_OS_MACOS
self._ADD_ACTION('Help/AboutQt', self._menuHelp, QIcon(),
'About &Qt', self._aboutQt, '')
self._menuHelp.addAction(self._actions['Standard/About'])
self._menuHelp.addSeparator()
# endif
self._ADD_ACTION('Help/InfoAboutApp', self._menuHelp, QIcon.fromTheme('help-contents'),
'Information about application', self._showInfoAboutApp, '')
self._ADD_ACTION('Help/ConfigInfo', self._menuHelp, QIcon(),
'Configuration Information', self._showConfigInfo, '')
self._ADD_ACTION('Help/ReportIssue', self._menuHelp, QIcon(),
'Report &Issue', self._reportIssue, '')
self._actions['Help/InfoAboutApp'].setShortcut(QKeySequence(QKeySequence.HelpContents))
# History menu
self._menuHistory = HistoryMenu()
self._menuHistory.setMainWindow(self._window)
# Bookmarks menu
self._menuBookmarks = BookmarksMenu()
self._menuBookmarks.setMainWindow(self._window)
# Other actions
action = QAction(QIcon.fromTheme('user-trash'),
'Restore &Closed Tab', self)
action.setShortcut(QKeySequence('Ctrl+Shift+T'))
action.triggered.connect(self._restoreClosedTab)
self._actions['Other/RestoreClosedTab'] = action
# # ifdef Q_OS_MACOS
# self._actions['View/FullScreen'].setShortcut(QKeySequence('Ctrl+Meta+F'))
# # Add standard actions to File Menu (as it won't be ever cleared) and
# # Mac menubar should move them to "Application" menu
# self._menuFile.addAction(self._actions['Standard/About'])
# self._menuFile.addAction(self._actions['Standard/Preferences'])
# # Prevent ConfigInfo action to be detected as "Preferences..." action in
# # Mac
# self._actions['Help/ConfigInfo'].setMenuRole(QAction.NoRole)
# # Create Dock Menu
# dockMenu = QMenu(0)
# dockMenu.addAction(self._actions['File/NewTab'])
# dockMenu.addAction(self._actions['File/NewWindow'])
# dockMenu.addAction(self._actions['File/NewPrivateWindow'])
# qt_mac_set_dock_menu(dockMenu)
# # endif
if const.OS_UNIX and not const.OS_MACOS:
self._menuEdit.addAction(self._actions['Standard/Preferences'])
elif not const.OS_MACOS:
self._menuTools.addAction(self._actions['Standard/Preferences'])
self._addActionsToWindow()
