Ejemplo de extensión de contenedor

El ejemplo de extensión de contenedor muestra cómo crear un complemento multipágina personalizado para Qt Widgets Designer utilizando la clase QDesignerContainerExtension.

Qt Widgets Designer mostrando la opción de insertar la página anterior a la actual en un objeto" src="images/containerextension-example.webp" title="Captura de pantalla del editor de IU Qt Widgets Designer mostrando la opción de insertar la página anterior a la actual en un objeto"/>

Para proporcionar un widget personalizado que se pueda utilizar con Qt Widgets Designer, necesitamos proporcionar una implementación autónoma. En este ejemplo utilizamos un widget multipágina personalizado diseñado para mostrar la función de extensión del contenedor.

Una extensión es un objeto que modifica el comportamiento de Qt Widgets Designer. QDesignerContainerExtension permite a Qt Widgets Designer gestionar y manipular un widget multipágina personalizado, es decir, añadir y eliminar páginas al widget.

Existen cuatro tipos de extensiones disponibles en Qt Widgets Designer:

• QDesignerMemberSheetExtension proporciona una extensión que permite manipular las funciones miembro de un widget que se muestra al configurar conexiones mediante el modo de edición de señales y ranuras de Qt Widgets Designer.
• QDesignerPropertySheetExtension proporciona una extensión que permite manipular las propiedades de un widget y que se muestra en el editor de propiedades de Qt Widgets Designer.
• QDesignerTaskMenuExtension proporciona una extensión que permite añadir entradas de menú personalizadas al menú de tareas de Qt Widgets Designer.
• QDesignerContainerExtension proporciona una extensión que permite añadir (y eliminar) páginas a un plugin contenedor multipágina en Qt Widgets Designer.

Puede utilizar todas las extensiones siguiendo el mismo patrón que en este ejemplo, sustituyendo únicamente la clase base de la extensión correspondiente. Para más información, consulte Qt Widgets Designer C++ Classes.

El ejemplo de extensión de contenedor consta de cuatro clases:

• MultiPageWidget es un widget contenedor personalizado que permite al usuario manipular y rellenar sus páginas, y navegar entre ellas utilizando un combobox.
• MultiPageWidgetPlugin expone la clase MultiPageWidget a Qt Widgets Designer.
• MultiPageWidgetExtensionFactory crea un objeto MultiPageWidgetContainerExtension.
• MultiPageWidgetContainerExtension proporciona la extensión del contenedor.

Los archivos de proyecto de los plugins de widgets personalizados necesitan información adicional para garantizar su funcionamiento en Qt Widgets Designer. Por ejemplo, los plugins de widgets personalizados dependen de componentes suministrados con Qt Widgets Designer, y esto debe especificarse en los archivos de proyecto que utilicemos. Primero echaremos un vistazo a los archivos de proyecto del plugin.

Luego continuaremos revisando la clase MultiPageWidgetPlugin, y echaremos un vistazo a las clases MultiPageWidgetExtensionFactory y MultiPageWidgetContainerExtension. Por último, echaremos un vistazo rápido a la definición de la clase MultiPageWidget.

Archivos de proyecto

CMake

Los archivos del proyecto deben indicar que se va a construir un plugin que enlace con las librerías 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
)

El siguiente ejemplo muestra cómo añadir los archivos de cabecera y fuente del widget:

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

Proporcionamos una implementación de la interfaz del plugin para que Qt Widgets Designer pueda utilizar el widget personalizado. En este ejemplo en particular también proporcionamos implementaciones de la interfaz de extensión del contenedor y de la fábrica de extensiones.

Es importante asegurarse de que el plugin se instala en una ubicación que sea buscada por Qt Widgets Designer. Hacemos esto especificando una ruta de destino para el proyecto y añadiéndolo a la lista de elementos a instalar:

   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}"
)

La extensión del contenedor se crea como una biblioteca. Se instalará junto con los demás plugins de Qt Widgets Designer cuando se instale el proyecto (utilizando ninja install o un procedimiento de instalación equivalente).

Para más información sobre plugins, consulte la documentación Cómo crear plugins de Qt.

qmake

El siguiente ejemplo muestra cómo vincular un plugin a las librerías Qt Widgets Designer:

TEMPLATE = lib
CONFIG  += plugin

QT      += widgets designer

El siguiente ejemplo muestra cómo añadir los archivos de cabecera y fuente del widget:

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

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

OTHER_FILES += multipagewidget.json

El siguiente ejemplo muestra cómo instalar un plugin en la ruta de plugins de Qt Widgets Designer:

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

Definición de la clase MultiPageWidgetPlugin

La clase MultiPageWidgetPlugin expone la clase MultiPageWidget a Qt Widgets Designer. Su definición es similar a la clase plugin del ejemplo Custom Widget Plugin que se explica en detalle. Las partes de la definición de la clase que es específica para este widget personalizado en particular es el nombre de la clase y un par de ranuras privadas:

#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

La clase plugin proporciona a Qt Widgets Designer información básica sobre nuestro plugin, como su nombre de clase y su archivo de inclusión. Además, sabe cómo crear instancias del widget MultiPageWidget. MultiPageWidgetPlugin también define la función initialize(), a la que se llama después de cargar el plugin en Qt Widgets Designer. El parámetro QDesignerFormEditorInterface de la función proporciona al plugin una puerta de acceso a todas las API de Qt Widgets Designer.

En el caso de un widget multipágina como el nuestro, también debemos implementar dos ranuras privadas, currentIndexChanged() y pageTitleChanged(), para poder actualizar el editor de propiedades de Qt Widgets Designer cada vez que el usuario vea otra página o cambie uno de los títulos de página. Para poder dar a cada página su propio título, hemos optado por utilizar la propiedad QWidget::windowTitle para almacenar el título de la página (para más información ver la implementación de la clase MultiPageWidget en containerextension/multipagewidget.cpp. Tenga en cuenta que actualmente no hay forma de añadir una propiedad personalizada (por ejemplo, un título de página) a las páginas sin utilizar una propiedad predefinida como marcador de posición.

La clase MultiPageWidgetPlugin hereda tanto de QObject como de QDesignerCustomWidgetInterface. Es importante recordar, cuando se utiliza herencia múltiple, asegurarse de que todas las interfaces (es decir, las clases que no heredan de Q_OBJECT) se dan a conocer al meta sistema de objetos utilizando la macro Q_INTERFACES(). Esto permite a Qt Widgets Designer utilizar qobject_cast() para consultar las interfaces soportadas utilizando únicamente un puntero QObject.

Para asegurar que Qt reconoce el widget como un plugin, exporta la información relevante sobre el widget añadiendo la macro Q_PLUGIN_METADATA():

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

Con esta macro, Qt Widgets Designer puede acceder y construir el widget personalizado. Sin esta macro, no hay forma de que Qt Widgets Designer utilice el widget.

Implementación de la clase MultiPageWidgetPlugin

La implementación de la clase MultiPageWidgetPlugin es en su mayor parte equivalente a la clase plugin del ejemplo Custom Widget Plugin:

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;
}

Una de las funciones que difieren es la función isContainer() que devuelve true en este ejemplo ya que nuestro widget personalizado está pensado para ser utilizado como contenedor.

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

Otra función que difiere es la función que crea nuestro widget personalizado:

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;
}

Además de crear y devolver el widget, conectamos la señal currentIndexChanged() de nuestro widget contenedor personalizado a la ranura currentIndexChanged() del plugin para asegurarnos de que el editor de propiedades de Qt Widgets Designer se actualiza cada vez que el usuario ve otra página. También conectamos la señal pageTitleChanged() del widget a la ranura pageTitleChanged() del plugin.

La ranura currentIndexChanged() se llama cada vez que se emite la señal currentIndexChanged() de nuestro widget personalizado, es decir, cada vez que el usuario ve otra página:

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

En primer lugar, recuperamos el objeto que emite la señal utilizando las funciones QObject::sender() y qobject_cast(). Si se llama en una ranura activada por una señal, QObject::sender() devuelve un puntero al objeto que envió la señal; en caso contrario, devuelve 0.

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

Una vez que tenemos el widget podemos actualizar el editor de propiedades. Qt Widgets Designer utiliza la clase QDesignerPropertySheetExtension para alimentar su editor de propiedades, y siempre que se seleccione un widget en su espacio de trabajo, Qt Widgets Designer consultará la extensión de la hoja de propiedades del widget y actualizará el editor de propiedades.

Así que lo que queremos conseguir es notificar a Qt Widgets Designer que la selección interna de nuestro widget ha cambiado: Primero usamos la función estática QDesignerFormWindowInterface::findFormWindow() para recuperar el objeto QDesignerFormWindowInterface que contiene el widget. La clase QDesignerFormWindowInterface permite consultar y manipular las ventanas de formulario que aparecen en el espacio de trabajo de Qt Widgets Designer. Después, todo lo que tenemos que hacer es emitir su señal emitSelectionChanged(), forzando una actualización del editor de propiedades.

Cuando cambiamos el título de una página no basta con refrescar genéricamente el editor de propiedades, ya que en realidad lo que hay que actualizar es la extensión de propiedades de la página. Por ello necesitamos acceder al objeto QDesignerPropertySheetExtension de la página cuyo título queremos cambiar. La clase QDesignerPropertySheetExtension también permite manipular las propiedades de un widget, pero para obtener la extensión primero debemos recuperar el acceso al gestor de extensiones de 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);

De nuevo recuperamos primero el widget que emite la señal, usando las funciones QObject::sender() y qobject_cast(). Después recuperamos la página actual del widget que emitió la señal, y utilizamos la función estática QDesignerFormWindowInterface::findFormWindow() para recuperar el formulario que contiene nuestro widget.

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

Ahora que tenemos la ventana del formulario, la clase QDesignerFormWindowInterface proporciona la función core() que devuelve el objeto QDesignerFormEditorInterface actual. La clase QDesignerFormEditorInterface permite acceder a los distintos componentes de Qt Designer. En particular, la función QDesignerFormEditorInterface::extensionManager() devuelve una referencia al gestor de extensiones actual.

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

Una vez que tenemos el gestor de extensiones podemos actualizar la hoja de extensiones: Primero recuperamos la extensión de la propiedad de la página cuyo título queremos cambiar, utilizando la función qt_extension(). Luego recuperamos el índice para el título de la página usando la función QDesignerPropertySheetExtension::indexOf(). Como se ha mencionado anteriormente, hemos elegido utilizar la propiedad QWidget::windowTitle para almacenar el título de la página (para más información consulte la implementación de la clase MultiPageWidget en containerextension/multipagewidget.cpp. Por último, forzamos implícitamente una actualización de la hoja de propiedades de la página llamando a la función QDesignerPropertySheetExtension::setChanged().

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

Fíjate también en la función initialize(): La función initialize() toma un objeto QDesignerFormEditorInterface como argumento.

    auto *manager = formEditor->extensionManager();

Al crear extensiones asociadas a plugins de widgets personalizados, necesitamos acceder al gestor de extensiones actual de Qt Widgets Designer, que recuperamos del parámetro QDesignerFormEditorInterface.

Además de permitirte manipular las propiedades de un widget, la clase QExtensionManager proporciona facilidades de gestión de extensiones para Qt Widgets Designer. Usando el gestor de extensiones actual de Qt Widgets Designer puedes recuperar la extensión de un objeto dado. También puedes registrar y anular el registro de una extensión para un objeto determinado. Recuerde que una extensión es un objeto que modifica el comportamiento de Qt Widgets Designer.

Al registrar una extensión, en realidad lo que se registra es la fábrica de extensiones asociada. En Qt Widgets Designer, las fábricas de extensiones se utilizan para buscar y crear extensiones con nombre a medida que se necesitan. Así, en este ejemplo, la extensión contenedor en sí no se crea hasta que Qt Widgets Designer debe saber si el widget asociado es un contenedor, o no.

    auto *factory = new MultiPageWidgetExtensionFactory(manager);

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

    initialized = true;
}

Creamos un objeto MultiPageWidgetExtensionFactory que registramos utilizando el parámetro extension manager actual de Qt Widgets Designer recuperado de QDesignerFormEditorInterface. El primer argumento es la fábrica recién creada y el segundo argumento es un identificador de extensión que es una cadena. La macro Q_TYPEID() simplemente convierte la cadena en un QLatin1String.

La clase MultiPageWidgetExtensionFactory es una subclase de QExtensionFactory. Cuando Qt Widgets Designer debe saber si un widget es un contenedor o no, el gestor de extensiones de Qt Widgets Designer recorrerá todas sus fábricas registradas invocando a la primera que sea capaz de crear una extensión contenedor para ese widget. Esta fábrica creará a su vez un objeto 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;
}

Por último, eche un vistazo a la función domXml(). Esta función incluye la configuración por defecto para el widget en el formato XML estándar utilizado por Qt Widgets Designer. En este caso, especificamos la primera página del contenedor; cualquier página inicial de un widget multipágina debe ser especificada dentro de esta función.

Definición de la clase MultiPageWidgetExtensionFactory

La clase MultiPageWidgetExtensionFactory hereda de QExtensionFactory que proporciona una fábrica de extensión estándar para Qt Widgets Designer.

class MultiPageWidgetExtensionFactory: public QExtensionFactory
{
    Q_OBJECT

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

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

El propósito de la subclase es reimplementar la función QExtensionFactory::createExtension(), haciéndola capaz de crear una extensión de contenedor MultiPageWidget.

Implementación de la clase MultiPageWidgetExtensionFactory

El constructor de la clase simplemente llama al constructor de la clase base QExtensionFactory:

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

Como se ha descrito anteriormente, la fábrica es invocada cuando Qt Widgets Designer debe saber si el widget asociado es un contenedor, o no.

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 El comportamiento de Designer es el mismo si la extensión solicitada está asociada a un contenedor, una hoja de miembros, una hoja de propiedades o un menú de tareas: Su gestor de extensiones recorre todas sus fábricas de extensiones registradas llamando a createExtension() para cada una de ellas hasta que una responde creando la extensión solicitada.

Así que lo primero que hacemos en MultiPageWidgetExtensionFactory::createExtension() es comprobar si el QObject, para el que se solicita la extensión, es de hecho un objeto MultiPageWidget. Después comprobamos si la extensión solicitada es una extensión contenedor.

Si el objeto es un MultiPageWidget que solicita una extensión contenedora, creamos y devolvemos un objeto MultiPageWidgetExtension. En caso contrario, simplemente devolvemos un puntero nulo, permitiendo al gestor de extensiones de Qt Widgets Designer continuar su búsqueda a través de las fábricas registradas.

Definición de la clase MultiPageWidgetContainerExtension

La clase MultiPageWidgetContainerExtension hereda de QDesignerContainerExtension que permite añadir (y eliminar) páginas a un plugin contenedor multipágina en 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;
};

Es importante reconocer que la clase QDesignerContainerExtension sólo está pensada para proporcionar a Qt Widgets Designer acceso a la funcionalidad de su widget multipágina personalizado; su widget multipágina personalizado debe implementar la funcionalidad correspondiente a las funciones de la extensión.

Observe también que implementamos un constructor que toma dos argumentos: el widget padre y el objeto MultiPageWidget para el que se solicita el menú de tareas.

QDesignerContainerExtension proporciona un par de entradas de menú en el menú de tareas de Qt Widgets Designer de forma predeterminada, lo que permite al usuario añadir o eliminar páginas al widget multipágina personalizado asociado en el espacio de trabajo de Qt Widgets Designer.

Implementación de la clase MultiPageWidgetContainerExtension

En el constructor guardamos la referencia al objeto MultiPageWidget enviado como parámetro, es decir, el widget asociado a la extensión. Lo necesitaremos más adelante para acceder al widget multipágina personalizado que realiza las acciones solicitadas.

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

Para habilitar completamente Qt Widgets Designer para gestionar y manipular su widget multipágina personalizado, debe reimplementar todas las funciones de 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();
}

Debe reimplementar canAddWidget() y addWidget() para añadir una página determinada al contenedor, count() para devolver el número de páginas del contenedor y currentIndex() para devolver el índice de la página seleccionada en ese momento.

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);
}

Debe reimplementar insertWidget() añadiendo una página dada al contenedor en un índice dado, canRemove() y remove() borrando la página en un índice dado, setCurrentIndex() estableciendo el índice de la página seleccionada actualmente, y finalmente widget() devolviendo la página en un índice dado.

Definición de la clase MultiPageWidget

La clase MultiPageWidget es un widget contenedor personalizado que permite al usuario manipular y rellenar sus páginas, y navegar entre ellas usando un combobox.

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;
};

El principal detalle a tener en cuenta es que tu widget multipágina personalizado debe implementar la funcionalidad correspondiente a las funciones miembro de QDesignerContainerExtension ya que la clase QDesignerContainerExtension sólo está pensada para proporcionar Qt Designer acceso a la funcionalidad de tu widget multipágina personalizado.

Además, declaramos las propiedades currentIndex y pageTitle, y sus funciones asociadas set y get. Al declarar estos atributos como propiedades, permitimos a Qt Widgets Designer gestionarlos de la misma forma que gestiona las propiedades que el widget MultiPageWidget hereda de QWidget y QObject, por ejemplo presentando el editor de propiedades.

Observe el atributo STORED en la declaración de la propiedad pageTitle: El atributo STORED indica persistencia, es decir, declara si el valor de la propiedad debe ser recordado al almacenar el estado de un objeto. Como se ha mencionado anteriormente, hemos elegido almacenar el título de la página utilizando la propiedad QWidget::windowTitle para poder dar a cada página su propio título. Por esa razón la propiedad pageTitle es una propiedad "falsa", proporcionada para propósitos de edición, y no necesita ser almacenada.

También debemos implementar y emitir las señales currentIndexChanged() y pageTitleChanged() para asegurarnos de que el editor de propiedades de Qt Widgets Designer se actualiza cada vez que el usuario ve otra página o cambia uno de los títulos de las páginas.

Consulte la implementación de la clase MultiPageWidget en containerextension/multipagewidget.cpp para obtener más detalles.

Proyecto de ejemplo @ code.qt.io