eric: comparison WebBrowser/WebBrowserWindow.py

-:b4d0cddecd64
+:433187e73c0f
 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
 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()
 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'),
 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)
-self.__toolbars.append(gotb)
-self.__gotb = gotb
-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.__toolbars.append(self.bookmarksToolBar)
-self.addToolBarBreak()
 vttb = self.addToolBar(self.tr("VirusTotal"))
 vttb.setObjectName("VirusTotalToolBar")
 vttb.setIconSize(UI.Config.ToolBarIconSize)
 vttb.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
 self.virustotalScanCurrentAct = vttb.addAction(
 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
 self.__htmlFullScreen = True
 def isFullScreenNavigationVisible(self):
 """
 Public method to check, if full screen navigation is active.
-"""
-# TODO: change this to navigation widget
+@return flag indicating visibility of the navigation container in full
-return self.isFullScreen() and self.__gotb.isVisible()
+screen mode
+@rtype bool
+"""
+return self.isFullScreen() and self.__navigationContainer.isVisible()
 def showFullScreenNavigation(self):
 """
 Public slot to show full screen navigation.
 """
 return
 if self.__hideNavigationTimer.isActive():
 self.__hideNavigationTimer.stop()
-# TODO: change this to navigation widget
+self.__navigationContainer.show()
-self.__gotb.show()
 def hideFullScreenNavigation(self):
 """
 Public slot to hide full screen navigation.
 """
 """
 browser = self.currentBrowser()
 mouseInBrowser = browser and browser.underMouse()
 if self.isFullScreen() and mouseInBrowser:
-# TODO: change this to navigation widget
+self.__navigationContainer.hide()
-self.__gotb.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.
 """
 # 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.__tabWidget.tabBar().hide()
+self.__navigationBar.exitFullScreenButton().setVisible(True)
-self.__searchWidget.hide()
+self.__navigationContainer.hide()
-##                self.fullScreenAct.setIcon(
-##                    UI.PixmapCache.getIcon("windowRestore.png"))
-##                self.fullScreenAct.setIconText(self.tr('Restore Window'))
 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.fullScreenAct.setIcon(
+self.__navigationBar.exitFullScreenButton().setVisible(False)
-##                    UI.PixmapCache.getIcon("windowFullscreen.png"))
+self.__navigationContainer.show()
-##                self.fullScreenAct.setIconText(self.tr('Full Screen'))
 if self.__hideNavigationTimer:
 self.__hideNavigationTimer.stop()
 return super(WebBrowserWindow, self).event(evt)

Mercurial Repositories > eric / file comparison

comparison: WebBrowser/WebBrowserWindow.py

WebBrowser/WebBrowserWindow.py