Ejemplo de extensión de contenedor
Creación de un complemento personalizado de varias páginas para Qt Widgets Designer.
El ejemplo de la extensión «Container» muestra cómo crear un complemento personalizado de varias páginas para Qt Widgets Designer utilizando la clase QDesignerContainerExtension.
Qt Widgets Designer en la que se muestra la opción de insertar una página antes de la página actual en un objeto" src="images/containerextension-example.webp" title="Captura de pantalla del editor de interfaz de usuario Qt Widgets Designer en la que se muestra la opción de insertar una página antes de la página actual en un objeto"/>
Para ofrecer un widget personalizado que se pueda utilizar con Qt Widgets Designer, debemos proporcionar una implementación autónoma. En este ejemplo utilizamos un widget de varias páginas personalizado diseñado para mostrar la funcionalidad de la extensión de contenedor.
Una extensión es un objeto que modifica el comportamiento de Qt Widgets Designer. La clase QDesignerContainerExtension permite a Qt Widgets Designer gestionar y manipular un widget multipágina personalizado, es decir, añadir y eliminar páginas del widget.
Hay cuatro tipos de extensiones disponibles en Qt Widgets Designer:
- QDesignerMemberSheetExtension proporciona una extensión que permite manipular las funciones miembro de un widget y que se muestra al configurar conexiones utilizando el modo de Qt Widgets Designer para editar señales y ranuras.
- QDesignerPropertySheetExtension proporciona una extensión que permite manipular las propiedades de un widget, 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 complemento contenedor de varias páginas en Qt Widgets Designer.
Puedes utilizar todas las extensiones siguiendo el mismo patrón que en este ejemplo, simplemente sustituyendo la clase base de la extensión correspondiente. Para obtener más información, consulta Qt Widgets Designer C++ Classes.
El ejemplo de la extensión «Container» consta de cuatro clases:
MultiPageWidgetes un widget contenedor personalizado que permite al usuario manipular y rellenar sus páginas, así como navegar entre ellas mediante un cuadro combinado.MultiPageWidgetPluginexpone la clase `MultiPageWidget` a ` Qt Widgets Designer`.MultiPageWidgetExtensionFactorycrea un objeto `MultiPageWidgetContainerExtension`.MultiPageWidgetContainerExtensionproporciona la extensión del contenedor.
Los archivos de proyecto de los complementos de widgets personalizados necesitan cierta información adicional para garantizar que funcionen dentro de Qt Widgets Designer. Por ejemplo, los complementos de widgets personalizados dependen de componentes proporcionados por Qt Widgets Designer, y esto debe especificarse en los archivos de proyecto que utilizamos. En primer lugar, echaremos un vistazo a los archivos de proyecto del complemento.
A continuación, continuaremos revisando la clase ` MultiPageWidgetPlugin ` y analizaremos 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 compilar un complemento que se vincula a las bibliotecas 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 de código 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 complemento para que Qt Widgets Designer pueda utilizar el widget personalizado. En este ejemplo concreto, 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 complemento se instale en una ubicación en la que Qt Widgets Designer realice la búsqueda. Para ello, especificamos una ruta de destino para el proyecto y la añadimos a la lista de elementos que se van 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 de contenedor se crea como una biblioteca. Se instalará junto con los demás complementos de Qt Widgets Designer cuando se instale el proyecto (mediante ninja install o un procedimiento de instalación equivalente).
Para obtener más información sobre los complementos, consulta la documentación «Cómo crear complementos de Qt ».
qmake
El siguiente ejemplo muestra cómo vincular un complemento a las bibliotecas de Qt Widgets Designer:
TEMPLATE = lib
CONFIG += plugin
QT += widgets designerEl siguiente ejemplo muestra cómo añadir los archivos de cabecera y de código fuente del widget:
HEADERS += multipagewidget.h \
multipagewidgetplugin.h \
multipagewidgetcontainerextension.h \
multipagewidgetextensionfactory.h
SOURCES += multipagewidget.cpp \
multipagewidgetplugin.cpp \
multipagewidgetcontainerextension.cpp \
multipagewidgetextensionfactory.cpp
OTHER_FILES += multipagewidget.jsonEl siguiente ejemplo muestra cómo instalar un complemento en la ruta de complementos de Qt Widgets Designer:
target.path = $$[QT_INSTALL_PLUGINS]/designer
INSTALLS += targetDefinición de la clase MultiPageWidgetPlugin
La clase ` MultiPageWidgetPlugin ` expone la clase ` MultiPageWidget ` a ` Qt Widgets Designer`. Su definición es similar a la de la clase de complemento del ejemplo «Complemento de widget personalizado», que se explica con detalle. Las partes de la definición de la clase que son específicas de este widget personalizado en particular son 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;
};
#endifLa clase del 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(), que se invoca después de que el plugin se haya cargado 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 slots privados, `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 las páginas. Para poder asignar 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, véase 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 que, al utilizar herencia múltiple, hay que asegurarse de que todas las interfaces (es decir, las clases que no heredan de ` Q_OBJECT`) se den a conocer al sistema de metobjetos mediante la macro ` Q_INTERFACES()`. Esto permite que ` Qt Widgets Designer ` utilice ` qobject_cast()` para consultar las interfaces compatibles utilizando únicamente un puntero ` QObject `.
Para garantizar que Qt reconozca el widget como un complemento, se debe exportar 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 al widget personalizado y crearlo. Sin esta macro, Qt Widgets Designer no tiene forma de utilizar el widget.
Implementación de la clase `MultiPageWidgetPlugin`
La implementación de la clase `MultiPageWidgetPlugin` es, en su mayor parte, equivalente a la clase del plugin del ejemplo «Plugin de widget personalizado »:
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 difiere es la función isContainer(), que devuelve «true» en este ejemplo, ya que nuestro widget personalizado está pensado para utilizarse como contenedor.
bool MultiPageWidgetPlugin::isContainer() const
{
return true;
}Otra función que difiere es la 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 garantizar que el editor de propiedades de Qt Widgets Designer se actualice cada vez que el usuario vea otra página. También conectamos la señal pageTitleChanged() del widget a la ranura pageTitleChanged() del plugin.
El slot currentIndexChanged() se invoca cada vez que se emite la señal currentIndexChanged() de nuestro widget personalizado, es decir, cada vez que el usuario visita 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 invoca 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 cada vez que se selecciona un widget en su espacio de trabajo, Qt Widgets Designer consulta la extensión de la hoja de propiedades del widget y actualiza el editor de propiedades.
Así pues, lo que queremos conseguir es notificar a Qt Widgets Designer que la selección interna de nuestro widget ha cambiado: primero utilizamos 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. A continuación, solo tenemos que emitir su señal emitSelectionChanged(), lo que fuerza una actualización del editor de propiedades.
Al cambiar el título de una página, no basta con una actualización genérica del editor de propiedades, ya que en realidad es la extensión de propiedades de la página la que debe actualizarse. Por ese motivo, 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 debemos primero acceder 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, primero recuperamos el widget que emite la señal, utilizando las funciones ` QObject::sender()` y ` qobject_cast()`. A continuación, recuperamos la página actual a partir 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 concreto, 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 disponemos del gestor de extensiones, podemos actualizar la hoja de extensión: en primer lugar, recuperamos la propiedad «extension» de la página cuyo título queremos cambiar, utilizando la función « qt_extension()». A continuación, recuperamos el índice del título de la página mediante la función « QDesignerPropertySheetExtension::indexOf()». Como se ha mencionado anteriormente, hemos optado por utilizar la propiedad ` QWidget::windowTitle ` para almacenar el título de la página (para más información, véase 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 como argumento un objeto ` QDesignerFormEditorInterface `.
auto *manager = formEditor->extensionManager();Al crear extensiones asociadas a complementos de widgets personalizados, necesitamos acceder al gestor de extensiones actual de ` Qt Widgets Designer`, que obtenemos a partir del parámetro ` QDesignerFormEditorInterface `.
Además de permitirte manipular las propiedades de un widget, la clase QExtensionManager proporciona funciones de gestión de extensiones para Qt Widgets Designer. Mediante el gestor de extensiones actual de Qt Widgets Designer, puedes recuperar la extensión de un objeto determinado. También puedes registrar y dar de baja una extensión para un objeto determinado. Recuerda que una extensión es un objeto que modifica el comportamiento de Qt Widgets Designer.
Al registrar una extensión, lo que realmente 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 según sea necesario. Por lo tanto, en este ejemplo, la propia extensión «container» no se crea hasta que Qt Widgets Designer necesita 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 ` extension manager ` actual de ` Qt Widgets Designer`, obtenido del parámetro ` 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 de caracteres. La macro ` Q_TYPEID() ` simplemente convierte la cadena en un ` QLatin1String`.
La clase « MultiPageWidgetExtensionFactory » es una subclase de « QExtensionFactory ». Cuando « Qt Widgets Designer » necesita saber si un widget es un contenedor o no, el gestor de extensiones de « Qt Widgets Designer » recorre todas sus fábricas registradas e invoca a la primera que sea capaz de crear una extensión de contenedor para ese widget. A su vez, esta fábrica creará 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, echa un vistazo a la función ` domXml() `. Esta función incluye la configuración predeterminada del 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 de varias páginas debe especificarse dentro de esta función.
Definición de la clase `MultiPageWidgetExtensionFactory`
La clase ` MultiPageWidgetExtensionFactory ` hereda de ` QExtensionFactory `, que proporciona una fábrica de extensiones 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 objetivo de la subclase es reimplementar la función ` QExtensionFactory::createExtension()`, de modo que sea 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)
{}Tal y como se ha descrito anteriormente, la fábrica se invoca cuando Qt Widgets Designer necesita 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 DesignerSu comportamiento es el mismo tanto 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í pues, 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 `. A continuación, comprobamos si la extensión solicitada es una extensión de contenedor.
Si el objeto es un `MultiPageWidget` que solicita una extensión de contenedor, creamos y devolvemos un objeto ` MultiPageWidgetExtension `. De lo contrario, simplemente devolvemos un puntero nulo, lo que permite que el gestor de extensiones de ` Qt Widgets Designer` continúe su búsqueda a través de las fábricas registradas.
Definición de la clase `MultiPageWidgetContainerExtension`
La clase ` MultiPageWidgetContainerExtension ` hereda de ` QDesignerContainerExtension `, lo que permite añadir (y eliminar) páginas a un complemento de 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 tener en cuenta que la clase ` QDesignerContainerExtension ` solo tiene por objeto proporcionar a ` Qt Widgets Designer ` acceso a la funcionalidad de tu widget multipágina personalizado; tu widget multipágina personalizado debe implementar la funcionalidad correspondiente a las funciones de la extensión.
Ten en cuenta 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 Por defecto, proporciona un par de entradas de menú en el menú de tareas de « Qt Widgets Designer », lo que permite al usuario añadir o eliminar páginas del 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. La necesitaremos más adelante para acceder al widget multipágina personalizado y realizar las acciones solicitadas.
MultiPageWidgetContainerExtension::MultiPageWidgetContainerExtension(MultiPageWidget *widget,
QObject *parent)
: QObject(parent)
, myWidget(widget)
{
}Para que Qt Widgets Designer pueda gestionar y manipular plenamente tu widget multipágina personalizado, debes 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();
}Debes reimplementar ` canAddWidget()` y ` addWidget()` añadiendo una página determinada al contenedor, ` count()` devolviendo el número de páginas del contenedor, y ` currentIndex()` devolviendo el índice de la página seleccionada actualmente.
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);
}Debes reimplementar insertWidget() para añadir una página determinada al contenedor en un índice determinado, canRemove() y remove() para eliminar la página en un índice determinado, setCurrentIndex() para establecer el índice de la página seleccionada actualmente y, por último, widget() para devolver la página en un índice determinado.
Definición de la clase MultiPageWidget
La clase `MultiPageWidget` es un widget contenedor personalizado que permite al usuario manipular y rellenar sus páginas, así como navegar entre ellas mediante un cuadro combinado.
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 detalle principal 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 solo está pensada para proporcionar acceso Qt Designer a la funcionalidad de tu widget multipágina personalizado.
Además, declaramos las propiedades ` currentIndex ` y ` pageTitle `, así como sus funciones «set» y «get» asociadas. Al declarar estos atributos como propiedades, permitimos que Qt Widgets Designer los gestione de la misma forma que gestiona las propiedades que el widget `MultiPageWidget` hereda de ` QWidget ` y ` QObject`, por ejemplo, mediante el editor de propiedades.
Fíjate en 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 recordarse al almacenar el estado de un objeto. Como se ha mencionado anteriormente, hemos optado por almacenar el título de la página utilizando la propiedad QWidget::windowTitle para poder asignar a cada página su propio título. Por ese motivo, la propiedad pageTitle es una propiedad «falsa», proporcionada con fines de edición, y no es necesario almacenarla.
También debemos implementar y emitir las señales currentIndexChanged() y pageTitleChanged() para garantizar que el editor de propiedades de Qt Widgets Designer se actualice cada vez que el usuario consulte otra página o modifique uno de los títulos de las páginas.
Consulta la implementación de la clase `MultiPageWidget` en ` containerextension/multipagewidget.cpp ` para obtener más detalles.
© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.