Signals and Slots¶

button.clicked.connect(self.button_clicked)

import sys

from PySide6.QtCore import Qt
from PySide6.QtWidgets import (
    QApplication,
    QLabel,
    QPushButton,
    QVBoxLayout,
    QWidget,
)


class MW(QWidget):
    def __init__(self):
        super().__init__()
        self.init_ui()

    def init_ui(self):
        self.setWindowTitle("DirectConnection Ex")
        self.resize(380, 180)

        self.label = QLabel("Button을 클릭하면 Slot이 즉시 실행됨.")
        self.button = QPushButton("Click Me")

        # DirectConnection: Slot이 즉시 호출됨.
        self.button.clicked.connect(
            self.on_clicked,
            Qt.ConnectionType.DirectConnection,
        )

        layout = QVBoxLayout()
        layout.addWidget(self.label)
        layout.addWidget(self.button)
        self.setLayout(layout)

    def on_clicked(self):
        """
        DirectConnection으로 연결된 Slot.

        Signal이 emit되면 이 method가
        emit한 thread에서 즉시 호출됨.
        Event System을 거치지 않는 직접 함수 호출임.
        """

        import threading

        tid = threading.current_thread().name
        print(f"[DirectConnection] on_clicked() called in: {tid}")
        self.label.setText(
            f"Slot executed directly in: {tid}"
        )


if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = MW()
    window.show()
    sys.exit(app.exec())

# worker thread에서 실행되는 코드
self.work_done.emit("result")

# main thread의 widget에 정의된 Slot
def on_work_done(self, message):
    self.label.setText(message)       # GUI widget 조작
    self.progress_bar.setValue(100)    # GUI widget 조작

import sys
import time

from PySide6.QtCore import QThread, Qt, Signal
from PySide6.QtWidgets import (
    QApplication,
    QLabel,
    QPushButton,
    QVBoxLayout,
    QWidget,
)


class Worker(QThread):
    """
    별도의 thread에서 작업을 수행하고
    완료 시 Signal을 emit하는 worker.
    """

    work_done = Signal(str)

    def run(self):
        import threading

        tid = threading.current_thread().name
        print(f"[Worker] run() executing in: {tid}")

        # 시간이 걸리는 작업을 simulation.
        time.sleep(1)

        self.work_done.emit(f"Work completed in: {tid}")


class MW(QWidget):
    def __init__(self):
        super().__init__()
        self.worker = None
        self.init_ui()

    def init_ui(self):
        self.setWindowTitle("QueuedConnection Ex")
        self.resize(420, 180)

        self.label = QLabel(
            "Button을 누르면 worker thread에서 작업 후\n"
            "main thread의 Slot이 비동기로 호출됨."
        )
        self.button = QPushButton("Start Worker")
        self.button.clicked.connect(self.start_worker)

        layout = QVBoxLayout()
        layout.addWidget(self.label)
        layout.addWidget(self.button)
        self.setLayout(layout)

    def start_worker(self):
        self.button.setEnabled(False)
        self.label.setText("Worker thread 실행 중...")

        self.worker = Worker()

        # QueuedConnection: Slot이 receiver(main)의
        # Event Loop에서 비동기적으로 실행됨.
        self.worker.work_done.connect(
            self.on_work_done,
            Qt.ConnectionType.QueuedConnection,
        )

        self.worker.start()

    def on_work_done(self, message):
        """
        QueuedConnection으로 연결된 Slot.

        Worker thread에서 emit된 Signal이
        main thread의 posted event queue에 등록된 뒤,
        main thread의 Event Loop가 처리할 때 호출됨.
        """

        import threading

        tid = threading.current_thread().name
        print(f"[QueuedConnection] on_work_done() called in: {tid}")
        print(f"[QueuedConnection] message: {message}")

        self.label.setText(
            f"Result: {message}\n"
            f"Slot executed in: {tid}"
        )
        self.button.setEnabled(True)


if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = MW()
    window.show()
    sys.exit(app.exec())

import sys
import time

from PySide6.QtCore import QThread, Signal
from PySide6.QtWidgets import (
    QApplication,
    QLabel,
    QPushButton,
    QVBoxLayout,
    QWidget,
)


class Worker(QThread):
    """
    별도의 thread에서 Signal을 emit하는 worker.
    """

    notify = Signal(str)

    def run(self):
        import threading

        tid = threading.current_thread().name

        time.sleep(0.5)
        self.notify.emit(f"from worker thread ({tid})")


class MW(QWidget):
    """
    AutoConnection 동작을 확인하는 main window.

    같은 Signal-Slot 연결이라도 emit하는 thread에 따라
    DirectConnection 또는 QueuedConnection으로 자동 결정됨.
    """

    manual_signal = Signal(str)

    def __init__(self):
        super().__init__()
        self.worker = None
        self.init_ui()

    def init_ui(self):
        self.setWindowTitle("AutoConnection Ex")
        self.resize(460, 260)

        self.label = QLabel(
            "AutoConnection은 emit하는 thread에 따라\n"
            "Direct 또는 Queued로 자동 결정됨."
        )

        self.btn_same = QPushButton(
            "Emit from Main Thread (→ Direct)"
        )
        self.btn_worker = QPushButton(
            "Emit from Worker Thread (→ Queued)"
        )

        self.btn_same.clicked.connect(self.emit_from_main)
        self.btn_worker.clicked.connect(self.start_worker)

        # AutoConnection (기본값): connect()에
        # connection type을 지정하지 않으면 AutoConnection임.
        self.manual_signal.connect(self.on_notify)

        layout = QVBoxLayout()
        layout.addWidget(self.label)
        layout.addWidget(self.btn_same)
        layout.addWidget(self.btn_worker)
        self.setLayout(layout)

    def emit_from_main(self):
        """
        Main thread에서 Signal을 emit함.

        Sender와 receiver가 같은 thread이므로
        AutoConnection은 DirectConnection으로 동작함.
        """

        import threading

        tid = threading.current_thread().name
        print(f"\n[Main] emit_from_main() in: {tid}")
        print("[Main] before emit")
        self.manual_signal.emit(f"from main thread ({tid})")
        print("[Main] after emit")

    def start_worker(self):
        """
        Worker thread에서 Signal을 emit하게 함.

        Sender와 receiver가 다른 thread이므로
        AutoConnection은 QueuedConnection으로 동작함.
        """

        self.btn_worker.setEnabled(False)

        self.worker = Worker()

        # 동일한 Slot에 연결하되, connection type은 기본값(Auto).
        self.worker.notify.connect(self.on_notify)
        self.worker.finished.connect(
            lambda: self.btn_worker.setEnabled(True)
        )

        self.worker.start()

    def on_notify(self, message):
        """
        AutoConnection으로 연결된 Slot.

        같은 thread에서 emit되면 즉시 호출되고,
        다른 thread에서 emit되면 Event Loop를 통해 호출됨.
        """

        import threading

        tid = threading.current_thread().name
        print(f"[Slot] on_notify() called in: {tid}")
        print(f"[Slot] message: {message}")

        self.label.setText(
            f"Signal: {message}\n"
            f"Slot executed in: {tid}"
        )


if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = MW()
    window.show()
    sys.exit(app.exec())

from PySide6.QtWidgets import QCheckBox
help(QCheckBox.toggled)

import sys

from PySide6.QtCore import Qt
from PySide6.QtWidgets import (
    QApplication,
    QButtonGroup,
    QCheckBox,
    QLabel,
    QVBoxLayout,
    QWidget,
)


class MW(QWidget):
    def __init__(self):
        super().__init__()
        self.init_ui()

    def init_ui(self):
        self.setWindowTitle("Signal Argument Ex")
        self.resize(380, 280)

        layout = QVBoxLayout()

        layout.addWidget(QLabel("What is most important?"))

        # QButtonGroup: 복수의 button을 그룹으로 관리함.
        self.bg = QButtonGroup(self)

        self.cb01 = QCheckBox("1. faith")
        self.cb02 = QCheckBox("2. hope")
        self.cb03 = QCheckBox("3. love")

        for cb in (self.cb01, self.cb02, self.cb03):
            layout.addWidget(cb)
            self.bg.addButton(cb)

        # 기본값: exclusive mode (하나만 선택 가능).
        self.bg.setExclusive(True)

        # buttonClicked Signal은 클릭된 button의 reference를
        # argument로 Slot에 전달함.
        self.bg.buttonClicked.connect(self.on_button_clicked)

        self.dp_label = QLabel("")
        layout.addWidget(self.dp_label)

        # 별도의 checkbox로 exclusive mode를 전환함.
        self.mode_cb = QCheckBox("Check for multiple selection")

        # stateChanged Signal은 check 상태를 나타내는
        # int 값을 argument로 Slot에 전달함.
        self.mode_cb.stateChanged.connect(self.on_mode_changed)
        layout.addWidget(self.mode_cb)

        self.setLayout(layout)

    def on_button_clicked(self, button):
        """
        QButtonGroup.buttonClicked Signal의 Slot.

        이 Signal은 클릭된 button의 reference를
        argument로 전달함.

        Parameters
        ----------
        button : QAbstractButton
            클릭된 button의 reference.
            buttonClicked Signal이 전달하는 argument임.
        """

        text = button.text()
        print(f"[buttonClicked] selected: {text}")
        self.dp_label.setText(f"Selected: {text}")

    def on_mode_changed(self, state):
        """
        QCheckBox.stateChanged Signal의 Slot.

        이 Signal은 check 상태를 나타내는 int 값을
        argument로 전달함.
        Qt.CheckState.Checked(2) 또는
        Qt.CheckState.Unchecked(0) 등의 값이 전달됨.

        Parameters
        ----------
        state : int
            check 상태를 나타내는 값.
            stateChanged Signal이 전달하는 argument임.
        """

        if state == Qt.CheckState.Checked.value:
            self.bg.setExclusive(False)
            print("[stateChanged] multiple selection enabled")
        else:
            self.bg.setExclusive(True)
            print("[stateChanged] exclusive selection enabled")


if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = MW()
    window.show()
    sys.exit(app.exec())