eric: comparison eric7/WebBrowser/WebBrowserWindow.py

-:c48137b0d7ba
+:207b47c2eed9
 )
 from PyQt6.QtWebEngineCore import (
 QWebEngineSettings, QWebEnginePage, QWebEngineProfile, QWebEngineScript
 )
 try:
-from PyQt6.QtHelp import QHelpEngine, QHelpEngineCore, QHelpFilterData
+from PyQt6.QtHelp import QHelpEngine
 QTHELP_AVAILABLE = True
 except ImportError:
 QTHELP_AVAILABLE = False
 from EricGui.EricAction import EricAction
 if WebBrowserWindow._useQtHelp:
 self.__helpEngine = QHelpEngine(
 WebBrowserWindow.getQtHelpCollectionFileName(),
 self)
+self.__helpEngine.setReadOnly(False)
+self.__helpEngine.setupData()
 self.__helpEngine.setUsesFilterEngine(True)
 self.__removeOldDocumentation()
 self.__helpEngine.warning.connect(self.__warning)
 else:
 self.__helpEngine = None
 self.__indexDock.setWidget(self.__indexWindow)
 self.addDockWidget(Qt.DockWidgetArea.LeftDockWidgetArea,
 self.__indexDock)
 # setup the search widget
-self.__searchWord = searchWord
 self.__indexing = False
 self.__indexingProgress = None
 self.__searchEngine = self.__helpEngine.searchEngine()
 self.__searchEngine.indexingStarted.connect(
 self.__indexingStarted)
 self.__searchWindow.newWindow.connect(self.openUrlNewWindow)
 state = Preferences.getWebBrowser("WebBrowserState")
 self.restoreState(state)
-self.__initHelpDb()
 self.__virusTotal = VirusTotalAPI(self)
 self.__virusTotal.submitUrlError.connect(
 self.__virusTotalSubmitUrlError)
 self.__virusTotal.urlScanReport.connect(
 self.__virusTotalUrlScanReport)
 QTimer.singleShot(0, syncMgr.loadSettings)
 if WebBrowserWindow._useQtHelp:
 QTimer.singleShot(50, self.__lookForNewDocumentation)
-if self.__searchWord is not None:
+if searchWord:
-QTimer.singleShot(0, self.__searchForWord)
+QTimer.singleShot(0, lambda: self.__searchForWord(searchWord))
 def __del__(self):
 """
 Special method called during object destruction.
 "ComboBoxWithEnoughWidth")
 self.filterCombo.setMinimumWidth(comboWidth)
 filtertb.addWidget(QLabel(self.tr("Filtered by: ")))
 filtertb.addWidget(self.filterCombo)
 self.__helpEngine.setupFinished.connect(self.__setupFilterCombo)
-self.filterCombo.currentTextChanged.connect(
+self.filterCombo.currentIndexChanged.connect(
 self.__filterQtHelpDocumentation)
 self.__setupFilterCombo()
 self.__toolbars["filter"] = (filtertb.windowTitle(), filtertb)
 settingstb = self.addToolBar(self.tr("Settings"))
 vttb.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
 vttb.addAction(self.virustotalScanCurrentAct)
 vttb.addAction(self.virustotalIpReportAct)
 vttb.addAction(self.virustotalDomainReportAct)
 self.__toolbars["virustotal"] = (vttb.windowTitle(), vttb)
+@pyqtSlot()
 def __nextTab(self):
 """
 Private slot used to show the next tab.
 """
 fwidget = QApplication.focusWidget()
 while fwidget and not hasattr(fwidget, 'nextTab'):
 fwidget = fwidget.parent()
 if fwidget:
 fwidget.nextTab()
+@pyqtSlot()
 def __prevTab(self):
 """
 Private slot used to show the previous tab.
 """
 fwidget = QApplication.focusWidget()
 while fwidget and not hasattr(fwidget, 'prevTab'):
 fwidget = fwidget.parent()
 if fwidget:
 fwidget.prevTab()
+@pyqtSlot()
 def __switchTab(self):
 """
 Private slot used to switch between the current and the previous
 current tab.
 """
 fwidget = QApplication.focusWidget()
 while fwidget and not hasattr(fwidget, 'switchTab'):
 fwidget = fwidget.parent()
 if fwidget:
 fwidget.switchTab()
+@pyqtSlot()
 def __whatsThis(self):
 """
 Private slot called in to enter Whats This mode.
 """
 QWhatsThis.enterWhatsThisMode()
 def __titleChanged(self, browser, title):
 """
 Private slot called to handle a change of a browser's title.
-@param browser reference to the browser (WebBrowserView)
+@param browser reference to the browser
-@param title new title (string)
+@type WebBrowserView
+@param title new title
+@type str
 """
 self.historyManager().updateHistoryEntry(
 browser.url().toString(), title)
 @pyqtSlot()
 '<p>Could not start the process.<br>'
 'Ensure that it is available as <b>{0}</b>.</p>'
 ).format(applPath),
 self.tr('OK'))
+@pyqtSlot()
 def __openFile(self):
 """
 Private slot called to open a file.
 """
 fn = EricFileDialog.getOpenFileName(
 if Utilities.isWindowsPlatform():
 url = "file:///" + Utilities.fromNativeSeparators(fn)
 else:
 url = "file://" + fn
 self.currentBrowser().setSource(QUrl(url))
+@pyqtSlot()
 def __openFileNewTab(self):
 """
 Private slot called to open a file in a new tab.
 """
 fn = EricFileDialog.getOpenFileName(
 if Utilities.isWindowsPlatform():
 url = "file:///" + Utilities.fromNativeSeparators(fn)
 else:
 url = "file://" + fn
 self.newTab(url)
+@pyqtSlot()
 def __savePageAs(self):
 """
 Private slot to save the current page.
 """
 browser = self.currentBrowser()
 shot.
 """
 from .PageScreenDialog import PageScreenDialog
 self.__pageScreen = PageScreenDialog(self.currentBrowser())
 self.__pageScreen.show()
+@pyqtSlot()
 def __about(self):
 """
 Private slot to show the about information.
 """
 chromeVersion, webengineVersion = (
 """<p>The eric Web Browser is a combined help file and HTML"""
 """ browser. It is part of the eric development"""
 """ toolset.</p>"""
 """<p>It is based on QtWebEngine {1} and Chrome {2}.</p>"""
 ).format(Version, webengineVersion, chromeVersion))
+@pyqtSlot()
 def __aboutQt(self):
 """
 Private slot to show info about Qt.
 """
 EricMessageBox.aboutQt(self, self.tr("eric Web Browser"))
+@pyqtSlot(bool)
 def setBackwardAvailable(self, b):
 """
 Public slot called when backward references are available.
-@param b flag indicating availability of the backwards action (boolean)
+@param b flag indicating availability of the backwards action
+@type bool
 """
 self.backAct.setEnabled(b)
 self.__navigationBar.backButton().setEnabled(b)
+@pyqtSlot(bool)
 def setForwardAvailable(self, b):
 """
 Public slot called when forward references are available.
 @param b flag indicating the availability of the forwards action
-(boolean)
+@type bool
 """
 self.forwardAct.setEnabled(b)
 self.__navigationBar.forwardButton().setEnabled(b)
+@pyqtSlot(bool)
 def setLoadingActions(self, b):
 """
 Public slot to set the loading dependent actions.
-@param b flag indicating the loading state to consider (boolean)
+@param b flag indicating the loading state to consider
+@type bool
 """
 self.reloadAct.setEnabled(not b)
 self.stopAct.setEnabled(b)
 self.__navigationBar.reloadStopButton().setLoading(b)
+@pyqtSlot()
 def __addBookmark(self):
 """
 Private slot called to add the displayed file to the bookmarks.
 """
 from .WebBrowserPage import WebBrowserPage
 dlg.setDescription(description)
 menu = self.bookmarksManager().menu()
 idx = self.bookmarksManager().bookmarksModel().nodeIndex(menu)
 dlg.setCurrentIndex(idx)
 dlg.exec()
+@pyqtSlot()
 def __addBookmarkFolder(self):
 """
 Private slot to add a new bookmarks folder.
 """
 from .Bookmarks.AddBookmarkDialog import AddBookmarkDialog
 menu = self.bookmarksManager().menu()
 idx = self.bookmarksManager().bookmarksModel().nodeIndex(menu)
 dlg.setCurrentIndex(idx)
 dlg.setFolder(True)
 dlg.exec()
+@pyqtSlot()
 def __showBookmarksDialog(self):
 """
 Private slot to show the bookmarks dialog.
 """
 from .Bookmarks.BookmarksDialog import BookmarksDialog
 self.__bookmarksDialog.openUrl.connect(self.openUrl)
 self.__bookmarksDialog.newTab.connect(self.openUrlNewTab)
 self.__bookmarksDialog.newBackgroundTab.connect(
 self.openUrlNewBackgroundTab)
 self.__bookmarksDialog.show()
+@pyqtSlot()
 def bookmarkAll(self):
 """
 Public slot to bookmark all open tabs.
 """
 from .WebBrowserPage import WebBrowserPage
 bookmark.url = url
 bookmark.title = title
 bookmark.desc = description
 self.bookmarksManager().addBookmark(folder, bookmark)
+@pyqtSlot()
 def __find(self):
 """
 Private slot to handle the find action.
 It opens the search dialog in order to perform the various
 def shutdown(self):
 """
 Public method to shut down the web browser.
-@return flag indicating successful shutdown (boolean)
+@return flag indicating successful shutdown
+@rtype bool
 """
 if not self.__shallShutDown():
 return False
 if (
 if browser != self:
 browser.close()
 self.close()
 return True
+@pyqtSlot()
 def __backward(self):
 """
 Private slot called to handle the backward action.
 """
 self.currentBrowser().backward()
+@pyqtSlot()
 def __forward(self):
 """
 Private slot called to handle the forward action.
 """
 self.currentBrowser().forward()
+@pyqtSlot()
 def __home(self):
 """
 Private slot called to handle the home action.
 """
 self.currentBrowser().home()
+@pyqtSlot()
 def __reload(self):
 """
 Private slot called to handle the reload action.
 """
 self.currentBrowser().reloadBypassingCache()
+@pyqtSlot()
 def __stopLoading(self):
 """
 Private slot called to handle loading of the current page.
 """
 self.currentBrowser().stop()
+@pyqtSlot(int)
 def __zoomValueChanged(self, value):
 """
 Private slot to handle value changes of the zoom widget.
-@param value zoom value (integer)
+@param value zoom value
+@type int
 """
 self.currentBrowser().setZoomValue(value)
+@pyqtSlot()
 def __zoomIn(self):
 """
 Private slot called to handle the zoom in action.
 """
 self.currentBrowser().zoomIn()
 self.__zoomWidget.setValue(self.currentBrowser().zoomValue())
+@pyqtSlot()
 def __zoomOut(self):
 """
 Private slot called to handle the zoom out action.
 """
 self.currentBrowser().zoomOut()
 self.__zoomWidget.setValue(self.currentBrowser().zoomValue())
+@pyqtSlot()
 def __zoomReset(self):
 """
 Private slot called to handle the zoom reset action.
 """
 self.currentBrowser().zoomReset()
 self.__zoomWidget.setValue(self.currentBrowser().zoomValue())
+@pyqtSlot()
 def toggleFullScreen(self):
 """
 Public slot called to toggle the full screen mode.
 """
 if self.__htmlFullScreen:
 screen mode
 @rtype bool
 """
 return self.isFullScreen() and self.__navigationContainer.isVisible()
+@pyqtSlot()
 def showFullScreenNavigation(self):
 """
 Public slot to show full screen navigation.
 """
 if self.__htmlFullScreen:
 self.__hideNavigationTimer.stop()
 self.__navigationContainer.show()
 self.__tabWidget.tabBar().show()
+@pyqtSlot()
 def hideFullScreenNavigation(self):
 """
 Public slot to hide full screen navigation.
 """
 if not self.__hideNavigationTimer.isActive():
 self.__hideNavigationTimer.start()
+@pyqtSlot()
 def __hideNavigation(self):
 """
 Private slot to hide full screen navigation by timer.
 """
 browser = self.currentBrowser()
 if self.isFullScreen() and mouseInBrowser:
 self.__navigationContainer.hide()
 self.__tabWidget.tabBar().hide()
+@pyqtSlot()
 def __copy(self):
 """
 Private slot called to handle the copy action.
 """
 self.currentBrowser().copy()
+@pyqtSlot()
 def __cut(self):
 """
 Private slot called to handle the cut action.
 """
 self.currentBrowser().cut()
+@pyqtSlot()
 def __paste(self):
 """
 Private slot called to handle the paste action.
 """
 self.currentBrowser().paste()
+@pyqtSlot()
 def __undo(self):
 """
 Private slot to handle the undo action.
 """
 self.currentBrowser().undo()
+@pyqtSlot()
 def __redo(self):
 """
 Private slot to handle the redo action.
 """
 self.currentBrowser().redo()
+@pyqtSlot()
 def __selectAll(self):
 """
 Private slot to handle the select all action.
 """
 self.currentBrowser().selectAll()
+@pyqtSlot()
 def __unselect(self):
 """
 Private slot to clear the selection of the current browser.
 """
 self.currentBrowser().unselect()
 @return list of references to web browsers (list of WebBrowserView)
 """
 return self.__tabWidget.browsers()
+@pyqtSlot(int)
 def __currentChanged(self, index):
 """
 Private slot to handle the currentChanged signal.
-@param index index of the current tab (integer)
+@param index index of the current tab
+@type int
 """
 if index > -1:
 cb = self.currentBrowser()
 if cb is not None:
 self.setForwardAvailable(cb.isForwardAvailable())
 self.setLoadingActions(cb.isLoading())
 # set value of zoom widget
 self.__zoomWidget.setValue(cb.zoomValue())
+@pyqtSlot()
 def __showPreferences(self):
 """
 Private slot to set the preferences.
 """
 from Preferences.ConfigurationDialog import (
 dlg.setPreferences()
 Preferences.syncPreferences()
 self.preferencesChanged()
 self.__lastConfigurationPageName = dlg.getConfigurationPageName()
+@pyqtSlot()
 def preferencesChanged(self):
 """
 Public slot to handle a change of preferences.
 """
 self.setStyle(Preferences.getUI("Style"),
 if local:
 # we were called from our local configuration dialog
 Preferences.convertPasswords(oldPassword, newPassword)
 Utilities.crypto.changeRememberedMaster(newPassword)
+@pyqtSlot()
 def __showAcceptedLanguages(self):
 """
 Private slot to configure the accepted languages for web pages.
 """
 from .WebBrowserLanguagesDialog import WebBrowserLanguagesDialog
 dlg = WebBrowserLanguagesDialog(self)
 dlg.exec()
 self.networkManager().languagesChanged()
+@pyqtSlot()
 def __showCookiesConfiguration(self):
 """
 Private slot to configure the cookies handling.
 """
 from .CookieJar.CookiesConfigurationDialog import (
 if cls._cookieJar is None:
 from .CookieJar.CookieJar import CookieJar
 cls._cookieJar = CookieJar()
 return cls._cookieJar
+@pyqtSlot()
 def __clearIconsDatabase(self):
 """
 Private slot to clear the favicons databse.
 """
 WebIconProvider.instance().clear()
+@pyqtSlot()
 def __showWebIconsDialog(self):
 """
 Private slot to show a dialog to manage the favicons database.
 """
 WebIconProvider.instance().showWebIconDialog()
 self.newTab(url)
 else:
 cb.setUrl(url)
 self.__activating = False
+@pyqtSlot()
 def __activateCurrentBrowser(self):
 """
 Private slot to activate the current browser.
 """
 self.currentBrowser().setFocus()
+@pyqtSlot()
 def __syncTOC(self):
 """
 Private slot to synchronize the TOC with the currently shown page.
 """
 if WebBrowserWindow._useQtHelp:
 with EricOverrideCursor():
 url = self.currentBrowser().source()
 self.__showTocWindow()
 if not self.__tocWindow.syncToContent(url):
 self.statusBar().showMessage(
-self.tr("Could not find an associated content."), 5000)
+self.tr("Could not find any associated content."),
+5000)
 def __showTocWindow(self):
 """
 Private method to show the table of contents window.
 """
 @param widget reference to the widget to be activated (QWidget)
 """
 widget.parent().show()
 widget.parent().raise_()
 widget.setFocus()
+@pyqtSlot()
 def __setupFilterCombo(self):
 """
 Private slot to setup the filter combo box.
 """
 if WebBrowserWindow._useQtHelp:
 activeFilter = self.filterCombo.currentText()
 if not activeFilter:
 activeFilter = self.__helpEngine.filterEngine().activeFilter()
+allFilters = self.__helpEngine.filterEngine().filters()
 self.filterCombo.clear()
-self.filterCombo.addItems(sorted(
+self.filterCombo.addItem(self.tr("Unfiltered"))
-self.__helpEngine.filterEngine().filters()))
+if allFilters:
+self.filterCombo.insertSeparator(1)
+for helpFilter in sorted(allFilters):
+self.filterCombo.addItem(helpFilter, helpFilter)
 self.filterCombo.setCurrentText(activeFilter)
-def __filterQtHelpDocumentation(self, activeFilter):
+@pyqtSlot(int)
+def __filterQtHelpDocumentation(self, index):
 """
 Private slot to filter the QtHelp documentation.
-@param activeFilter current text of the filter combobox
+@param index index of the selected QtHelp documentation filter
-@type str
+@type int
 """
 if self.__helpEngine:
-self.__helpEngine.filterEngine().setActiveFilter(activeFilter)
+helpFilter = self.filterCombo.itemData(index)
+self.__helpEngine.filterEngine().setActiveFilter(helpFilter)
+@pyqtSlot()
 def __manageQtHelpDocumentation(self):
 """
 Private slot to manage the QtHelp documentation database.
 """
 if WebBrowserWindow._useQtHelp:
 @return dictionary with tab id as key and host/namespace as value
 """
 return self.__tabWidget.getSourceFileList()
+@pyqtSlot()
 def __indexingStarted(self):
 """
 Private slot to handle the start of the indexing process.
 """
 if WebBrowserWindow._useQtHelp:
 progressBar.setSizePolicy(sizePolicy)
 layout.addWidget(progressBar)
 self.statusBar().insertPermanentWidget(
 0, self.__indexingProgress)
+@pyqtSlot()
 def __indexingFinished(self):
 """
 Private slot to handle the start of the indexing process.
 """
 if WebBrowserWindow._useQtHelp:
 self.statusBar().removeWidget(self.__indexingProgress)
 self.__indexingProgress = None
 self.__indexing = False
-if self.__searchWord is not None:
-self.__searchForWord()
+@pyqtSlot(str)
+def __searchForWord(self, searchWord):
-def __searchForWord(self):
 """
 Private slot to search for a word.
-"""
-if (
+@param searchWord word to search for
-WebBrowserWindow._useQtHelp and
+@type str
-not self.__indexing and
+"""
-self.__searchWord is not None
+if WebBrowserWindow._useQtHelp and searchWord:
-):
+if self.__indexing:
-self.__searchDock.show()
+# Try again a second later
-self.__searchDock.raise_()
+QTimer.singleShot(
-self.__searchEngine.search(self.__searchWord)
+1000,
-self.__searchWord = None
+lambda: self.__searchForWord(searchWord)
+)
+else:
+self.__searchDock.show()
+self.__searchDock.raise_()
+self.__searchEngine.search(searchWord)
 def search(self, word):
 """
 Public method to search for a word.
-@param word word to search for (string)
+@param word word to search for
+@type str
 """
 if WebBrowserWindow._useQtHelp:
-self.__searchWord = word
+self.__searchForWord(word)
-self.__searchForWord()
+@pyqtSlot()
 def __removeOldDocumentation(self):
 """
 Private slot to remove non-existing documentation from the help engine.
 """
 if WebBrowserWindow._useQtHelp:
 for namespace in self.__helpEngine.registeredDocumentations():
 docFile = self.__helpEngine.documentationFileName(namespace)
 if not os.path.exists(docFile):
 self.__helpEngine.unregisterDocumentation(namespace)
+@pyqtSlot()
 def __lookForNewDocumentation(self):
 """
 Private slot to look for new documentation to be loaded into the
 help database.
 """
 self.__helpInstaller.docsInstalled.connect(self.__docsInstalled)
 self.statusBar().showMessage(
 self.tr("Looking for Documentation..."))
 self.__helpInstaller.installDocs()
+@pyqtSlot(str)
 def __showInstallationError(self, message):
 """
 Private slot to show installation errors.
-@param message message to be shown (string)
+@param message message to be shown
+@type str
 """
 EricMessageBox.warning(
 self,
 self.tr("eric Web Browser"),
 message)
+@pyqtSlot(bool)
 def __docsInstalled(self, installed):
 """
 Private slot handling the end of documentation installation.
 @param installed flag indicating that documents were installed
-(boolean)
+@type bool
 """
 if WebBrowserWindow._useQtHelp:
 self.statusBar().clearMessage()
+self.__helpEngine.setupData()
-def __initHelpDb(self):
-"""
+@pyqtSlot(str)
-Private slot to initialize the documentation database.
-"""
-if WebBrowserWindow._useQtHelp:
-unfiltered = self.tr("Unfiltered")
-filterEngine = self.__helpEngine.filterEngine()
-if unfiltered not in filterEngine.filters():
-filterEngine.setFilterData(unfiltered, QHelpFilterData())
-self.__helpEngine.blockSignals(True)
-filterEngine.setActiveFilter(unfiltered)
-self.__helpEngine.blockSignals(False)
 def __warning(self, msg):
 """
 Private slot handling warnings from the help engine.
-@param msg message sent by the help  engine (string)
+@param msg message sent by the help  engine
+@type str
 """
 EricMessageBox.warning(
 self,
 self.tr("Help Engine"), msg)
+@pyqtSlot()
 def __aboutToShowSettingsMenu(self):
 """
 Private slot to show the Settings menu.
 """
 self.editMessageFilterAct.setEnabled(
 EricErrorMessage.messageHandlerInstalled())
+@pyqtSlot()
 def __clearPrivateData(self):
 """
 Private slot to clear the private data.
 """
 from .WebBrowserClearPrivateDataDialog import (
 self.passwordManager().clear()
 if zoomValues:
 ZoomManager.instance().clear()
 if sslExceptions:
 self.networkManager().clearSslExceptions()
+@pyqtSlot()
 def __showEnginesConfigurationDialog(self):
 """
 Private slot to show the search engines configuration dialog.
 """
 from .OpenSearch.OpenSearchDialog import OpenSearchDialog
 action.
 @return reference to the search engines configuration action (QAction)
 """
 return self.searchEnginesAct
+@pyqtSlot()
 def __showPasswordsDialog(self):
 """
 Private slot to show the passwords management dialog.
 """
 from .Passwords.PasswordsDialog import PasswordsDialog
 dlg = PasswordsDialog(self)
 dlg.exec()
+@pyqtSlot()
 def __showCertificateErrorsDialog(self):
 """
 Private slot to show the certificate errors management dialog.
 """
 self.networkManager().showSslErrorExceptionsDialog()
+@pyqtSlot()
 def __showAdBlockDialog(self):
 """
 Private slot to show the AdBlock configuration dialog.
 """
 self.adBlockManager().showDialog()
+@pyqtSlot()
 def __showPersonalInformationDialog(self):
 """
 Private slot to show the Personal Information configuration dialog.
 """
 self.personalInformationManager().showConfigurationDialog()
+@pyqtSlot()
 def __showGreaseMonkeyConfigDialog(self):
 """
 Private slot to show the GreaseMonkey scripts configuration dialog.
 """
 self.greaseMonkeyManager().showConfigurationDialog()
+@pyqtSlot()
 def __showFeaturePermissionDialog(self):
 """
 Private slot to show the feature permission dialog.
 """
 self.featurePermissionManager().showFeaturePermissionsDialog()
+@pyqtSlot()
 def __showZoomValuesDialog(self):
 """
 Private slot to show the zoom values management dialog.
 """
 from .ZoomManager.ZoomValuesDialog import ZoomValuesDialog
 dlg = ZoomValuesDialog(self)
 dlg.exec()
+@pyqtSlot()
 def __showDownloadsWindow(self):
 """
 Private slot to show the downloads dialog.
 """
 self.downloadManager().show()
+@pyqtSlot()
 def __showPageSource(self):
 """
 Private slot to show the source of the current page in an editor.
 """
 self.currentBrowser().page().toHtml(self.__showPageSourceCallback)
 editor = MiniEditor(parent=self)
 editor.setText(src, "Html")
 editor.setLanguage("dummy.html")
 editor.show()
+@pyqtSlot()
 def __toggleJavaScriptConsole(self):
 """
 Private slot to toggle the JavaScript console.
 """
 if self.__javascriptConsoleDock.isVisible():
 from .Bookmarks.BookmarksManager import BookmarksManager
 cls._bookmarksManager = BookmarksManager()
 return cls._bookmarksManager
+@pyqtSlot(QUrl)
+@pyqtSlot(QUrl, str)
 def openUrl(self, url, title=None):
 """
 Public slot to load a URL in the current tab.
-@param url URL to be opened (QUrl)
+@param url URL to be opened
-@param title title of the bookmark (string)
+@type QUrl
+@param title title of the bookmark
+@type str
 """
 self.__linkActivated(url)
+@pyqtSlot(QUrl)
+@pyqtSlot(QUrl, str)
 def openUrlNewTab(self, url, title=None):
 """
 Public slot to load a URL in a new tab.
-@param url URL to be opened (QUrl)
+@param url URL to be opened
-@param title title of the bookmark (string)
+@type QUrl
+@param title title of the bookmark
+@type str
 """
 self.newTab(url)
+@pyqtSlot(QUrl)
+@pyqtSlot(QUrl, str)
 def openUrlNewBackgroundTab(self, url, title=None):
 """
 Public slot to load a URL in a new background tab.
-@param url URL to be opened (QUrl)
+@param url URL to be opened
-@param title title of the bookmark (string)
+@type QUrl
+@param title title of the bookmark
+@type str
 """
 self.newTab(url, background=True)
+@pyqtSlot(QUrl)
+@pyqtSlot(QUrl, str)
 def openUrlNewWindow(self, url, title=None):
 """
 Public slot to load a URL in a new window.
-@param url URL to be opened (QUrl)
+@param url URL to be opened
-@param title title of the bookmark (string)
+@type QUrl
+@param title title of the bookmark
+@type str
 """
 self.newWindow(url)
+@pyqtSlot(QUrl)
+@pyqtSlot(QUrl, str)
 def openUrlNewPrivateWindow(self, url, title=None):
 """
 Public slot to load a URL in a new private window.
-@param url URL to be opened (QUrl)
+@param url URL to be opened
-@param title title of the bookmark (string)
+@type QUrl
+@param title title of the bookmark
+@type str
 """
 self.newPrivateWindow(url)
+@pyqtSlot()
 def __sendPageLink(self):
 """
 Private slot to send the link of the current page via email.
 """
 url = self.currentBrowser().url()
 for codec in codecNames:
 self.__createTextEncodingAction(codec, defaultCodec, menu)
 parentMenu.addMenu(menu)
+@pyqtSlot()
 def __aboutToShowTextEncodingMenu(self):
 """
 Private slot to populate the text encoding menu.
 """
 self.__textEncodingMenu.clear()
 self.__createTextEncodingSubmenu(self.tr("Apple"), macCodecs,
 self.__textEncodingMenu)
 self.__createTextEncodingSubmenu(self.tr("Other"), otherCodecs,
 self.__textEncodingMenu)
+@pyqtSlot(QAction)
 def __setTextEncoding(self, act):
 """
 Private slot to set the selected text encoding as the default for
 this session.
-@param act reference to the selected action (QAction)
+@param act reference to the selected action
+@type QAction
 """
 codec = act.data()
 if codec == "":
 self.webSettings().setDefaultTextEncoding("")
 else:
 menu.triggered.connect(self.__TBMenuTriggered)
 self.__populateToolbarsMenu(menu)
 return menu
+@pyqtSlot()
 def __showToolbarsMenu(self):
 """
 Private slot to display the Toolbars menu.
 """
 self.__populateToolbarsMenu(self.__toolbarsMenu)
 from .Feeds.FeedsManager import FeedsManager
 cls._feedsManager = FeedsManager()
 return cls._feedsManager
+@pyqtSlot()
 def __showFeedsManager(self):
 """
 Private slot to show the feeds manager dialog.
 """
 feedsManager = self.feedsManager()
 feedsManager.newBackgroundTab.disconnect(self.openUrlNewBackgroundTab)
 feedsManager.newWindow.disconnect(self.openUrlNewWindow)
 feedsManager.newPrivateWindow.disconnect(self.openUrlNewPrivateWindow)
 feedsManager.rejected.disconnect()
+@pyqtSlot()
 def __showSiteinfoDialog(self):
 """
 Private slot to show the site info dialog.
 """
 from .SiteInfo.SiteInfoDialog import SiteInfoDialog
 from .UserAgent.UserAgentManager import UserAgentManager
 cls._userAgentsManager = UserAgentManager()
 return cls._userAgentsManager
+@pyqtSlot()
 def __showUserAgentsDialog(self):
 """
 Private slot to show the user agents management dialog.
 """
 from .UserAgent.UserAgentsDialog import UserAgentsDialog
 from .Sync.SyncManager import SyncManager
 cls._syncManager = SyncManager()
 return cls._syncManager
+@pyqtSlot()
 def __showSyncDialog(self):
 """
 Private slot to show the synchronization dialog.
 """
 self.syncManager().showSyncDialog()
 ###########################################################################
 ## Interface to VirusTotal below                                         ##
 ###########################################################################
+@pyqtSlot()
 def __virusTotalScanCurrentSite(self):
 """
 Private slot to ask VirusTotal for a scan of the URL of the current
 browser.
 """
 @param url URL to be scanned (QUrl)
 """
 self.__virusTotal.submitUrl(url)
+@pyqtSlot(str)
 def __virusTotalSubmitUrlError(self, msg):
 """
 Private slot to handle an URL scan submission error.
-@param msg error message (str)
+@param msg error message
+@type str
 """
 EricMessageBox.critical(
 self,
 self.tr("VirusTotal Scan"),
 self.tr("""<p>The VirusTotal scan could not be"""
 """ scheduled.<p>\n<p>Reason: {0}</p>""").format(msg))
+@pyqtSlot(str)
 def __virusTotalUrlScanReport(self, url):
 """
 Private slot to initiate the display of the URL scan report page.
-@param url URL of the URL scan report page (string)
+@param url URL of the URL scan report page
+@type str
 """
 self.newTab(url)
+@pyqtSlot(str)
 def __virusTotalFileScanReport(self, url):
 """
 Private slot to initiate the display of the file scan report page.
-@param url URL of the file scan report page (string)
+@param url URL of the file scan report page
+@type str
 """
 self.newTab(url)
+@pyqtSlot()
 def __virusTotalIpAddressReport(self):
 """
 Private slot to retrieve an IP address report.
 """
 ip, ok = QInputDialog.getText(
 self,
 self.tr("IP Address Report"),
 self.tr("""The given IP address is not in dotted quad"""
 """ notation."""))
+@pyqtSlot()
 def __virusTotalDomainReport(self):
 """
 Private slot to retrieve a domain report.
 """
 domain, ok = QInputDialog.getText(
 from .Session.SessionManager import SessionManager
 cls._sessionManager = SessionManager()
 return cls._sessionManager
+@pyqtSlot()
 def __showSessionManagerDialog(self):
 """
 Private slot to show the session manager dialog.
 """
 self.sessionManager().showSessionManagerDialog()
 from .SafeBrowsing.SafeBrowsingManager import SafeBrowsingManager
 cls._safeBrowsingManager = SafeBrowsingManager()
 return cls._safeBrowsingManager
+@pyqtSlot()
 def __showSafeBrowsingDialog(self):
 """
 Private slot to show the safe browsing management dialog.
 """
 self.safeBrowsingManager().showSafeBrowsingDialog()
 from .Network.ProtocolHandlerManager import ProtocolHandlerManager
 cls._protocolHandlerManager = ProtocolHandlerManager()
 return cls._protocolHandlerManager
+@pyqtSlot()
 def __showProtocolHandlerManagerDialog(self):
 """
 Private slot to show the protocol handler manager dialog.
 """
 self.protocolHandlerManager().showProtocolHandlerManagerDialog()
 @param word word to be searched for
 @type str
 """
 if WebBrowserWindow._useQtHelp:
-self.__searchWord = word
+self.__searchForWord(word)
-self.__searchForWord()
 self.raise_()
 self.activateWindow()
 ######################################################
 ## Methods below implement shortcuts related functions
 ######################################################
+@pyqtSlot()
 def __configShortcuts(self):
 """
 Private slot to configure the keyboard shortcuts.
 """
 if self.__shortcutsDialog is None:
 from Preferences.ShortcutsDialog import ShortcutsDialog
 self.__shortcutsDialog = ShortcutsDialog(self)
 self.__shortcutsDialog.populate(helpViewer=self)
 self.__shortcutsDialog.show()
+@pyqtSlot()
 def __exportShortcuts(self):
 """
 Private slot to export the keyboard shortcuts.
 """
 fn, selectedFilter = EricFileDialog.getSaveFileNameAndFilter(
 )
 if ok:
 from Preferences import Shortcuts
 Shortcuts.exportShortcuts(fn, helpViewer=self)
+@pyqtSlot()
 def __importShortcuts(self):
 """
 Private slot to import the keyboard shortcuts.
 """
 fn = EricFileDialog.getOpenFileName(

Mercurial Repositories > eric / file comparison

comparison: eric7/WebBrowser/WebBrowserWindow.py

eric7/WebBrowser/WebBrowserWindow.py