컨테이너 확장 예제

컨테이너 확장 예제에서는 QDesignerContainerExtension 클래스를 사용하여 Qt Widgets Designer 에 대한 사용자 정의 다중 페이지 플러그인을 만드는 방법을 보여줍니다.

Qt Widgets Designer 와 함께 사용할 수 있는 사용자 정의 위젯을 제공하려면 독립된 구현을 제공해야 합니다. 이 예에서는 컨테이너 확장 기능을 표시하도록 설계된 사용자 정의 다중 페이지 위젯을 사용합니다.

확장은 Qt Widgets Designer 의 동작을 수정하는 객체입니다. QDesignerContainerExtension 은 Qt Widgets Designer 이 사용자 정의 다중 페이지 위젯을 관리하고 조작할 수 있도록 합니다(예: 위젯에 페이지를 추가하고 삭제하는 등).

Qt Widgets Designer 에는 네 가지 유형의 확장을 사용할 수 있습니다:

• QDesignerMemberSheetExtension Qt Widgets Designer 의 신호 및 슬롯 편집 모드를 사용하여 연결을 구성할 때 표시되는 위젯의 멤버 기능을 조작할 수 있는 확장 기능을 제공합니다.
• QDesignerPropertySheetExtension Qt Widgets Designer 의 속성 편집기에 표시되는 위젯의 속성을 조작할 수 있는 확장 기능을 제공합니다.
• QDesignerTaskMenuExtension Qt Widgets Designer 의 작업 메뉴에 사용자 정의 메뉴 항목을 추가할 수 있는 확장 기능을 제공합니다.
• QDesignerContainerExtension Qt Widgets Designer 에서 다중 페이지 컨테이너 플러그인에 페이지를 추가(및 삭제)할 수 있는 확장 기능을 제공합니다.

이 예제와 동일한 패턴에 따라 모든 확장 기능을 사용할 수 있으며 각 확장 기능의 기본 클래스만 교체하면 됩니다. 자세한 내용은 Qt Widgets Designer C++ Classes.

컨테이너 확장 예제는 네 가지 클래스로 구성됩니다:

• MultiPageWidget 는 사용자가 페이지를 조작하고 채우고 콤보박스를 사용하여 페이지를 탐색할 수 있는 사용자 정의 컨테이너 위젯입니다.
• MultiPageWidgetPlugin MultiPageWidget 클래스를 Qt Widgets Designer 에 노출합니다.
• MultiPageWidgetExtensionFactory MultiPageWidgetContainerExtension 객체를 생성합니다.
• MultiPageWidgetContainerExtension 컨테이너 확장을 제공합니다.

사용자 정의 위젯 플러그인용 프로젝트 파일은 Qt Widgets Designer 내에서 작동하도록 하기 위해 몇 가지 추가 정보가 필요합니다. 예를 들어, 사용자 정의 위젯 플러그인은 Qt Widgets Designer 과 함께 제공되는 컴포넌트에 의존하므로 사용하는 프로젝트 파일에 이를 지정해야 합니다. 먼저 플러그인의 프로젝트 파일을 살펴보겠습니다.

그런 다음 MultiPageWidgetPlugin 클래스를 계속 검토하고 MultiPageWidgetExtensionFactory 및 MultiPageWidgetContainerExtension 클래스를 살펴보겠습니다. 마지막으로 MultiPageWidget 클래스 정의를 간단히 살펴보겠습니다.

프로젝트 파일

CMake

프로젝트 파일에는 Qt Widgets Designer 라이브러리에 연결되는 플러그인을 빌드할 것임을 명시해야 합니다:

find_package(Qt6 REQUIRED COMPONENTS Core Designer Gui Widgets)

qt_add_plugin(containerextension)

target_link_libraries(containerextension PUBLIC
    Qt::Core
    Qt::Designer
    Qt::Gui
    Qt::Widgets
)

다음 예시는 위젯의 헤더와 소스 파일을 추가하는 방법을 보여줍니다:

target_sources(containerextension PRIVATE
    multipagewidget.cpp multipagewidget.h
    multipagewidgetcontainerextension.cpp multipagewidgetcontainerextension.h
    multipagewidgetextensionfactory.cpp multipagewidgetextensionfactory.h
    multipagewidgetplugin.cpp multipagewidgetplugin.h
)

Qt Widgets Designer 에서 사용자 정의 위젯을 사용할 수 있도록 플러그인 인터페이스의 구현을 제공합니다. 이 특정 예에서는 컨테이너 확장 인터페이스와 확장 팩토리의 구현도 제공합니다.

플러그인이 Qt Widgets Designer 에서 검색되는 위치에 설치되어 있는지 확인하는 것이 중요합니다. 이를 위해 프로젝트의 대상 경로를 지정하고 설치할 항목 목록에 추가하면 됩니다:

   set(INSTALL_EXAMPLEDIR "${QT6_INSTALL_PREFIX}/${QT6_INSTALL_PLUGINS}/designer")
install(TARGETS containerextension
    RUNTIME DESTINATION "${INSTALL_EXAMPLEDIR}"
    BUNDLE DESTINATION "${INSTALL_EXAMPLEDIR}"
    LIBRARY DESTINATION "${INSTALL_EXAMPLEDIR}"
)

컨테이너 확장은 라이브러리로 생성됩니다. 프로젝트가 설치될 때 다른 Qt Widgets Designer 플러그인과 함께 설치됩니다( ninja install 또는 이와 유사한 설치 절차 사용).

플러그인에 대한 자세한 내용은 Qt 플러그인 생성 방법 문서를 참고하세요.

qmake

다음 예제는 Qt Widgets Designer 라이브러리에 플러그인을 링크하는 방법을 보여줍니다:

TEMPLATE = lib
CONFIG  += plugin

QT      += widgets designer

다음 예는 위젯의 헤더 및 소스 파일을 추가하는 방법을 보여줍니다:

HEADERS += multipagewidget.h \
           multipagewidgetplugin.h \
           multipagewidgetcontainerextension.h \
           multipagewidgetextensionfactory.h

SOURCES += multipagewidget.cpp \
           multipagewidgetplugin.cpp \
           multipagewidgetcontainerextension.cpp \
           multipagewidgetextensionfactory.cpp

OTHER_FILES += multipagewidget.json

다음 예제는 Qt Widgets Designer 의 플러그인 경로에 플러그인을 설치하는 방법을 보여줍니다:

target.path = $$[QT_INSTALL_PLUGINS]/designer
INSTALLS += target

멀티페이지위젯플러그인 클래스 정의

MultiPageWidgetPlugin 클래스는 MultiPageWidget 클래스를 Qt Widgets Designer 에 노출합니다. 이 클래스의 정의는 사용자 정의 위젯 플러그인 예제의 플러그인 클래스와 유사하며 자세히 설명되어 있습니다. 클래스 정의에서 이 특정 사용자 정의 위젯에 특정한 부분은 클래스 이름과 몇 개의 비공개 슬롯입니다:

#ifndef MULTIPAGEWIDGETPLUGIN_H
#define MULTIPAGEWIDGETPLUGIN_H

#include <QtUiPlugin/QDesignerCustomWidgetInterface>

class QIcon;
class QWidget;

class MultiPageWidgetPlugin: public QObject, public QDesignerCustomWidgetInterface
{
    Q_OBJECT
    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QDesignerCustomWidget")
    Q_INTERFACES(QDesignerCustomWidgetInterface)
public:
    explicit MultiPageWidgetPlugin(QObject *parent = nullptr);

    QString name() const override;
    QString group() const override;
    QString toolTip() const override;
    QString whatsThis() const override;
    QString includeFile() const override;
    QIcon icon() const override;
    bool isContainer() const override;
    QWidget *createWidget(QWidget *parent) override;
    bool isInitialized() const override;
    void initialize(QDesignerFormEditorInterface *formEditor) override;
    QString domXml() const override;

private slots:
    void currentIndexChanged(int index);
    void pageTitleChanged(const QString &title);

private:
    bool initialized = false;
};

#endif

플러그인 클래스는 Qt Widgets Designer 에 클래스 이름과 포함 파일 등 플러그인에 대한 기본 정보를 제공합니다. 또한 MultiPageWidget 위젯의 인스턴스를 생성하는 방법도 알고 있습니다. MultiPageWidgetPlugin 은 플러그인이 Qt Widgets Designer 에 로드된 후 호출되는 initialize() 함수도 정의합니다. 이 함수의 QDesignerFormEditorInterface 매개변수는 플러그인에 Qt Widgets Designer 의 모든 API에 대한 게이트웨이를 제공합니다.

저희와 같은 다중 페이지 위젯의 경우, 사용자가 다른 페이지를 보거나 페이지 제목 중 하나를 변경할 때마다 Qt Widgets Designer 의 속성 편집기를 업데이트할 수 있도록 두 개의 비공개 슬롯인 currentIndexChanged() 및 pageTitleChanged()도 구현해야 합니다. 각 페이지에 고유한 제목을 부여할 수 있도록 QWidget::windowTitle 속성을 사용하여 페이지 제목을 저장하도록 선택했습니다(자세한 내용은 containerextension/multipagewidget.cpp의 MultiPageWidget 클래스 구현을 참조하세요). 현재로서는 미리 정의된 속성을 플레이스홀더로 사용하지 않고 페이지에 사용자 정의 속성(예: 페이지 제목)을 추가할 수 있는 방법이 없습니다.

MultiPageWidgetPlugin 클래스는 QObject 과 QDesignerCustomWidgetInterface 모두에서 상속합니다. 다중 상속을 사용할 때는 Q_INTERFACES() 매크로를 사용하여 모든 인터페이스(즉, Q_OBJECT 를 상속하지 않는 클래스)가 메타 객체 시스템에 알려지도록 해야 한다는 점을 기억하는 것이 중요합니다. 이렇게 하면 Qt Widgets Designer 에서 qobject_cast()를 사용하여 QObject 포인터만 사용하여 지원되는 인터페이스를 쿼리할 수 있습니다.

Qt가 위젯을 플러그인으로 인식하도록 하려면 Q_PLUGIN_METADATA() 매크로를 추가하여 위젯에 대한 관련 정보를 내보냅니다:

    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QDesignerCustomWidget")

이 매크로를 사용하면 Qt Widgets Designer 에서 사용자 정의 위젯을 액세스하고 구성할 수 있습니다. 이 매크로가 없으면 Qt Widgets Designer 에서 위젯을 사용할 수 없습니다.

멀티 페이지 위젯 플러그인 클래스 구현

멀티페이지위젯플러그인 클래스 구현은 대부분의 부분에서 사용자 정의 위젯 플러그인 예제의 플러그인 클래스와 동일합니다:

MultiPageWidgetPlugin::MultiPageWidgetPlugin(QObject *parent)
    : QObject(parent)
{
}

QString MultiPageWidgetPlugin::name() const
{
    return u"MultiPageWidget"_s;
}

QString MultiPageWidgetPlugin::group() const
{
    return u"Display Widgets [Examples]"_s;
}

QString MultiPageWidgetPlugin::toolTip() const
{
    return {};
}

QString MultiPageWidgetPlugin::whatsThis() const
{
    return {};
}

QString MultiPageWidgetPlugin::includeFile() const
{
    return u"multipagewidget.h"_s;
}

QIcon MultiPageWidgetPlugin::icon() const
{
    return {};
}

bool MultiPageWidgetPlugin::isInitialized() const
{
    return initialized;
}

다른 함수 중 하나는 사용자 정의 위젯을 컨테이너로 사용하기 위한 것이므로 이 예제에서는 참을 반환하는 isContainer() 함수입니다.

bool MultiPageWidgetPlugin::isContainer() const
{
    return true;
}

또 다른 다른 함수는 사용자 정의 위젯을 만드는 함수입니다:

QWidget *MultiPageWidgetPlugin::createWidget(QWidget *parent)
{
    auto *widget = new MultiPageWidget(parent);
    connect(widget, &MultiPageWidget::currentIndexChanged,
            this, &MultiPageWidgetPlugin::currentIndexChanged);
    connect(widget, &MultiPageWidget::pageTitleChanged,
            this, &MultiPageWidgetPlugin::pageTitleChanged);
    return widget;
}

위젯을 생성하고 반환하는 것 외에도 사용자 정의 컨테이너 위젯의 currentIndexChanged() 신호를 플러그인의 currentIndexChanged() 슬롯에 연결하여 사용자가 다른 페이지를 볼 때마다 Qt Widgets Designer 의 속성 편집기가 업데이트되도록 합니다. 또한 위젯의 pageTitleChanged() 신호를 플러그인의 pageTitleChanged() 슬롯에 연결합니다.

currentIndexChanged() 슬롯은 사용자 정의 위젯의 currentIndexChanged() 신호가 발생할 때마다, 즉 사용자가 다른 페이지를 볼 때마다 호출됩니다:

void MultiPageWidgetPlugin::currentIndexChanged(int index)
{
    Q_UNUSED(index);
    auto *widget = qobject_cast<MultiPageWidget*>(sender());

먼저 QObject::sender() 및 qobject_cast() 함수를 사용하여 신호를 방출하는 객체를 검색합니다. 신호에 의해 활성화된 슬롯에서 호출된 경우 QObject::sender()는 신호를 보낸 객체에 대한 포인터를 반환하고, 그렇지 않으면 0을 반환합니다.

    if (widget) {
        auto *form = QDesignerFormWindowInterface::findFormWindow(widget);
        if (form)
            form->emitSelectionChanged();
    }
}

위젯이 있으면 속성 편집기를 업데이트할 수 있습니다. Qt Widgets Designer 는 QDesignerPropertySheetExtension 클래스를 사용하여 속성 편집기를 공급하고, 작업 영역에서 위젯이 선택될 때마다 Qt Widgets Designer 는 위젯의 속성 시트 확장을 쿼리하고 속성 편집기를 업데이트합니다.

따라서 우리가 달성하고자 하는 것은 위젯의 내부 선택이 변경되었음을 Qt Widgets Designer 에 알리는 것입니다: 먼저 정적 QDesignerFormWindowInterface::findFormWindow() 함수를 사용하여 위젯이 포함된 QDesignerFormWindowInterface 객체를 검색합니다. QDesignerFormWindowInterface 클래스를 사용하면 Qt Widgets Designer 의 작업 영역에 표시되는 양식 창을 쿼리하고 조작할 수 있습니다. 그런 다음 emitSelectionChanged() 신호를 전송하여 속성 편집기를 강제로 업데이트하기만 하면 됩니다.

페이지 제목을 변경할 때는 실제로 업데이트해야 하는 것은 페이지의 속성 확장이므로 속성 편집기의 일반적인 새로 고침만으로는 충분하지 않습니다. 따라서 제목을 변경하려는 페이지의 QDesignerPropertySheetExtension 객체에 액세스해야 합니다. QDesignerPropertySheetExtension 클래스를 통해서도 위젯의 속성을 조작할 수 있지만 확장자를 가져오려면 먼저 Qt Widgets Designer 의 확장자 관리자에 대한 액세스 권한을 가져와야 합니다:

void MultiPageWidgetPlugin::pageTitleChanged(const QString &title)
{
    Q_UNUSED(title);
    auto *widget = qobject_cast<MultiPageWidget*>(sender());
    if (widget) {
        auto *page = widget->widget(widget->currentIndex());
        auto *form = QDesignerFormWindowInterface::findFormWindow(widget);

여기서도 QObject::sender() 및 qobject_cast() 함수를 사용하여 먼저 신호를 보내는 위젯을 검색합니다. 그런 다음 신호를 보낸 위젯에서 현재 페이지를 검색하고 정적 QDesignerFormWindowInterface::findFormWindow() 함수를 사용하여 위젯이 포함된 폼을 검색합니다.

            auto *editor = form->core();
            auto *manager = editor->extensionManager();

이제 양식 창이 생겼으므로 QDesignerFormWindowInterface 클래스는 현재 QDesignerFormEditorInterface 객체를 반환하는 core() 함수를 제공합니다. QDesignerFormEditorInterface 클래스를 사용하면 Qt Designer 의 다양한 컴포넌트에 액세스할 수 있습니다. 특히 QDesignerFormEditorInterface::extensionManager() 함수는 현재 확장 관리자에 대한 참조를 반환합니다.

            auto *sheet = qt_extension<QDesignerPropertySheetExtension*>(manager, page);
            const int propertyIndex = sheet->indexOf(QLatin1String("windowTitle"));
            sheet->setChanged(propertyIndex, true);
        }
    }
}

확장자 관리자가 있으면 확장자 시트를 업데이트할 수 있습니다: 먼저 qt_extension() 함수를 사용하여 제목을 변경하려는 페이지의 속성 확장자를 검색합니다. 그런 다음 QDesignerPropertySheetExtension::indexOf() 함수를 사용하여 페이지 제목에 대한 색인을 검색합니다. 앞서 언급했듯이 QWidget::windowTitle 속성을 사용하여 페이지 제목을 저장하도록 선택했습니다(자세한 내용은 containerextension/multipagewidget.cpp의 MultiPageWidget 클래스 구현을 참조하세요). 마지막으로 QDesignerPropertySheetExtension::setChanged() 함수를 호출하여 페이지의 속성 시트를 암시적으로 강제로 업데이트합니다.

void MultiPageWidgetPlugin::initialize(QDesignerFormEditorInterface *formEditor)
{
    if (initialized)
        return;

초기화() 함수도 주목하세요: initialize() 함수는 QDesignerFormEditorInterface 객체를 인수로 받습니다.

    auto *manager = formEditor->extensionManager();

사용자 정의 위젯 플러그인과 연결된 확장을 만들 때는 QDesignerFormEditorInterface 매개변수에서 검색하는 Qt Widgets Designer 의 현재 확장 관리자에 액세스해야 합니다.

QExtensionManager 클래스는 위젯의 속성을 조작할 수 있을 뿐만 아니라 Qt Widgets Designer 에 대한 확장 관리 기능을 제공합니다. Qt Widgets Designer 의 현재 확장 관리자를 사용하면 지정된 객체의 확장자를 검색할 수 있습니다. 또한 지정된 객체에 대한 확장자를 등록하고 등록을 취소할 수도 있습니다. 확장자는 Qt Widgets Designer 의 동작을 수정하는 객체라는 것을 기억하세요.

확장 프로그램을 등록할 때 실제로 등록되는 것은 연결된 확장 팩토리입니다. Qt Widgets Designer 에서 확장 팩토리는 필요에 따라 명명된 확장을 조회하고 만드는 데 사용됩니다. 따라서 이 예제에서는 Qt Widgets Designer 에서 연결된 위젯이 컨테이너인지 여부를 알아야 하기 전까지 컨테이너 확장 자체는 생성되지 않습니다.

    auto *factory = new MultiPageWidgetExtensionFactory(manager);

    Q_ASSERT(manager != nullptr);
    manager->registerExtensions(factory, Q_TYPEID(QDesignerContainerExtension));

    initialized = true;
}

Qt Widgets Designer 의 현재 extension manager 에서 검색한 QDesignerFormEditorInterface 매개변수를 사용하여 등록하는 MultiPageWidgetExtensionFactory 객체를 생성합니다. 첫 번째 인수는 새로 생성된 팩토리이고 두 번째 인수는 문자열인 확장 식별자입니다. Q_TYPEID() 매크로는 단순히 문자열을 QLatin1String 으로 변환합니다.

MultiPageWidgetExtensionFactory 클래스는 QExtensionFactory 의 서브클래스입니다. Qt Widgets Designer 가 위젯이 컨테이너인지 여부를 알아야 하는 경우 Qt Widgets Designer 의 확장 관리자는 등록된 모든 팩토리를 실행하여 해당 위젯의 컨테이너 확장을 생성할 수 있는 첫 번째 팩토리를 호출합니다. 이 팩토리는 차례로 MultiPageWidgetExtension 객체를 생성합니다.

QString MultiPageWidgetPlugin::domXml() const
{
    return uR"(
<ui language="c++">
    <widget class="MultiPageWidget" name="multipagewidget">
        <widget class="QWidget" name="page"/>
    </widget>
    <customwidgets>
        <customwidget>
            <class>MultiPageWidget</class>
            <extends>QWidget</extends>
            <addpagemethod>addPage</addpagemethod>
        </customwidget>
    </customwidgets>
</ui>)"_s;
}

마지막으로 domXml() 함수를 살펴보세요. 이 함수에는 Qt Widgets Designer 에서 사용하는 표준 XML 형식의 위젯 기본 설정이 포함되어 있습니다. 이 경우 컨테이너의 첫 페이지를 지정하며, 멀티 페이지 위젯의 모든 초기 페이지는 이 함수 내에서 지정해야 합니다.

멀티페이지위젯익스텐션팩토리 클래스 정의

MultiPageWidgetExtensionFactory 클래스는 Qt Widgets Designer 에 대한 표준 확장 팩토리를 제공하는 QExtensionFactory 을 상속합니다.

class MultiPageWidgetExtensionFactory: public QExtensionFactory
{
    Q_OBJECT

public:
    explicit MultiPageWidgetExtensionFactory(QExtensionManager *parent = nullptr);

protected:
    QObject *createExtension(QObject *object, const QString &iid, QObject *parent) const override;
};

이 서브클래스의 목적은 QExtensionFactory::createExtension() 함수를 재구현하여 MultiPageWidget 컨테이너 확장을 생성할 수 있도록 하는 것입니다.

멀티페이지위젯 익스텐션 팩토리 클래스 구현

클래스 생성자는 QExtensionFactory 베이스 클래스 생성자를 호출하기만 하면 됩니다:

MultiPageWidgetExtensionFactory::MultiPageWidgetExtensionFactory(QExtensionManager *parent)
    : QExtensionFactory(parent)
{}

위에서 설명한 것처럼 팩토리는 Qt Widgets Designer 에서 연결된 위젯이 컨테이너인지 아닌지를 알아야 할 때 호출됩니다.

QObject *MultiPageWidgetExtensionFactory::createExtension(QObject *object,
                                                          const QString &iid,
                                                          QObject *parent) const
{
    auto *widget = qobject_cast<MultiPageWidget*>(object);

    if (widget && (iid == Q_TYPEID(QDesignerContainerExtension)))
        return new MultiPageWidgetContainerExtension(widget, parent);
    return nullptr;
}

Qt Widgets Designer의 동작은 요청된 확장이 컨테이너, 멤버 시트, 속성 시트 또는 작업 메뉴와 연관되어 있는지 여부와 관계없이 동일합니다: 확장자 관리자는 요청된 확장자를 만들어 응답할 때까지 등록된 모든 확장자 팩토리를 통해 각각에 대해 createExtension() 을 호출합니다.

따라서 MultiPageWidgetExtensionFactory::createExtension() 에서 가장 먼저 하는 일은 확장이 요청된 QObject 이 실제로 MultiPageWidget 개체인지 확인하는 것입니다. 그런 다음 요청된 확장자가 컨테이너 확장자인지 확인합니다.

객체가 컨테이너 확장을 요청하는 멀티페이지위젯인 경우 MultiPageWidgetExtension 객체를 생성하고 반환합니다. 그렇지 않으면 null 포인터를 반환하여 Qt Widgets Designer 의 확장 관리자가 등록된 팩토리를 통해 검색을 계속할 수 있도록 합니다.

멀티페이지위젯컨테이너익스텐션 클래스 정의

MultiPageWidgetContainerExtension 클래스는 QDesignerContainerExtension 을 상속하여 Qt Widgets Designer 에서 다중 페이지 컨테이너 플러그인에 페이지를 추가(및 삭제)할 수 있습니다.

class MultiPageWidgetContainerExtension: public QObject,
                                         public QDesignerContainerExtension
{
    Q_OBJECT
    Q_INTERFACES(QDesignerContainerExtension)

public:
    explicit MultiPageWidgetContainerExtension(MultiPageWidget *widget, QObject *parent);

    bool canAddWidget() const override;
    void addWidget(QWidget *widget) override;
    int count() const override;
    int currentIndex() const override;
    void insertWidget(int index, QWidget *widget) override;
    bool canRemove(int index) const override;
    void remove(int index) override;
    void setCurrentIndex(int index) override;
    QWidget *widget(int index) const override;

private:
    MultiPageWidget *myWidget;
};

QDesignerContainerExtension 클래스는 사용자 정의 다중 페이지 위젯의 기능에 대한 Qt Widgets Designer 액세스를 제공하기 위한 것일 뿐이며, 사용자 정의 다중 페이지 위젯은 확장 기능에 해당하는 기능을 구현해야 한다는 점을 알아두는 것이 중요합니다.

또한 부모 위젯과 작업 메뉴가 요청되는 MultiPageWidget 객체라는 두 가지 인수를 받는 생성자를 구현한다는 점에 유의하세요.

QDesignerContainerExtension 는 기본적으로 Qt Widgets Designer 의 작업 메뉴에 몇 가지 메뉴 항목을 제공하여 사용자가 Qt Widgets Designer 의 작업 영역에서 연결된 사용자 정의 다중 페이지 위젯에 페이지를 추가하거나 삭제할 수 있도록 합니다.

멀티 페이지 위젯 컨테이너 확장 클래스 구현

생성자에서는 매개변수로 전송된 MultiPageWidget 객체, 즉 확장에 연결된 위젯에 대한 참조를 저장합니다. 나중에 요청된 작업을 수행하는 사용자 정의 다중 페이지 위젯에 액세스하려면 이 참조가 필요합니다.

MultiPageWidgetContainerExtension::MultiPageWidgetContainerExtension(MultiPageWidget *widget,
                                                                     QObject *parent)
    : QObject(parent)
    , myWidget(widget)
{
}

Qt Widgets Designer 에서 사용자 정의 다중 페이지 위젯을 관리하고 조작할 수 있도록 완전히 활성화하려면 QDesignerContainerExtension 의 모든 기능을 다시 구현해야 합니다:

bool MultiPageWidgetContainerExtension::canAddWidget() const
{
    return true;
}

void MultiPageWidgetContainerExtension::addWidget(QWidget *widget)
{
    myWidget->addPage(widget);
}

int MultiPageWidgetContainerExtension::count() const
{
    return myWidget->count();
}

int MultiPageWidgetContainerExtension::currentIndex() const
{
    return myWidget->currentIndex();
}

컨테이너에 지정된 페이지를 추가하는 canAddWidget() 및 addWidget(), 컨테이너의 페이지 수를 반환하는 count(), 현재 선택한 페이지의 색인을 반환하는 currentIndex()을 다시 구현해야 합니다.

void MultiPageWidgetContainerExtension::insertWidget(int index, QWidget *widget)
{
    myWidget->insertPage(index, widget);
}

bool MultiPageWidgetContainerExtension::canRemove(int index) const
{
    Q_UNUSED(index);
    return true;
}

void MultiPageWidgetContainerExtension::remove(int index)
{
    myWidget->removePage(index);
}

void MultiPageWidgetContainerExtension::setCurrentIndex(int index)
{
    myWidget->setCurrentIndex(index);
}

QWidget* MultiPageWidgetContainerExtension::widget(int index) const
{
    return myWidget->widget(index);
}

주어진 인덱스의 컨테이너에 주어진 페이지를 추가하는 insertWidget(), 주어진 인덱스의 페이지를 삭제하는 canRemove() 및 remove(), 현재 선택된 페이지의 인덱스를 설정하는 setCurrentIndex(), 마지막으로 주어진 인덱스의 페이지를 반환하는 widget() 함수를 다시 구현해야 합니다.

멀티페이지위젯 클래스 정의

MultiPageWidget 클래스는 사용자가 페이지를 조작하고 채우고 콤보박스를 사용하여 페이지를 탐색할 수 있는 사용자 정의 컨테이너 위젯입니다.

class MultiPageWidget : public QWidget
{
    Q_OBJECT
    Q_PROPERTY(int currentIndex READ currentIndex WRITE setCurrentIndex)
    Q_PROPERTY(QString pageTitle READ pageTitle WRITE setPageTitle STORED false)

public:
    explicit MultiPageWidget(QWidget *parent = nullptr);

    QSize sizeHint() const override;

    int count() const;
    int currentIndex() const;
    QWidget *widget(int index);
    QString pageTitle() const;

public slots:
    void addPage(QWidget *page);
    void insertPage(int index, QWidget *page);
    void removePage(int index);
    void setPageTitle(const QString &newTitle);
    void setCurrentIndex(int index);

private slots:
    void pageWindowTitleChanged();

signals:
    void currentIndexChanged(int index);
    void pageTitleChanged(const QString &title);

private:
    QStackedWidget *stackWidget;
    QComboBox *comboBox;
};

주의해야 할 주요 세부 사항은 QDesignerContainerExtension 클래스는 사용자 정의 다중 페이지 위젯의 기능에 대한 Qt Designer 액세스만 제공하기 위한 것이므로 사용자 정의 다중 페이지 위젯은 QDesignerContainerExtension 의 멤버 함수에 해당하는 기능을 구현해야 한다는 것입니다.

또한 currentIndex 및 pageTitle 속성과 관련 set 및 get 함수를 선언합니다. 이러한 속성을 속성으로 선언하면 Qt Widgets Designer 에서 멀티페이지위젯 위젯이 QWidget 및 QObject 에서 상속하는 속성을 관리하는 것과 동일한 방식으로 관리할 수 있습니다(예: 속성 편집기 기능).

pageTitle 속성의 선언에서 STORED 속성에 주목하세요: STORED 속성은 지속성을 나타내며, 즉 객체의 상태를 저장할 때 속성 값을 기억해야 하는지 여부를 선언합니다. 위에서 언급했듯이 각 페이지에 고유한 제목을 부여하기 위해 QWidget::windowTitle 속성을 사용하여 페이지 제목을 저장하기로 선택했습니다. 따라서 pageTitle 프로퍼티는 편집 목적으로 제공되는 '가짜' 프로퍼티이므로 저장할 필요가 없습니다.

또한 사용자가 다른 페이지를 보거나 페이지 제목 중 하나를 변경할 때마다 Qt Widgets Designer 의 속성 편집기가 업데이트되도록 currentIndexChanged() 및 pageTitleChanged() 신호를 구현하고 발산해야 합니다.

자세한 내용은 containerextension/multipagewidget.cpp의 MultiPageWidget 클래스 구현을 참조하세요.

예제 프로젝트 @ code.qt.io