eric: comparison eric7/WebBrowser/UrlBar/UrlBar.py

-:844c2713bf44
+:766e1566cb74
 Module implementing the URL bar widget.
 """
 from PyQt6.QtCore import pyqtSlot, Qt, QPointF, QUrl, QDateTime, QTimer, QPoint
 from PyQt6.QtGui import QColor, QPalette, QLinearGradient, QIcon
-from PyQt6.QtWidgets import QDialog, QApplication
+from PyQt6.QtWidgets import QDialog, QApplication, QLineEdit
 from PyQt6.QtWebEngineCore import QWebEnginePage
 try:
 from PyQt6.QtNetwork import QSslCertificate     # __IGNORE_EXCEPTION__
 except ImportError:
 QSslCertificate = None      # __IGNORE_WARNING__
-from EricWidgets.EricLineEdit import EricLineEdit, EricLineEditSide
+from EricWidgets.EricLineEdit import EricClearableLineEdit, EricLineEditSide
-from EricWidgets.EricLineEditButton import EricLineEditButton
 from WebBrowser.WebBrowserWindow import WebBrowserWindow
 from WebBrowser.SafeBrowsing.SafeBrowsingLabel import SafeBrowsingLabel
 import UI.PixmapCache
 import Preferences
 import Utilities
-class UrlBar(EricLineEdit):
+class UrlBar(EricClearableLineEdit):
 """
 Class implementing a line edit for entering URLs.
 """
 def __init__(self, mainWindow, parent=None):
 """
 Constructor
 @param mainWindow reference to the main window (WebBrowserWindow)
 @param parent reference to the parent widget (WebBrowserView)
 """
-EricLineEdit.__init__(self, parent)
+super().__init__(parent)
 self.setPlaceholderText(self.tr("Enter the URL here."))
 self.setWhatsThis(self.tr("Enter the URL here."))
 self.__mw = mainWindow
 self.__browser = None
 self.__sslLabel = SslLabel(self)
 self.addWidget(self.__sslLabel, EricLineEditSide.LEFT)
 self.__sslLabel.setVisible(False)
-self.__rssButton = EricLineEditButton(self)
+self.__rssAction = self.addAction(
-self.__rssButton.setIcon(UI.PixmapCache.getIcon("rss16"))
+UI.PixmapCache.getIcon("rss16"),
-self.addWidget(self.__rssButton, EricLineEditSide.RIGHT)
+QLineEdit.ActionPosition.TrailingPosition)
-self.__rssButton.setVisible(False)
+self.__rssAction.setVisible(False)
-self.__bookmarkButton = EricLineEditButton(self)
+self.__bookmarkAction = self.addAction(
-self.addWidget(self.__bookmarkButton, EricLineEditSide.RIGHT)
+self.__bmInactiveIcon,
-self.__bookmarkButton.setVisible(False)
+QLineEdit.ActionPosition.TrailingPosition)
+self.__bookmarkAction.setVisible(False)
-self.__clearButton = EricLineEditButton(self)
-self.__clearButton.setIcon(UI.PixmapCache.getIcon("clearLeft"))
-self.addWidget(self.__clearButton, EricLineEditSide.RIGHT)
-self.__clearButton.setVisible(False)
 self.__safeBrowsingLabel.clicked.connect(self.__showThreatInfo)
-self.__bookmarkButton.clicked.connect(self.__showBookmarkInfo)
+self.__bookmarkAction.triggered.connect(self.__showBookmarkInfo)
-self.__rssButton.clicked.connect(self.__rssClicked)
+self.__rssAction.triggered.connect(self.__rssTriggered)
-self.__clearButton.clicked.connect(self.clear)
-self.textChanged.connect(self.__textChanged)
 self.__mw.bookmarksManager().entryChanged.connect(
 self.__bookmarkChanged)
 self.__mw.bookmarksManager().entryAdded.connect(
 self.__bookmarkChanged)
 def __loadStarted(self):
 """
 Private slot to perform actions before the page is loaded.
 """
-self.__bookmarkButton.setVisible(False)
+self.__bookmarkAction.setVisible(False)
-self.__rssButton.setVisible(False)
+self.__rssAction.setVisible(False)
 self.__sslLabel.setVisible(False)
 def __checkBookmark(self):
 """
 Private slot to check the current URL for the bookmarked state.
 """
 manager = self.__mw.bookmarksManager()
 if manager.bookmarkForUrl(self.__browser.url()) is not None:
-self.__bookmarkButton.setIcon(self.__bmActiveIcon)
+self.__bookmarkAction.setIcon(self.__bmActiveIcon)
 bookmarks = manager.bookmarksForUrl(self.__browser.url())
 from WebBrowser.Bookmarks.BookmarkNode import BookmarkNode
 for bookmark in bookmarks:
 manager.setTimestamp(bookmark, BookmarkNode.TsVisited,
 QDateTime.currentDateTime())
 elif self.__mw.speedDial().pageForUrl(self.__browser.url()).url != "":
-self.__bookmarkButton.setIcon(self.__bmActiveIcon)
+self.__bookmarkAction.setIcon(self.__bmActiveIcon)
 else:
-self.__bookmarkButton.setIcon(self.__bmInactiveIcon)
+self.__bookmarkAction.setIcon(self.__bmInactiveIcon)
 def __loadFinished(self, ok):
 """
 Private slot to set some data after the page was loaded.
 @param ok flag indicating a successful load (boolean)
 """
 if self.__browser.url().scheme() in ["eric", "about"]:
-self.__bookmarkButton.setVisible(False)
+self.__bookmarkAction.setVisible(False)
 else:
 self.__checkBookmark()
-self.__bookmarkButton.setVisible(True)
+self.__bookmarkAction.setVisible(True)
 self.__browserUrlChanged(self.__browser.url())
 self.__safeBrowsingLabel.setVisible(
 not self.__browser.getSafeBrowsingStatus())
 if ok:
 QTimer.singleShot(0, self.__setRssButton)
-def __textChanged(self, txt):
-"""
-Private slot to handle changes of the text.
-@param txt current text (string)
-"""
-self.__clearButton.setVisible(txt != "")
 def preferencesChanged(self):
 """
 Public slot to handle a change of preferences.
 """
 self.update()
+@pyqtSlot()
 def __showBookmarkInfo(self):
 """
 Private slot to show a dialog with some bookmark info.
 """
 from .BookmarkActionSelectionDialog import (
 gradient.setColorAt(progress / 100.0, backgroundColor)
 p.setBrush(QPalette.ColorRole.Base, gradient)
 self.setPalette(p)
-EricLineEdit.paintEvent(self, evt)
+super().paintEvent(evt)
 def focusOutEvent(self, evt):
 """
 Protected method to handle focus out event.
 @param evt reference to the focus event (QFocusEvent)
 """
 if self.text() == "" and self.__browser is not None:
 self.__browserUrlChanged(self.__browser.url())
-EricLineEdit.focusOutEvent(self, evt)
+super().focusOutEvent(evt)
 def mousePressEvent(self, evt):
 """
 Protected method called by a mouse press event.
 @param evt reference to the mouse event (QMouseEvent)
 """
 if evt.button() == Qt.MouseButton.LeftButton:
 self.selectAll()
 else:
-EricLineEdit.mouseDoubleClickEvent(self, evt)
+super().mouseDoubleClickEvent(evt)
 def keyPressEvent(self, evt):
 """
 Protected method to handle key presses.
 if not host.lower().endswith(append):
 host += append
 url.setHost(host)
 self.setText(url.toString())
-EricLineEdit.keyPressEvent(self, evt)
+super().keyPressEvent(evt)
 def dragEnterEvent(self, evt):
 """
 Protected method to handle drag enter events.
 """
 mimeData = evt.mimeData()
 if mimeData.hasUrls() or mimeData.hasText():
 evt.acceptProposedAction()
-EricLineEdit.dragEnterEvent(self, evt)
+super().dragEnterEvent(evt)
 def dropEvent(self, evt):
 """
 Protected method to handle drop events.
 elif mimeData.hasText():
 url = QUrl.fromEncoded(mimeData.text().encode("utf-8"),
 QUrl.ParsingMode.TolerantMode)
 if url.isEmpty() or not url.isValid():
-EricLineEdit.dropEvent(self, evt)
+super().dropEvent(evt)
 return
 self.setText(str(url.toEncoded(), encoding="utf-8"))
 self.selectAll()
 def __setRssButton(self):
 """
 Private slot to show the RSS button.
 """
-self.__rssButton.setVisible(self.__browser.checkRSS())
+self.__rssAction.setVisible(self.__browser.checkRSS())
-def __rssClicked(self):
+@pyqtSlot()
+def __rssTriggered(self):
 """
 Private slot to handle clicking the RSS icon.
 """
 from WebBrowser.Feeds.FeedsDialog import FeedsDialog
 feeds = self.__browser.getRSS()

Mercurial Repositories > eric / file comparison

comparison: eric7/WebBrowser/UrlBar/UrlBar.py

eric7/WebBrowser/UrlBar/UrlBar.py