PyQt5 focusIN/Out 事件

Question

I am using Python 3.4 and Qt 5 for the first time. It's easy and I can understand most of functionality which I need. But (there is always "but") I don't understand how to use focusOut / clearFocus / focusIn events.

Am I right that old way:

QObject.connect(self.someWidget, QtCore.SIGNAL('focusOutEvent()'), self.myProcedure)

...does not work in Qt5?

I tried to understand this unsuccessfully. I'll be very thankful for a short example how to catch an event when eg some of many QLineEdit has lost focus.

Answer 1

The issue here is that focusInEvent / clearFocus / focusOutEvent are not signals, they are event handlers . See for example here . If you want to catch these events you will need to re-implement the event handler on your object, for example by subclassing QLineEdit.

class MyQLineEdit(QLineEdit):

    def focusInEvent(self, e):
        # Do something with the event here
        super(MyQLineEdit, self).focusInEvent(e) # Do the default action on the parent class QLineEdit

In PyQt5 the syntax for signals themselves is considerably simpler. Taking for example the textEdited signal from QLineEdit, you can use that as follows:

self.someWidget.textEdited.connect( self.myProcedure )

This will connect your self.myProcedure function to the textEdited signal. The target function will need to accept the event outputs, for example:

void    textEdited ( const QString & text )

So you could define your self.myProcedure in your class as follows and it will receive the QString sent by that event:

def myProcedure(self, t):
    # Do something with the QString (text) object here

You can also define custom events as follows:

from PyQt5.QtCore import QObject, pyqtSignal

class Foo(QObject):
    an_event = pyqtSignal()
    a_number = pyqtSignal(int)

In each of these cases pyqtSignal is used to define a property of the Foo class which you can connect to like any other signal. So for example to handle the above we could create:

def an_event_handler(self):
    # We receive nothing here

def a_number_handler(self, i):
    # We receive the int

You could then connect() and emit() the events as follows:

self.an_event.connect( self.an_event_handler )
self.a_number.connect( self.a_number_handler )

self.an_event.emit()   # Send the event and nothing else.
self.a_number.emit(1)  # Send the event an an int.

The link you posted gives more information on custom events , signal naming and overloading with the new syntax.

Answer 2

It took me a while to get this figured out so I thought I would post it here to help anyone else having this problem. It is in Python 3.9.6 and PyQt 6.1.2.

This changes the color of the widget when it is in focus and again when it is out of focus.

import sys
from PyQt6 import QtWidgets


class Main(QtWidgets.QWidget):

    def __init__(self, parent=None):
        super().__init__(parent)

        self.setWindowTitle("Qt Testing")
        self.setGeometry(0, 0, 640, 120)

        h = QtWidgets.QHBoxLayout()

        w = ColorQLineEdit("one")
        h.addWidget(w)

        w = ColorQLineEdit("two")
        h.addWidget(w)

        self.setLayout(h)


class ColorQLineEdit(QtWidgets.QLineEdit):

    def focusInEvent(self, event):
        print("in")
        self.setStyleSheet("background-color: yellow; color: red;")
        super().focusInEvent(event)

    def focusOutEvent(self, event):
        print("out")
        self.setStyleSheet("background-color: white; color: black;")
        super().focusOutEvent(event)


app = QtWidgets.QApplication(sys.argv)
main = Main()
main.show()
sys.exit(app.exec())