eric: comparison Helpviewer/HelpWindow.py

-:671d0d55e5c8
+:c1726b754f96
 QHBoxLayout, QProgressBar, QAction, QIcon
 from PyQt4.QtNetwork import QNetworkAccessManager, QNetworkRequest
 from PyQt4.QtWebKit import QWebSettings, QWebDatabase, QWebSecurityOrigin, QWebPage
 from PyQt4.QtHelp import QHelpEngine, QHelpEngineCore, QHelpSearchQuery
-from .SearchWidget import SearchWidget
+from .Network.NetworkAccessManager import SSL_AVAILABLE
-from .HelpTocWidget import HelpTocWidget
-from .HelpIndexWidget import HelpIndexWidget
-from .HelpSearchWidget import HelpSearchWidget
-from .HelpTopicDialog import HelpTopicDialog
-from .QtHelpDocumentationDialog import QtHelpDocumentationDialog
-from .QtHelpFiltersDialog import QtHelpFiltersDialog
-from .HelpDocsInstaller import HelpDocsInstaller
-from .HelpWebSearchWidget import HelpWebSearchWidget
-from .HelpClearPrivateDataDialog import HelpClearPrivateDataDialog
-from .HelpLanguagesDialog import HelpLanguagesDialog
-from .PageScreenDialog import PageScreenDialog
-from .CookieJar.CookieJar import CookieJar
-from .CookieJar.CookiesConfigurationDialog import CookiesConfigurationDialog
-from .Bookmarks.BookmarksManager import BookmarksManager
-from .Bookmarks.BookmarksMenu import BookmarksMenuBarMenu
-from .Bookmarks.BookmarksToolBar import BookmarksToolBar
-from .Bookmarks.BookmarkNode import BookmarkNode
-from .Bookmarks.AddBookmarkDialog import AddBookmarkDialog
-from .Bookmarks.BookmarksDialog import BookmarksDialog
-from .History.HistoryManager import HistoryManager
-from .History.HistoryMenu import HistoryMenu
-from .Passwords.PasswordManager import PasswordManager
-from .Network.NetworkAccessManager import NetworkAccessManager, SSL_AVAILABLE
-from .AdBlock.AdBlockManager import AdBlockManager
-from .AdBlock.AdBlockIcon import AdBlockIcon
-from .OfflineStorage.OfflineStorageConfigDialog import OfflineStorageConfigDialog
-from .UserAgent.UserAgentMenu import UserAgentMenu
-from .UserAgent.UserAgentManager import UserAgentManager
-from .HelpBrowserWV import HelpBrowser
-from .HelpTabWidget import HelpTabWidget
-from .Download.DownloadManager import DownloadManager
-from .VirusTotalApi import VirusTotalAPI
-from .Feeds.FeedsManager import FeedsManager
-from .SiteInfo.SiteInfoDialog import SiteInfoDialog
-from .Sync.SyncManager import SyncManager
-from .SpeedDial.SpeedDial import SpeedDial
-from .PersonalInformationManager.PersonalInformationManager import \
-PersonalInformationManager
-from .GreaseMonkey.GreaseMonkeyManager import GreaseMonkeyManager
 from .data import icons_rc          # __IGNORE_WARNING__
 from .data import html_rc           # __IGNORE_WARNING__
 from .data import javascript_rc     # __IGNORE_WARNING__
 from E5Gui import E5MessageBox, E5FileDialog
 from E5Gui.E5MainWindow import E5MainWindow
 from E5Gui.E5Application import e5App
 from E5Gui.E5ZoomWidget import E5ZoomWidget
-from E5Network.E5NetworkMonitor import E5NetworkMonitor
 import Preferences
 from Preferences import Shortcuts
-from Preferences.ConfigurationDialog import ConfigurationDialog
 import Utilities
 import UI.PixmapCache
 import UI.Config
 from UI.Info import Version
-from UI.NotificationWidget import NotificationWidget
 class HelpWindow(E5MainWindow):
 """
 Class implementing the web browser main window.
 self.__eventKeyboardModifiers = Qt.NoModifier
 if self.initShortcutsOnly:
 self.__initActions()
 else:
+from .SearchWidget import SearchWidget
+from .HelpTocWidget import HelpTocWidget
+from .HelpIndexWidget import HelpIndexWidget
+from .HelpSearchWidget import HelpSearchWidget
+from .HelpBrowserWV import HelpBrowser
+from .HelpTabWidget import HelpTabWidget
+from .AdBlock.AdBlockIcon import AdBlockIcon
+from .VirusTotalApi import VirusTotalAPI
 if not self.fromEric:
 self.setStyle(Preferences.getUI("Style"), Preferences.getUI("StyleSheet"))
 self.__helpEngine = \
 QHelpEngine(os.path.join(Utilities.getConfigDir(),
 menu.addAction(self.stopAct)
 menu.addAction(self.reloadAct)
 menu.addSeparator()
 menu.addAction(self.syncTocAct)
+from .History.HistoryMenu import HistoryMenu
 self.historyMenu = HistoryMenu(self, self.tabWidget)
 self.historyMenu.setTearOffEnabled(True)
 self.historyMenu.setTitle(self.trUtf8('H&istory'))
 self.historyMenu.openUrl.connect(self.openUrl)
 self.historyMenu.newUrl.connect(self.openUrlNewTab)
 mb.addMenu(self.historyMenu)
+from .Bookmarks.BookmarksMenu import BookmarksMenuBarMenu
 self.bookmarksMenu = BookmarksMenuBarMenu(self)
 self.bookmarksMenu.setTearOffEnabled(True)
 self.bookmarksMenu.setTitle(self.trUtf8('&Bookmarks'))
 self.bookmarksMenu.openUrl.connect(self.openUrl)
 self.bookmarksMenu.newUrl.connect(self.openUrlNewTab)
 menu.addAction(self.certificatesAct)
 menu.addSeparator()
 menu.addAction(self.adblockAct)
 menu.addAction(self.flashblockAct)
 menu.addSeparator()
+from .UserAgent.UserAgentMenu import UserAgentMenu
 self.__userAgentMenu = UserAgentMenu(self.trUtf8("Global User Agent"))
 menu.addMenu(self.__userAgentMenu)
 menu.addAction(self.userAgentManagerAct)
 menu.addSeparator()
 menu.addAction(self.manageQtHelpDocsAct)
 menu.addAction(self.manageQtHelpFiltersAct)
 menu.addAction(self.reindexDocumentationAct)
 menu.addSeparator()
 menu.addAction(self.clearPrivateDataAct)
 gotb.addSeparator()
 self.__navigationSplitter = QSplitter(gotb)
 self.__navigationSplitter.addWidget(self.tabWidget.stackedUrlBar())
+from .HelpWebSearchWidget import HelpWebSearchWidget
 self.searchEdit = HelpWebSearchWidget(self)
 sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
 sizePolicy.setHorizontalStretch(2)
 sizePolicy.setVerticalStretch(0)
 self.searchEdit.setSizePolicy(sizePolicy)
 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)
 def __savePageScreen(self):
 """
 Private slot to save the current page as a screen shot.
 """
+from .PageScreenDialog import PageScreenDialog
 self.__pageScreen = PageScreenDialog(self.currentBrowser())
 self.__pageScreen.show()
 def __about(self):
 """
 description = ""
 meta = view.page().mainFrame().metaData()
 if "description" in meta:
 description = meta["description"][0]
+from .Bookmarks.AddBookmarkDialog import AddBookmarkDialog
 dlg = AddBookmarkDialog()
 dlg.setUrl(url)
 dlg.setTitle(title)
 dlg.setDescription(description)
 menu = self.bookmarksManager().menu()
 def __addBookmarkFolder(self):
 """
 Private slot to add a new bookmarks folder.
 """
+from .Bookmarks.AddBookmarkDialog import AddBookmarkDialog
 dlg = AddBookmarkDialog()
 menu = self.bookmarksManager().menu()
 idx = self.bookmarksManager().bookmarksModel().nodeIndex(menu)
 dlg.setCurrentIndex(idx)
 dlg.setFolder(True)
 def __showBookmarksDialog(self):
 """
 Private slot to show the bookmarks dialog.
 """
+from .Bookmarks.BookmarksDialog import BookmarksDialog
 self.__bookmarksDialog = BookmarksDialog(self)
 self.__bookmarksDialog.setAttribute(Qt.WA_DeleteOnClose)
 self.__bookmarksDialog.openUrl.connect(self.openUrl)
 self.__bookmarksDialog.newUrl.connect(self.openUrlNewTab)
 self.__bookmarksDialog.show()
 def bookmarkAll(self):
 """
 Public slot to bookmark all open tabs.
 """
+from .Bookmarks.AddBookmarkDialog import AddBookmarkDialog
 dlg = AddBookmarkDialog()
 dlg.setFolder(True)
 dlg.setTitle(self.trUtf8("Saved Tabs"))
 dlg.exec_()
 folder = dlg.addedNode()
 if folder is None:
 return
+from .Bookmarks.BookmarkNode import BookmarkNode
 for browser in self.tabWidget.browsers():
 bookmark = BookmarkNode(BookmarkNode.Bookmark)
 bookmark.url = bytes(browser.url().toEncoded()).decode()
 bookmark.title = browser.title()
 meta = browser.page().mainFrame().metaData()
 def __showPreferences(self):
 """
 Private slot to set the preferences.
 """
+from Preferences.ConfigurationDialog import ConfigurationDialog
 dlg = ConfigurationDialog(self, 'Configuration', True,
 fromEric=self.fromEric,
 displayMode=ConfigurationDialog.HelpBrowserMode)
 dlg.preferencesChanged.connect(self.preferencesChanged)
 dlg.masterPasswordChanged.connect(self.masterPasswordChanged)
 Public slot to handle the change of the master password.
 @param oldPassword current master password (string)
 @param newPassword new master password (string)
 """
+from Preferences.ConfigurationDialog import ConfigurationDialog
 self.passwordManager().masterPasswordChanged(oldPassword, newPassword)
 if self.fromEric and isinstance(self.sender(), ConfigurationDialog):
 # we were called from our local configuration dialog
 Preferences.convertPasswords(oldPassword, newPassword)
 Utilities.crypto.changeRememberedMaster(newPassword)
 def __showAcceptedLanguages(self):
 """
 Private slot to configure the accepted languages for web pages.
 """
+from .HelpLanguagesDialog import HelpLanguagesDialog
 dlg = HelpLanguagesDialog(self)
 dlg.exec_()
 self.networkAccessManager().languagesChanged()
 def __showCookiesConfiguration(self):
 """
 Private slot to configure the cookies handling.
 """
+from .CookieJar.CookiesConfigurationDialog import CookiesConfigurationDialog
 dlg = CookiesConfigurationDialog(self)
 dlg.exec_()
 def __showOfflineStorageConfiguration(self):
 """
 Private slot to configure the offline storage.
 """
+from .OfflineStorage.OfflineStorageConfigDialog import OfflineStorageConfigDialog
 dlg = OfflineStorageConfigDialog(self)
 if dlg.exec_() == QDialog.Accepted:
 dlg.storeData()
 self.__initWebSettings()
 Class method to get a reference to the network access manager.
 @return reference to the network access manager (NetworkAccessManager)
 """
 if cls._networkAccessManager is None:
+from .Network.NetworkAccessManager import NetworkAccessManager
+from .CookieJar.CookieJar import CookieJar
 cls._networkAccessManager = \
 NetworkAccessManager(cls.helpEngine())
 cls._cookieJar = CookieJar()
 cls._networkAccessManager.setCookieJar(cls._cookieJar)
 @param links dictionary with help topic as key (string) and
 URL as value (QUrl)
 @param keyword keyword for the link set (string)
 """
 if not self.__activating:
+from .HelpTopicDialog import HelpTopicDialog
 self.__activating = True
 dlg = HelpTopicDialog(self, keyword, links)
 if dlg.exec_() == QDialog.Accepted:
 self.currentBrowser().setSource(dlg.link())
 self.__activating = False
 def __manageQtHelpDocumentation(self):
 """
 Private slot to manage the QtHelp documentation database.
 """
+from .QtHelpDocumentationDialog import QtHelpDocumentationDialog
 dlg = QtHelpDocumentationDialog(self.__helpEngine, self)
 dlg.exec_()
 if dlg.hasChanges():
 for i in sorted(dlg.getTabsToClose(), reverse=True):
 self.tabWidget.closeBrowserAt(i)
 def __manageQtHelpFilters(self):
 """
 Private slot to manage the QtHelp filters.
 """
+from .QtHelpFiltersDialog import QtHelpFiltersDialog
 dlg = QtHelpFiltersDialog(self.__helpEngine, self)
 dlg.exec_()
 def __indexingStarted(self):
 """
 def __lookForNewDocumentation(self):
 """
 Private slot to look for new documentation to be loaded into the
 help database.
 """
+from .HelpDocsInstaller import HelpDocsInstaller
 self.__helpInstaller = HelpDocsInstaller(self.__helpEngine.collectionFile())
 self.__helpInstaller.errorMessage.connect(self.__showInstallationError)
 self.__helpInstaller.docsInstalled.connect(self.__docsInstalled)
 self.statusBar().showMessage(self.trUtf8("Looking for Documentation..."))
 def __clearPrivateData(self):
 """
 Private slot to clear the private data.
 """
+from .HelpClearPrivateDataDialog import HelpClearPrivateDataDialog
 dlg = HelpClearPrivateDataDialog(self)
 if dlg.exec_() == QDialog.Accepted:
 # browsing history, search history, favicons, disk cache, cookies,
 # passwords, web databases, downloads
 (history, searches, favicons, cache, cookies,
 else:
 for securityOrigin in QWebSecurityOrigin.allOrigins():
 for database in securityOrigin.databases():
 QWebDatabase.removeDatabase(database)
 if flashCookies:
+from .HelpLanguagesDialog import HelpLanguagesDialog
 languages = Preferences.toList(
 Preferences.Prefs.settings.value("Help/AcceptLanguages",
 HelpLanguagesDialog.defaultAcceptLanguages()))
 if languages:
 language = languages[0]
 def __showNetworkMonitor(self):
 """
 Private slot to show the network monitor dialog.
 """
+from E5Network.E5NetworkMonitor import E5NetworkMonitor
 monitor = E5NetworkMonitor.instance(self.networkAccessManager())
 monitor.show()
 def __showDownloadsWindow(self):
 """
 def __closeNetworkMonitor(self):
 """
 Private slot to close the network monitor dialog.
 """
+from E5Network.E5NetworkMonitor import E5NetworkMonitor
 E5NetworkMonitor.closeMonitor()
 def __showPageSource(self):
 """
 Private slot to show the source of the current page in  an editor.
 Class method to get a reference to the bookmarks manager.
 @return reference to the bookmarks manager (BookmarksManager)
 """
 if cls._bookmarksManager is None:
+from .Bookmarks.BookmarksManager import BookmarksManager
 cls._bookmarksManager = BookmarksManager()
 return cls._bookmarksManager
 def openUrl(self, url, title):
 Class method to get a reference to the history manager.
 @return reference to the history manager (HistoryManager)
 """
 if cls._historyManager is None:
+from .History.HistoryManager import HistoryManager
 cls._historyManager = HistoryManager()
 return cls._historyManager
 @classmethod
 Class method to get a reference to the password manager.
 @return reference to the password manager (PasswordManager)
 """
 if cls._passwordManager is None:
+from .Passwords.PasswordManager import PasswordManager
 cls._passwordManager = PasswordManager()
 return cls._passwordManager
 @classmethod
 Class method to get a reference to the AdBlock manager.
 @return reference to the AdBlock manager (AdBlockManager)
 """
 if cls._adblockManager is None:
+from .AdBlock.AdBlockManager import AdBlockManager
 cls._adblockManager = AdBlockManager()
 return cls._adblockManager
 def adBlockIcon(self):
 Class method to get a reference to the download manager.
 @return reference to the password manager (DownloadManager)
 """
 if cls._downloadManager is None:
+from .Download.DownloadManager import DownloadManager
 cls._downloadManager = DownloadManager()
 return cls._downloadManager
 @classmethod
 Class method to get a reference to the personal information manager.
 @return reference to the personal information manager (PersonalInformationManager)
 """
 if cls._personalInformationManager is None:
+from .PersonalInformationManager.PersonalInformationManager import \
+PersonalInformationManager
 cls._personalInformationManager = PersonalInformationManager()
 return cls._personalInformationManager
 @classmethod
 Class method to get a reference to the GreaseMonkey manager.
 @return reference to the GreaseMonkey manager (GreaseMonkeyManager)
 """
 if cls._greaseMonkeyManager is None:
+from .GreaseMonkey.GreaseMonkeyManager import GreaseMonkeyManager
 cls._greaseMonkeyManager = GreaseMonkeyManager()
 return cls._greaseMonkeyManager
 @classmethod
 Class method to get a reference to the RSS feeds manager.
 @return reference to the RSS feeds manager (FeedsManager)
 """
 if cls._feedsManager is None:
+from .Feeds.FeedsManager import FeedsManager
 cls._feedsManager = FeedsManager()
 return cls._feedsManager
 def __showFeedsManager(self):
 def __showSiteinfoDialog(self):
 """
 Private slot to show the site info dialog.
 """
+from .SiteInfo.SiteInfoDialog import SiteInfoDialog
 self.__siteinfoDialog = SiteInfoDialog(self.currentBrowser(), self)
 self.__siteinfoDialog.setAttribute(Qt.WA_DeleteOnClose)
 self.__siteinfoDialog.show()
 @classmethod
 Class method to get a reference to the user agents manager.
 @return reference to the user agents manager (UserAgentManager)
 """
 if cls._userAgentsManager is None:
+from .UserAgent.UserAgentManager import UserAgentManager
 cls._userAgentsManager = UserAgentManager()
 return cls._userAgentsManager
 def __showUserAgentsDialog(self):
 Class method to get a reference to the data synchronization manager.
 @return reference to the data synchronization manager (SyncManager)
 """
 if cls._syncManager is None:
+from .Sync.SyncManager import SyncManager
 cls._syncManager = SyncManager()
 return cls._syncManager
 def __showSyncDialog(self):
 Class methdo to get a reference to the speed dial.
 @return reference to the speed dial (SpeedDial)
 """
 if cls._speedDial is None:
+from .SpeedDial.SpeedDial import SpeedDial
 cls._speedDial = SpeedDial()
 return cls._speedDial
 def keyPressEvent(self, evt):
 """
 Private slot to search VirusTotal for a given entry.
 """
 search = self.virustotalSearchEdit.text()
 if search:
+from .VirusTotalApi import VirusTotalAPI
 requestData = VirusTotalAPI.getSearchRequestData(search)
 self.newTab(requestData=requestData)
 def __virusTotalScanCurrentSite(self):
 """
 if cls._fromEric:
 e5App().getObject("UserInterface").showNotification(icon, heading, text)
 else:
 if Preferences.getUI("NotificationsEnabled"):
 if cls._notification is None:
+from UI.NotificationWidget import NotificationWidget
 cls._notification = NotificationWidget()
 cls._notification.setPixmap(icon)
 cls._notification.setHeading(heading)
 cls._notification.setText(text)
 cls._notification.setTimeout(Preferences.getUI("NotificationTimeout"))

Mercurial Repositories > eric / file comparison

comparison: Helpviewer/HelpWindow.py

Helpviewer/HelpWindow.py