eric: comparison WebBrowser/WebBrowserWindow.py

-:9a71bd9e2e37
+:6422afc7adc4
 from PyQt5.QtCore import pyqtSlot, pyqtSignal, Qt, QByteArray, QSize, QTimer, \
 QUrl, QTextCodec, QProcess, QEvent, qVersion
 from PyQt5.QtGui import QDesktopServices, QKeySequence, QFont, QFontMetrics
 from PyQt5.QtWidgets import QWidget, QVBoxLayout, QSizePolicy, QDockWidget, \
-QComboBox, QLabel, QSplitter, QMenu, QToolButton, QLineEdit, \
+QComboBox, QLabel, QMenu, QToolButton, QLineEdit, QApplication, \
-QApplication, QWhatsThis, QDialog, QHBoxLayout, QProgressBar, QAction, \
+QWhatsThis, QDialog, QHBoxLayout, QProgressBar, QInputDialog
-QInputDialog
 from PyQt5.QtWebEngineWidgets import QWebEngineSettings, QWebEnginePage, \
 QWebEngineProfile, QWebEngineScript
 try:
 from PyQt5.QtHelp import QHelpEngine, QHelpEngineCore, QHelpSearchQuery
 QTHELP_AVAILABLE = True
 @keyparam searchWord word to search for (string)
 @keyparam private flag indicating a private browsing window (bool)
 @keyparam qthelp flag indicating to enable the QtHelp support (bool)
 @keyparam settingsDir directory to be used for the settings files (str)
 """
+self.__hideNavigationTimer = None
 super(WebBrowserWindow, self).__init__(parent)
 self.setObjectName(name)
 if private:
 self.setWindowTitle(self.tr("eric6 Web Browser (Private Mode)"))
 else:
 from .WebBrowserTabWidget import WebBrowserTabWidget
 from .AdBlock.AdBlockIcon import AdBlockIcon
 from .StatusBar.JavaScriptIcon import JavaScriptIcon
 from .StatusBar.ImagesIcon import ImagesIcon
 from .VirusTotal.VirusTotalApi import VirusTotalAPI
+from .Navigation.NavigationBar import NavigationBar
+from .Navigation.NavigationContainer import NavigationContainer
+from .Bookmarks.BookmarksToolBar import BookmarksToolBar
 if not self.__fromEric:
 self.setStyle(Preferences.getUI("Style"),
 Preferences.getUI("StyleSheet"))
 self.__zoomWidget.setValue)
 self.__tabWidget.browserClosed.connect(self.webBrowserClosed)
 self.__tabWidget.browserOpened.connect(self.webBrowserOpened)
 self.__searchWidget = SearchWidget(self, self)
+self.__setIconDatabasePath()
+bookmarksModel = self.bookmarksManager().bookmarksModel()
+self.__bookmarksToolBar = BookmarksToolBar(self, bookmarksModel,
+self)
+self.__bookmarksToolBar.setIconSize(UI.Config.ToolBarIconSize)
+self.__bookmarksToolBar.openUrl.connect(self.openUrl)
+self.__bookmarksToolBar.newTab.connect(self.openUrlNewTab)
+self.__bookmarksToolBar.newWindow.connect(self.openUrlNewWindow)
+self.__navigationBar = NavigationBar(self)
+self.__navigationContainer = NavigationContainer(self)
+self.__navigationContainer.addWidget(self.__navigationBar)
+self.__navigationContainer.addWidget(self.__bookmarksToolBar)
 centralWidget = QWidget()
 layout = QVBoxLayout()
 layout.setContentsMargins(1, 1, 1, 1)
+layout.setSpacing(0)
+layout.addWidget(self.__navigationContainer)
 layout.addWidget(self.__tabWidget)
 layout.addWidget(self.__searchWidget)
 self.__tabWidget.setSizePolicy(
 QSizePolicy.Preferred, QSizePolicy.Expanding)
 centralWidget.setLayout(layout)
 else:
 self.restoreGeometry(g)
 WebBrowserWindow.BrowserWindows.append(self)
-self.__setIconDatabasePath()
 self.__initWebEngineSettings()
 # initialize some of our class objects
 self.passwordManager()
 self.historyManager()
 if self.__searchWord is not None:
 QTimer.singleShot(0, self.__searchForWord)
 e5App().focusChanged.connect(self.__appFocusChanged)
+self.__toolbarStates = self.saveState()
+self.__hideNavigationTimer = QTimer(self)
+self.__hideNavigationTimer.setInterval(1000)
+self.__hideNavigationTimer.setSingleShot(True)
+self.__hideNavigationTimer.timeout.connect(self.__hideNavigation)
 QTimer.singleShot(0, syncMgr.loadSettings)
 def __del__(self):
 """
 Special method called during object destruction.
 UI.PixmapCache.getIcon("home.png"),
 self.tr('&Home'),
 QKeySequence(self.tr("Ctrl+Home", "Go|Home")),
 0, self, 'webbrowser_go_home')
 self.homeAct.setStatusTip(self.tr(
-'Move to the initial help screen'))
+'Move to the initial screen'))
 self.homeAct.setWhatsThis(self.tr(
 """<b>Home</b>"""
 """<p>Moves to the initial screen.</p>"""
 ))
 if not self.__initShortcutsOnly:
 self.fullScreenAct = E5Action(
 self.tr('Full Screen'),
 UI.PixmapCache.getIcon("windowFullscreen.png"),
 self.tr('&Full Screen'),
 QKeySequence(self.tr('F11')), 0,
-self, 'webbrowser_view_full_scree')
+self, 'webbrowser_view_full_screen')
 if not self.__initShortcutsOnly:
-self.fullScreenAct.triggered.connect(self.__viewFullScreen)
+self.fullScreenAct.triggered.connect(self.toggleFullScreen)
 self.__actions.append(self.fullScreenAct)
 self.addAction(self.fullScreenAct)
 self.nextTabAct = E5Action(
 self.tr('Show next tab'),
 def __initToolbars(self):
 """
 Private method to create the toolbars.
 """
+# save references to toolbars in order to hide them
+# when going full screen
+self.__toolbars = []
 filetb = self.addToolBar(self.tr("File"))
 filetb.setObjectName("FileToolBar")
 filetb.setIconSize(UI.Config.ToolBarIconSize)
 filetb.addAction(self.newTabAct)
 filetb.addAction(self.newAct)
 filetb.addAction(self.printPdfAct)
 if self.printPreviewAct or self.printAct or self.printPdfAct:
 filetb.addSeparator()
 filetb.addAction(self.closeAct)
 filetb.addAction(self.exitAct)
+self.__toolbars.append(filetb)
 self.savePageScreenMenu = QMenu(self)
 self.savePageScreenMenu.addAction(self.savePageScreenAct)
 self.savePageScreenMenu.addAction(self.saveVisiblePageScreenAct)
 savePageScreenButton = filetb.widgetForAction(self.savePageScreenAct)
 edittb.addAction(self.copyAct)
 edittb.addAction(self.cutAct)
 edittb.addAction(self.pasteAct)
 edittb.addSeparator()
 edittb.addAction(self.selectAllAct)
+self.__toolbars.append(edittb)
 viewtb = self.addToolBar(self.tr("View"))
 viewtb.setObjectName("ViewToolBar")
 viewtb.setIconSize(UI.Config.ToolBarIconSize)
 viewtb.addAction(self.zoomInAct)
 viewtb.addAction(self.zoomResetAct)
 viewtb.addAction(self.zoomOutAct)
 viewtb.addSeparator()
 viewtb.addAction(self.fullScreenAct)
+self.__toolbars.append(viewtb)
 findtb = self.addToolBar(self.tr("Find"))
 findtb.setObjectName("FindToolBar")
 findtb.setIconSize(UI.Config.ToolBarIconSize)
 findtb.addAction(self.findAct)
 findtb.addAction(self.findNextAct)
 findtb.addAction(self.findPrevAct)
+self.__toolbars.append(findtb)
 if WebBrowserWindow._useQtHelp:
 filtertb = self.addToolBar(self.tr("Filter"))
 filtertb.setObjectName("FilterToolBar")
 self.filterCombo = QComboBox()
 filtertb.addWidget(self.filterCombo)
 self.__helpEngine.setupFinished.connect(self.__setupFilterCombo)
 self.filterCombo.activated[str].connect(
 self.__filterQtHelpDocumentation)
 self.__setupFilterCombo()
+self.__toolbars.append(filtertb)
 settingstb = self.addToolBar(self.tr("Settings"))
 settingstb.setObjectName("SettingsToolBar")
 settingstb.setIconSize(UI.Config.ToolBarIconSize)
 settingstb.addAction(self.prefAct)
 settingstb.addAction(self.cookiesAct)
 settingstb.addAction(self.flashCookiesAct)
 settingstb.addAction(self.personalDataAct)
 settingstb.addAction(self.greaseMonkeyAct)
 settingstb.addAction(self.featurePermissionAct)
+self.__toolbars.append(settingstb)
 toolstb = self.addToolBar(self.tr("Tools"))
 toolstb.setObjectName("ToolsToolBar")
 toolstb.setIconSize(UI.Config.ToolBarIconSize)
 toolstb.addAction(self.feedsManagerAct)
 toolstb.addAction(self.siteInfoAct)
 toolstb.addSeparator()
 toolstb.addAction(self.synchronizationAct)
+self.__toolbars.append(toolstb)
 helptb = self.addToolBar(self.tr("Help"))
 helptb.setObjectName("HelpToolBar")
 helptb.setIconSize(UI.Config.ToolBarIconSize)
 helptb.addAction(self.whatsThisAct)
+self.__toolbars.append(helptb)
-self.addToolBarBreak()
-gotb = self.addToolBar(self.tr("Go"))
-gotb.setObjectName("GoToolBar")
-gotb.setIconSize(UI.Config.ToolBarIconSize)
-gotb.addAction(self.backAct)
-gotb.addAction(self.forwardAct)
-gotb.addAction(self.reloadAct)
-gotb.addAction(self.stopAct)
-gotb.addAction(self.homeAct)
-gotb.addSeparator()
-self.__navigationSplitter = QSplitter(gotb)
-self.__navigationSplitter.addWidget(self.__tabWidget.stackedUrlBar())
-from .WebBrowserWebSearchWidget import WebBrowserWebSearchWidget
-self.searchEdit = WebBrowserWebSearchWidget(self)
-sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
-sizePolicy.setHorizontalStretch(2)
-sizePolicy.setVerticalStretch(0)
-self.searchEdit.setSizePolicy(sizePolicy)
-self.searchEdit.search.connect(self.__linkActivated)
-self.__navigationSplitter.addWidget(self.searchEdit)
-gotb.addWidget(self.__navigationSplitter)
-self.__navigationSplitter.setSizePolicy(
-QSizePolicy.Expanding, QSizePolicy.Maximum)
-self.__navigationSplitter.setCollapsible(0, False)
-self.backMenu = QMenu(self)
-self.backMenu.aboutToShow.connect(self.__showBackMenu)
-self.backMenu.triggered.connect(self.__navigationMenuActionTriggered)
-backButton = gotb.widgetForAction(self.backAct)
-backButton.setMenu(self.backMenu)
-backButton.setPopupMode(QToolButton.MenuButtonPopup)
-self.forwardMenu = QMenu(self)
-self.forwardMenu.aboutToShow.connect(self.__showForwardMenu)
-self.forwardMenu.triggered.connect(
-self.__navigationMenuActionTriggered)
-forwardButton = gotb.widgetForAction(self.forwardAct)
-forwardButton.setMenu(self.forwardMenu)
-forwardButton.setPopupMode(QToolButton.MenuButtonPopup)
-from .Bookmarks.BookmarksToolBar import BookmarksToolBar
-bookmarksModel = self.bookmarksManager().bookmarksModel()
-self.bookmarksToolBar = BookmarksToolBar(self, bookmarksModel, self)
-self.bookmarksToolBar.setObjectName("BookmarksToolBar")
-self.bookmarksToolBar.setIconSize(UI.Config.ToolBarIconSize)
-self.bookmarksToolBar.openUrl.connect(self.openUrl)
-self.bookmarksToolBar.newTab.connect(self.openUrlNewTab)
-self.bookmarksToolBar.newWindow.connect(self.openUrlNewWindow)
-self.addToolBarBreak()
-self.addToolBar(self.bookmarksToolBar)
 self.addToolBarBreak()
 vttb = self.addToolBar(self.tr("VirusTotal"))
 vttb.setObjectName("VirusTotalToolBar")
 vttb.setIconSize(UI.Config.ToolBarIconSize)
 if not Preferences.getWebBrowser("VirusTotalEnabled") or \
 Preferences.getWebBrowser("VirusTotalServiceKey") == "":
 self.virustotalScanCurrentAct.setEnabled(False)
 self.virustotalIpReportAct.setEnabled(False)
 self.virustotalDomainReportAct.setEnabled(False)
+self.__toolbars.append(vttb)
 def __nextTab(self):
 """
 Private slot used to show the next tab.
 """
 Public slot called when backward references are available.
 @param b flag indicating availability of the backwards action (boolean)
 """
 self.backAct.setEnabled(b)
+self.__navigationBar.backButton().setEnabled(b)
 def setForwardAvailable(self, b):
 """
 Public slot called when forward references are available.
 @param b flag indicating the availability of the forwards action
 (boolean)
 """
 self.forwardAct.setEnabled(b)
+self.__navigationBar.forwardButton().setEnabled(b)
 def setLoadingActions(self, b):
 """
 Public slot to set the loading dependent actions.
 @param b flag indicating the loading state to consider (boolean)
 """
 self.reloadAct.setEnabled(not b)
 self.stopAct.setEnabled(b)
+self.__navigationBar.reloadButton().setEnabled(not b)
+self.__navigationBar.stopButton().setEnabled(b)
 def __addBookmark(self):
 """
 Private slot called to add the displayed file to the bookmarks.
 """
 self.downloadManager().shutdown()
 self.cookieJar().close()
-self.bookmarksToolBar.setModel(None)
+self.__bookmarksToolBar.setModel(None)
 self.bookmarksManager().close()
 self.historyManager().close()
 self.passwordManager().close()
 self.__virusTotal.close()
 self.flashCookieManager().shutdown()
-self.searchEdit.openSearchManager().close()
+self.__navigationBar.searchEdit().openSearchManager().close()
 if len(WebBrowserWindow.BrowserWindows) == 1:
 # it is the last window
 self.tabManager().close()
 self.__searchEngine.cancelSearching()
 if self.__helpInstaller:
 self.__helpInstaller.stop()
-self.searchEdit.saveSearches()
+self.__navigationBar.searchEdit().saveSearches()
 self.__tabWidget.closeAllBrowsers(shutdown=True)
 state = self.saveState()
 Preferences.setWebBrowser("WebBrowserState", state)
 Private slot called to handle the zoom reset action.
 """
 self.currentBrowser().zoomReset()
 self.__zoomWidget.setValue(self.currentBrowser().zoomValue())
-def __viewFullScreen(self):
+def toggleFullScreen(self):
 """
-Private slot called to toggle fullscreen mode.
+Public slot called to toggle the full screen mode.
 """
 if self.__htmlFullScreen:
 self.currentBrowser().triggerPageAction(
 QWebEnginePage.ExitFullScreen)
 return
 if self.isFullScreen():
 # switch back to normal
 self.showNormal()
-self.menuBar().show()
-self.fullScreenAct.setIcon(
-UI.PixmapCache.getIcon("windowFullscreen.png"))
-self.fullScreenAct.setIconText(self.tr('Full Screen'))
 else:
 # switch to full screen
 self.showFullScreen()
-self.menuBar().hide()
-self.fullScreenAct.setIcon(
-UI.PixmapCache.getIcon("windowRestore.png"))
-self.fullScreenAct.setIconText(self.tr('Restore Window'))
 def enterHtmlFullScreen(self):
 """
 Public method to switch to full screen initiated by the
 HTML page.
 """
 self.showFullScreen()
 self.__htmlFullScreen = True
+def isFullScreenNavigationVisible(self):
+"""
+Public method to check, if full screen navigation is active.
+@return flag indicating visibility of the navigation container in full
+screen mode
+@rtype bool
+"""
+return self.isFullScreen() and self.__navigationContainer.isVisible()
+def showFullScreenNavigation(self):
+"""
+Public slot to show full screen navigation.
+"""
+if self.__htmlFullScreen:
+return
+if self.__hideNavigationTimer.isActive():
+self.__hideNavigationTimer.stop()
+self.__navigationContainer.show()
+def hideFullScreenNavigation(self):
+"""
+Public slot to hide full screen navigation.
+"""
+if not self.__hideNavigationTimer.isActive():
+self.__hideNavigationTimer.start()
+def __hideNavigation(self):
+"""
+Private slot to hide full screen navigation by timer.
+"""
+browser = self.currentBrowser()
+mouseInBrowser = browser and browser.underMouse()
+if self.isFullScreen() and mouseInBrowser:
+self.__navigationContainer.hide()
 def __copy(self):
 """
 Private slot called to handle the copy action.
 """
 self.historyManager().preferencesChanged()
 self.__tabWidget.preferencesChanged()
-self.searchEdit.preferencesChanged()
+self.__navigationBar.searchEdit().preferencesChanged()
 self.autoScroller().preferencesChanged()
 profile = self.webProfile()
 if not self.isPrivate():
 Private slot to show the Settings menu.
 """
 self.editMessageFilterAct.setEnabled(
 E5ErrorMessage.messageHandlerInstalled())
-def __showBackMenu(self):
-"""
-Private slot showing the backwards navigation menu.
-"""
-self.backMenu.clear()
-history = self.currentBrowser().history()
-historyCount = history.count()
-backItems = history.backItems(historyCount)
-for index in range(len(backItems) - 1, -1, -1):
-item = backItems[index]
-act = QAction(self)
-act.setData(-1 * (index + 1))
-icon = WebBrowserWindow.icon(item.url())
-act.setIcon(icon)
-act.setText(item.title())
-self.backMenu.addAction(act)
-def __showForwardMenu(self):
-"""
-Private slot showing the forwards navigation menu.
-"""
-self.forwardMenu.clear()
-history = self.currentBrowser().history()
-historyCount = history.count()
-forwardItems = history.forwardItems(historyCount)
-for index in range(len(forwardItems)):
-item = forwardItems[index]
-act = QAction(self)
-act.setData(index + 1)
-icon = WebBrowserWindow.icon(item.url())
-act.setIcon(icon)
-act.setText(item.title())
-self.forwardMenu.addAction(act)
-def __navigationMenuActionTriggered(self, act):
-"""
-Private slot to go to the selected page.
-@param act reference to the action selected in the navigation menu
-(QAction)
-"""
-offset = act.data()
-history = self.currentBrowser().history()
-historyCount = history.count()
-if offset < 0:
-# go back
-history.goToItem(history.backItems(historyCount)[-1 * offset - 1])
-else:
-# go forward
-history.goToItem(history.forwardItems(historyCount)[offset - 1])
 def __clearPrivateData(self):
 """
 Private slot to clear the private data.
 """
 from .WebBrowserClearPrivateDataDialog import \
 if history:
 self.historyManager().clear(historyPeriod)
 self.__tabWidget.clearClosedTabsList()
 self.webProfile().clearAllVisitedLinks()
 if searches:
-self.searchEdit.clear()
+self.__navigationBar.searchEdit().clear()
 if downloads:
 self.downloadManager().cleanup()
 self.downloadManager().hide()
 if favicons:
 self.__clearIconsDatabase()
 """
 Public method to get a reference to the opensearch manager object.
 @return reference to the opensearch manager object (OpenSearchManager)
 """
-return self.searchEdit.openSearchManager()
+return self.__navigationBar.searchEdit().openSearchManager()
 def __aboutToShowTextEncodingMenu(self):
 """
 Private slot to populate the text encoding menu.
 """
 if evt.type() == QEvent.WindowStateChange:
 if not bool(evt.oldState() & Qt.WindowFullScreen) and \
 bool(self.windowState() & Qt.WindowFullScreen):
 # enter full screen mode
 self.__windowStates = evt.oldState()
+self.__toolbarStates = self.saveState()
+self.menuBar().hide()
+self.statusBar().hide()
+self.__searchWidget.hide()
+self.__tabWidget.tabBar().hide()
+for toolbar in self.__toolbars:
+toolbar.hide()
+self.__navigationBar.exitFullScreenButton().setVisible(True)
+self.__navigationContainer.hide()
 elif bool(evt.oldState() & Qt.WindowFullScreen) and \
 not bool(self.windowState() & Qt.WindowFullScreen):
 # leave full screen mode
 self.setWindowState(self.__windowStates)
 self.__htmlFullScreen = False
+self.menuBar().show()
+self.statusBar().show()
+self.restoreState(self.__toolbarStates)
+self.__tabWidget.tabBar().show()
+self.__navigationBar.exitFullScreenButton().setVisible(False)
+self.__navigationContainer.show()
+if self.__hideNavigationTimer:
+self.__hideNavigationTimer.stop()
 return super(WebBrowserWindow, self).event(evt)
 ###########################################################################
 ## Interface to VirusTotal below                                         ##

Mercurial Repositories > eric / file comparison

comparison: WebBrowser/WebBrowserWindow.py

WebBrowser/WebBrowserWindow.py