6강. 다중 시그널/단일 슬롯

0. 학습 목표

이번 단계에서는 여러 Signal을 하나의 Slot에 연결하는 구조를 학습합니다.

 

앞의 3.5 단계에서는 하나의 Signal에 여러 Slot을 연결하는 구조를 살펴보았습니다.

이번 단계에서는 반대로, 여러 위젯의 Signal을 하나의 Slot 함수에 연결하는 구조를 살펴봅니다.

 

예제에서는 QSlider와 QDial을 함께 사용합니다.

슬라이더를 움직여도, 다이얼을 돌려도 같은 Slot 함수가 실행되도록 구성합니다.

학습 목표	내용
다중 Signal / 단일 Slot 이해	여러 Signal을 하나의 Slot 함수에 연결할 수 있음을 이해합니다.
QSlider와 QDial 이해	슬라이더와 다이얼이 모두 valueChanged(int) Signal을 발생시킬 수 있음을 이해합니다.
공통 Slot 함수 구현	슬라이더와 다이얼에서 전달된 값을 하나의 Slot 함수에서 처리합니다.
위젯 동기화 이해	슬라이더를 움직이면 다이얼 값도 바뀌고, 다이얼을 돌리면 슬라이더 값도 바뀌도록 구성합니다.
GUI 로직 통합	ProgressBar, Label, LCDNumber 갱신 로직을 한 곳에서 처리하는 구조를 이해합니다.

이번 단계의 핵심
QSlider의 valueChanged Signal과 QDial의 valueChanged Signal을 하나의 Slot 함수에 연결하여 같은 로직으로 처리합니다.

1. Signal / Slot 개념 이해하기

1.1 하나의 Slot에 여러 Signal 연결하기

Qt의 Signal / Slot 구조에서는 하나의 Slot 함수에 여러 Signal을 연결할 수 있습니다.

즉, 서로 다른 위젯에서 발생한 Signal이라도 전달하는 값의 형태가 같다면 같은 Slot 함수에서 처리할 수 있습니다.

 

이번 예제에서는 QSlider와 QDial을 사용합니다.

QSlider.valueChanged  ────┐
                          ├────▶  update_value(value)
QDial.valueChanged ───────┘

슬라이더를 움직여도 update_value()가 실행되고, 다이얼을 돌려도 update_value()가 실행됩니다.

이처럼 공통 로직을 하나의 Slot 함수로 모으면 코드 중복을 줄일 수 있습니다.

 

 

1.2 QSlider와 QDial

QSlider와 QDial은 모양은 다르지만, 둘 다 사용자가 숫자 값을 조절하는 위젯입니다.

두 위젯 모두 값이 바뀔 때 valueChanged(int) Signal을 발생시킬 수 있습니다.

위젯	역할
QSlider	막대를 움직여 값을 조절하는 위젯입니다.
QDial	다이얼을 돌려 값을 조절하는 위젯입니다.
valueChanged(int)	값이 변경될 때 현재 값을 int로 전달하는 Signal입니다.

따라서 두 위젯의 Signal을 같은 Slot 함수에 연결할 수 있습니다.

 

 

1.3 다중 Signal / 단일 Slot 구조

이번 예제의 핵심 연결 구조는 다음과 같습니다.

self.slider.valueChanged.connect(self.update_value)
self.dial.valueChanged.connect(self.update_value)

위 코드는 두 개의 Signal을 하나의 Slot 함수에 연결합니다.

Signal	연결되는 Slot
self.slider.valueChanged	self.update_value
self.dial.valueChanged	self.update_value

따라서 슬라이더와 다이얼 중 어떤 위젯의 값이 바뀌어도 update_value() 함수가 실행됩니다.

 

 

1.4 슬라이더와 다이얼 연동

슬라이더와 다이얼을 함께 사용할 때는 두 위젯의 값도 서로 맞춰 주면 좋습니다.

예를 들어 슬라이더를 움직이면 다이얼 값도 같이 바뀌고, 다이얼을 돌리면 슬라이더 값도 같이 바뀌도록 만들 수 있습니다.

self.slider.valueChanged.connect(self.sync_dial)
self.dial.valueChanged.connect(self.sync_slider)

단, 서로의 값을 계속 바꾸는 구조이므로 중복 Signal 발생을 주의해야 합니다.

이번 예제에서는 blockSignals(True)를 사용하여 동기화 과정에서 불필요한 Signal이 다시 발생하지 않도록 처리합니다.

주의할 점
슬라이더와 다이얼을 서로 연결할 때는 값 변경이 다시 Signal을 발생시켜 중복 실행될 수 있습니다.
이런 경우 blockSignals()를 사용하면 동기화 중에 발생하는 불필요한 Signal을 막을 수 있습니다.

 

 

1.5 이번 예제의 전체 흐름

슬라이더 이동
    ↓
slider.valueChanged(int) Signal 발생
    ├── update_value(value)
    │       ├── 원본 값 Label 변경
    │       ├── ProgressBar 변경
    │       └── processedValueSignal.emit(value × 2)
    │
    └── sync_dial(value)
            └── 다이얼 값 동기화

다이얼 이동
    ↓
dial.valueChanged(int) Signal 발생
    ├── update_value(value)
    │       ├── 원본 값 Label 변경
    │       ├── ProgressBar 변경
    │       └── processedValueSignal.emit(value × 2)
    │
    └── sync_slider(value)
            └── 슬라이더 값 동기화

이 구조를 사용하면 슬라이더와 다이얼 중 어느 쪽을 조작해도 같은 Slot 함수가 실행되고, 화면 전체가 같은 방식으로 갱신됩니다.

2. 예제 코드

2.1 실습 준비

이번 예제는 PyCharm에서 진행합니다.

새 Python 프로젝트를 만들고, 프로젝트 가상환경에 PySide6가 설치되어 있는 상태에서 진행합니다.

예제 파일명은 main.py로 작성합니다.

 

2. PyCharm 프로젝트 생성

 

 

2.2 main.py 예제 코드

import sys
from PySide6.QtCore import Qt, Signal, Slot
from PySide6.QtWidgets import (
    QApplication,
    QWidget,
    QSlider,
    QDial,
    QVBoxLayout,
    QLabel,
    QProgressBar,
    QLCDNumber
)

class MultiSignalExample(QWidget):

    processedValueSignal = Signal(int)

    def __init__(self):
        super().__init__()

        self.setWindowTitle("다중 Signal / 단일 Slot 예제")
        self.resize(300, 260)

        self.label_original = QLabel("원본 값: -")
        self.label_processed = QLabel("처리된 값(×2): -")

        self.slider = QSlider(Qt.Horizontal)
        self.slider.setMinimum(1)
        self.slider.setMaximum(100)
        self.slider.setValue(25)

        self.dial = QDial()
        self.dial.setRange(1, 100)
        self.dial.setValue(25)

        self.progress_bar = QProgressBar()
        self.progress_bar.setRange(0, 100)
        self.progress_bar.setValue(25)

        self.lcd_number = QLCDNumber()
        self.lcd_number.setDigitCount(3)
        self.lcd_number.display(50)

        self.slider.valueChanged.connect(self.update_value)
        self.dial.valueChanged.connect(self.update_value)

        self.slider.valueChanged.connect(self.sync_dial)
        self.dial.valueChanged.connect(self.sync_slider)

        self.processedValueSignal.connect(self.update_processed_views)

        layout = QVBoxLayout(self)
        layout.addWidget(self.slider)
        layout.addWidget(self.dial)
        layout.addWidget(self.label_original)
        layout.addWidget(self.progress_bar)
        layout.addWidget(self.lcd_number)
        layout.addWidget(self.label_processed)

    @Slot(int)
    def update_value(self, value):
        print("값 변경 :", value)

        self.label_original.setText(f"원본 값: {value}")
        self.progress_bar.setValue(value)

        processed_value = value * 2
        self.processedValueSignal.emit(processed_value)

    @Slot(int)
    def update_processed_views(self, value):
        print("처리된 값 :", value)

        self.label_processed.setText(f"처리된 값(×2): {value}")
        self.lcd_number.display(value)

    @Slot(int)
    def sync_dial(self, value):
        self.dial.blockSignals(True)
        self.dial.setValue(value)
        self.dial.blockSignals(False)

    @Slot(int)
    def sync_slider(self, value):
        self.slider.blockSignals(True)
        self.slider.setValue(value)
        self.slider.blockSignals(False)

if __name__ == "__main__":
    app = QApplication(sys.argv)

    window = MultiSignalExample()
    window.show()

    sys.exit(app.exec())

 

이 코드를 실행하면 슬라이더, 다이얼, 원본 값 Label, ProgressBar, LCDNumber, 처리된 값 Label이 표시됩니다.

슬라이더를 움직여도, 다이얼을 돌려도 같은 update_value() Slot 함수가 실행됩니다.

값 변경 : 26
처리된 값 : 52

값 변경 : 27
처리된 값 : 54

 

 

2.3 예제에서 확인할 핵심 구조

코드	의미
QDial()	다이얼을 돌려 값을 조절하는 위젯을 생성합니다.
slider.valueChanged.connect()	슬라이더 값 변경 Signal을 Slot 함수와 연결합니다.
dial.valueChanged.connect()	다이얼 값 변경 Signal을 Slot 함수와 연결합니다.
update_value()	슬라이더와 다이얼의 값을 공통으로 처리하는 단일 Slot 함수입니다.
sync_dial()	슬라이더 값이 바뀌면 다이얼 값을 맞춥니다.
sync_slider()	다이얼 값이 바뀌면 슬라이더 값을 맞춥니다.
blockSignals()	동기화 과정에서 불필요한 Signal이 다시 발생하지 않도록 막습니다.

 

 

2.4 예제 파일

예제 파일은 main.py로 저장합니다.

 

 

SingleSignal_MultiSlot_02.zip

0.00MB

3. 코드 분석

3.1 주석 포함 전체 코드

import sys                                      # [1] 파이썬 인터프리터 관련 기능을 제공하는 sys 모듈을 가져옴
from PySide6.QtCore import (                    # [2] PySide6의 핵심 기능 관련 클래스들 중에서
    Qt,                                         #     - Qt: 방향, 정렬, 키 값 등 Qt에서 사용하는 공통 상수 제공
    Signal,                                     #     - Signal: 사용자 정의 Signal을 선언할 때 사용하는 클래스
    Slot                                        #     - Slot: Slot 함수의 인자 타입을 명확히 표시할 때 사용하는 데코레이터
)
from PySide6.QtWidgets import (                 # [3] PySide6의 위젯 관련 클래스들 중에서
    QApplication,                               #     - QApplication: 전체 어플리케이션(프로그램)을 관리하는 클래스
    QWidget,                                    #     - QWidget: 화면에 보이는 기본 창(위젯)의 부모 클래스
    QSlider,                                    #     - QSlider: 값을 조절할 수 있는 슬라이더 위젯 클래스
    QDial,                                      #     - QDial: 다이얼 형태로 값을 조절하는 위젯 클래스
    QVBoxLayout,                                #     - QVBoxLayout: 위젯들을 세로 방향으로 배치하는 레이아웃 클래스
    QLabel,                                     #     - QLabel: 화면에 텍스트를 표시하는 위젯 클래스
    QProgressBar,                               #     - QProgressBar: 진행률 형태로 값을 표시하는 위젯 클래스
    QLCDNumber                                  #     - QLCDNumber: 숫자를 LCD 형태로 표시하는 위젯 클래스
)


class MultiSignalExample(QWidget):              # [4] QWidget을 상속받아 사용자 정의 창 클래스 생성

    processedValueSignal = Signal(int)          # [5] 사용자 정의 Signal 선언
                                                #     - 정수(int) 값을 전달하는 Signal
                                                #     - 처리된 값(value × 2)을 전달할 때 사용

    def __init__(self):                         # [6] MultiSignalExample 객체가 생성될 때 자동 실행되는 초기화 메서드
        super().__init__()                      # [7] 부모 클래스(QWidget)의 초기화 기능 실행

        self.setWindowTitle("다중 Signal / 단일 Slot 예제")  # [8] 창 제목 설정
        self.resize(300, 260)                   # [9] 창 크기 설정

        self.label_original = QLabel("원본 값: -")          # [10] 원본 값을 표시할 Label 생성
        self.label_processed = QLabel("처리된 값(×2): -")    # [11] 처리된 값을 표시할 Label 생성

        self.slider = QSlider(Qt.Horizontal)    # [12] 가로 방향 슬라이더 생성
        self.slider.setMinimum(1)               # [13] 슬라이더 최소값 설정
        self.slider.setMaximum(100)             # [14] 슬라이더 최대값 설정
        self.slider.setValue(25)                # [15] 슬라이더 초기값 설정

        self.dial = QDial()                     # [16] 다이얼 위젯 생성
        self.dial.setRange(1, 100)              # [17] 다이얼 값 범위를 1~100으로 설정
        self.dial.setValue(25)                  # [18] 다이얼 초기값 설정

        self.progress_bar = QProgressBar()      # [19] ProgressBar 위젯 생성
        self.progress_bar.setRange(0, 100)      # [20] ProgressBar 값 범위를 0~100으로 설정
        self.progress_bar.setValue(25)          # [21] ProgressBar 초기값 설정

        self.lcd_number = QLCDNumber()          # [22] LCDNumber 위젯 생성
        self.lcd_number.setDigitCount(3)        # [23] LCDNumber 표시 자리수 설정
        self.lcd_number.display(50)             # [24] 슬라이더 초기값 25의 2배인 50 표시

        self.slider.valueChanged.connect(       # [25] 슬라이더 valueChanged Signal과
            self.update_value                   #      공통 Slot 함수 연결
        )

        self.dial.valueChanged.connect(         # [26] 다이얼 valueChanged Signal과
            self.update_value                   #      같은 공통 Slot 함수 연결
        )

        self.slider.valueChanged.connect(       # [27] 슬라이더 값이 바뀌면
            self.sync_dial                      #      다이얼 값을 같은 값으로 동기화
        )

        self.dial.valueChanged.connect(         # [28] 다이얼 값이 바뀌면
            self.sync_slider                    #      슬라이더 값을 같은 값으로 동기화
        )

        self.processedValueSignal.connect(      # [29] 사용자 정의 Signal과
            self.update_processed_views         #      처리된 값을 표시하는 Slot 함수 연결
        )

        layout = QVBoxLayout(self)              # [30] 현재 창에 세로 방향 레이아웃 생성
        layout.addWidget(self.slider)           # [31] 레이아웃에 슬라이더 추가
        layout.addWidget(self.dial)             # [32] 레이아웃에 다이얼 추가
        layout.addWidget(self.label_original)   # [33] 레이아웃에 원본 값 Label 추가
        layout.addWidget(self.progress_bar)     # [34] 레이아웃에 ProgressBar 추가
        layout.addWidget(self.lcd_number)       # [35] 레이아웃에 LCDNumber 추가
        layout.addWidget(self.label_processed)  # [36] 레이아웃에 처리된 값 Label 추가

    @Slot(int)                                  # [37] 정수 값을 받는 Slot 함수임을 명시
    def update_value(self, value):              # [38] 슬라이더와 다이얼이 공통으로 사용하는 Slot 함수
        print("값 변경 :", value)               # [39] 현재 값 출력

        self.label_original.setText(             # [40] 원본 값 Label 변경
            f"원본 값: {value}"
        )

        self.progress_bar.setValue(value)        # [41] ProgressBar에 원본 값 반영

        processed_value = value * 2              # [42] 전달받은 값을 2배로 처리
        self.processedValueSignal.emit(          # [43] 사용자 정의 Signal 발생
            processed_value                      #      - 처리된 값을 전달
        )

    @Slot(int)                                  # [44] 정수 값을 받는 Slot 함수임을 명시
    def update_processed_views(self, value):     # [45] 처리된 값을 화면에 표시하는 Slot 함수
        print("처리된 값 :", value)              # [46] 처리된 값 출력

        self.label_processed.setText(            # [47] 처리된 값 Label 변경
            f"처리된 값(×2): {value}"
        )

        self.lcd_number.display(value)           # [48] 처리된 값을 LCDNumber에 표시

    @Slot(int)                                  # [49] 정수 값을 받는 Slot 함수임을 명시
    def sync_dial(self, value):                  # [50] 슬라이더 값을 다이얼에 동기화하는 Slot 함수
        self.dial.blockSignals(True)             # [51] 다이얼 값 변경 중 Signal 발생을 잠시 막음
        self.dial.setValue(value)                # [52] 다이얼 값을 슬라이더 값과 동일하게 변경
        self.dial.blockSignals(False)            # [53] 다시 Signal 발생 허용

    @Slot(int)                                  # [54] 정수 값을 받는 Slot 함수임을 명시
    def sync_slider(self, value):                # [55] 다이얼 값을 슬라이더에 동기화하는 Slot 함수
        self.slider.blockSignals(True)           # [56] 슬라이더 값 변경 중 Signal 발생을 잠시 막음
        self.slider.setValue(value)              # [57] 슬라이더 값을 다이얼 값과 동일하게 변경
        self.slider.blockSignals(False)          # [58] 다시 Signal 발생 허용


if __name__ == "__main__":                      # [59] 이 파일을 직접 실행할 때만 아래 코드 실행
    app = QApplication(sys.argv)                 # [60] QApplication 객체 생성

    window = MultiSignalExample()                # [61] 사용자 정의 창 객체 생성
    window.show()                                # [62] 창을 실제로 화면에 표시

    sys.exit(app.exec())                         # [63] 이벤트 루프(Event Loop) 시작

 

 

3.2 단계별 분석

1단계: QDial 추가

self.dial = QDial()
self.dial.setRange(1, 100)
self.dial.setValue(25)

QDial은 다이얼 형태로 값을 조절하는 위젯입니다.

이번 예제에서는 QSlider와 같은 범위인 1부터 100까지 값을 가지도록 설정합니다.

 

2단계: 여러 Signal을 하나의 Slot에 연결

self.slider.valueChanged.connect(self.update_value)
self.dial.valueChanged.connect(self.update_value)

이 코드가 이번 예제의 핵심입니다.

슬라이더의 valueChanged Signal과 다이얼의 valueChanged Signal이 모두 같은 update_value() Slot 함수에 연결됩니다.

 

3단계: 공통 Slot 함수에서 값 처리

@Slot(int)
def update_value(self, value):
    print("값 변경 :", value)

    self.label_original.setText(f"원본 값: {value}")
    self.progress_bar.setValue(value)

    processed_value = value * 2
    self.processedValueSignal.emit(processed_value)

update_value() 함수는 슬라이더와 다이얼이 함께 사용하는 공통 Slot 함수입니다.

어떤 위젯에서 값이 변경되었든, 전달된 value 값을 기준으로 화면을 갱신합니다.

 

4단계: 슬라이더와 다이얼 동기화

self.slider.valueChanged.connect(self.sync_dial)
self.dial.valueChanged.connect(self.sync_slider)

슬라이더와 다이얼은 서로 같은 값을 가지도록 동기화합니다.

슬라이더를 움직이면 다이얼 값도 바뀌고, 다이얼을 돌리면 슬라이더 값도 바뀝니다.

 

5단계: blockSignals()로 중복 Signal 방지

def sync_dial(self, value):
    self.dial.blockSignals(True)
    self.dial.setValue(value)
    self.dial.blockSignals(False)

sync_dial()은 슬라이더 값을 다이얼에 반영합니다.

이때 다이얼 값이 바뀌면서 다시 valueChanged Signal이 발생하면 같은 로직이 중복 실행될 수 있습니다.

그래서 blockSignals(True)로 잠시 Signal 발생을 막은 뒤 값을 변경하고, 다시 blockSignals(False)로 Signal 발생을 허용합니다.

 

6단계: 처리된 값 표시

@Slot(int)
def update_processed_views(self, value):
    print("처리된 값 :", value)

    self.label_processed.setText(f"처리된 값(×2): {value}")
    self.lcd_number.display(value)

update_processed_views()는 사용자 정의 Signal이 전달한 처리된 값을 화면에 표시합니다.

처리된 값은 Label과 LCDNumber에 함께 표시됩니다.

 

7단계: 전체 실행 흐름

슬라이더 또는 다이얼 값 변경
        ↓
valueChanged(int) Signal 발생
        ↓
update_value(value) 실행
        ↓
원본 값 Label / ProgressBar 갱신
        ↓
processedValueSignal.emit(value × 2)
        ↓
update_processed_views(value) 실행
        ↓
처리된 값 Label / LCDNumber 갱신

4. Qt Designer에서 구현할 때의 구조

4.1 코드 방식과 Designer 방식의 차이

앞의 예제에서는 Python 코드로 슬라이더와 다이얼을 직접 만들었습니다.

self.slider = QSlider(Qt.Horizontal)
self.dial = QDial()

Qt Designer를 사용하는 경우에는 슬라이더와 다이얼을 Designer 화면에서 배치한 뒤, Python 코드에서 해당 위젯에 접근합니다.

self.ui.horizontalSlider
self.ui.dial

구조는 동일합니다.

다만 Designer에서 만든 위젯은 self.ui를 통해 접근해야 합니다.

 

 

4.2 Qt Designer 기반 작업 흐름

Qt for Python 프로젝트 생성
        ↓
Qt Designer에서 Slider, Dial, Label, ProgressBar, LCDNumber 배치
        ↓
form.ui 파일 저장
        ↓
form.ui 파일을 ui_form.py로 변환
        ↓
Slider와 Dial의 valueChanged Signal을 하나의 Slot에 연결
        ↓
공통 Slot 함수에서 화면 갱신
        ↓
Slider와 Dial 값 동기화

 

4.3 GUI Designer 작업

Qt Designer에서 다음 위젯을 배치합니다.

위젯	objectName 예시	역할
Horizontal Slider	horizontalSlider	값을 조절합니다.
Dial	dial	다이얼 형태로 값을 조절합니다.
Label	labelOriginal	원본 값을 표시합니다.
Progress Bar	progressBar	원본 값을 진행률로 표시합니다.
LCD Number	lcdNumber	처리된 값을 숫자로 표시합니다.
Label	labelProcessed	처리된 값을 텍스트로 표시합니다.

 

 

4.4 form.ui를 ui_form.py로 변환하기

Qt Designer에서 만든 form.ui 파일은 그대로 Python 코드에서 사용할 수 없습니다.

일반적으로 다음 명령으로 form.ui → ui_form.py 파일로 변환합니다.

pyside6-uic form.ui -o ui_form.py

변환이 끝나면 ui_form.py 파일이 생성됩니다.

 

 

4.5 ui_form.py 파일 적용하기

import sys
from PySide6.QtCore import Signal, Slot
from PySide6.QtWidgets import QApplication, QWidget

from ui_form import Ui_Widget

class Widget(QWidget):

    processedValueSignal = Signal(int)

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

        self.ui = Ui_Widget()
        self.ui.setupUi(self)

        self.ui.horizontalSlider.setRange(1, 100)
        self.ui.horizontalSlider.setValue(25)

        self.ui.dial.setRange(1, 100)
        self.ui.dial.setValue(25)

        self.ui.progressBar.setRange(0, 100)
        self.ui.progressBar.setValue(25)

        self.ui.lcdNumber.setDigitCount(3)
        self.ui.lcdNumber.display(50)

        # [1] 여러 Signal을 하나의 Slot에 연결
        self.ui.horizontalSlider.valueChanged.connect(self.update_value)
        self.ui.dial.valueChanged.connect(self.update_value)

        # [2] 슬라이더와 다이얼 값 동기화
        self.ui.horizontalSlider.valueChanged.connect(self.sync_dial)
        self.ui.dial.valueChanged.connect(self.sync_slider)

        # [3] 사용자 정의 Signal 연결
        self.processedValueSignal.connect(self.update_processed_views)

    @Slot(int)
    def update_value(self, value):
        print("값 변경 :", value)

        self.ui.labelOriginal.setText(f"원본 값: {value}")
        self.ui.progressBar.setValue(value)

        processed_value = value * 2
        self.processedValueSignal.emit(processed_value)

    @Slot(int)
    def update_processed_views(self, value):
        print("처리된 값 :", value)

        self.ui.labelProcessed.setText(f"처리된 값(×2): {value}")
        self.ui.lcdNumber.display(value)

    @Slot(int)
    def sync_dial(self, value):
        self.ui.dial.blockSignals(True)
        self.ui.dial.setValue(value)
        self.ui.dial.blockSignals(False)

    @Slot(int)
    def sync_slider(self, value):
        self.ui.horizontalSlider.blockSignals(True)
        self.ui.horizontalSlider.setValue(value)
        self.ui.horizontalSlider.blockSignals(False)

if __name__ == "__main__":
    app = QApplication(sys.argv)

    widget = Widget()
    widget.show()

    sys.exit(app.exec())

 

 

4.6 Designer 방식에서 주의할 점

Qt Designer 방식에서도 여러 Signal을 하나의 Slot에 연결하는 방식은 동일합니다.

self.ui.horizontalSlider.valueChanged.connect(self.update_value)
self.ui.dial.valueChanged.connect(self.update_value)

위 코드는 슬라이더와 다이얼의 valueChanged Signal을 같은 update_value() Slot 함수에 연결한 것입니다.

중요한 점
Designer에서 만든 위젯은 self.ui를 통해 접근합니다. 여러 위젯의 Signal을 하나의 Slot에 연결하면 공통 처리 로직을 한 곳에 모을 수 있습니다.

5. 정리

이번 단계에서는 여러 Signal을 하나의 Slot에 연결하는 구조를 살펴보았습니다.

핵심 흐름은 다음과 같습니다.

여러 Signal
    ↓
self.slider.valueChanged
self.dial.valueChanged
    ↓
하나의 Slot
    ↓
self.update_value(value)

개념	정리
다중 Signal	여러 위젯에서 발생하는 Signal입니다.
단일 Slot	여러 Signal을 공통으로 처리하는 하나의 함수입니다.
QSlider	슬라이더 형태로 값을 조절합니다.
QDial	다이얼 형태로 값을 조절합니다.
blockSignals()	위젯 동기화 과정에서 불필요한 Signal 발생을 잠시 막습니다.

이번 단계에서 기억할 문장
Qt에서는 여러 Signal을 하나의 Slot에 연결할 수 있습니다.

 

이 구조를 사용하면 여러 위젯에서 발생한 값을 하나의 함수에서 일관되게 처리할 수 있습니다.