Sur cette page

QDesignerCustomWidgetInterface Class

La classe QDesignerCustomWidgetInterface permet à Qt Widgets Designer d'accéder à des widgets personnalisés et de les construire. Plus d'informations...

En-tête : #include <QDesignerCustomWidgetInterface>
CMake : find_package(Qt6 REQUIRED COMPONENTS Designer)
target_link_libraries(mytarget PRIVATE Qt6::Designer)
qmake : QT += designer

Fonctions publiques

virtual ~QDesignerCustomWidgetInterface()
virtual QString codeTemplate() const
virtual QWidget *createWidget(QWidget *parent) = 0
virtual QString domXml() const
virtual QString group() const = 0
virtual QIcon icon() const = 0
virtual QString includeFile() const = 0
virtual void initialize(QDesignerFormEditorInterface *formEditor)
virtual bool isContainer() const = 0
virtual bool isInitialized() const
virtual QString name() const = 0
virtual QString toolTip() const = 0
virtual QString whatsThis() const = 0

Macros

Description détaillée

QDesignerCustomWidgetInterface fournit une interface pour un widget personnalisé. La classe contient un ensemble de fonctions qui doivent être sous-classées pour renvoyer des informations de base sur le widget, telles que le nom de sa classe et le nom de son fichier d'en-tête. D'autres fonctions doivent être mises en œuvre pour initialiser le plugin lorsqu'il est chargé et pour construire des instances du widget personnalisé à utiliser par Qt Widgets Designer.

Lorsque vous mettez en œuvre un widget personnalisé, vous devez sous-classer QDesignerCustomWidgetInterface pour exposer votre widget à Qt Widgets Designer. Par exemple, voici la déclaration du plugin utilisé dans l'exemple du plugin de widget personnalisé qui permet à un widget personnalisé d'horloge analogique d'être utilisé par Qt Widgets Designer:

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

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

private:
    bool initialized = false;
};

Notez que la seule partie de la définition de la classe qui est spécifique à ce widget personnalisé particulier est le nom de la classe. De plus, comme nous implémentons une interface, nous devons nous assurer qu'elle est connue du système de métaobjets à l'aide de la macro Q_INTERFACES(). Cela permet à Qt Widgets Designer d'utiliser la fonction qobject_cast() pour rechercher les interfaces prises en charge en n'utilisant rien d'autre qu'un pointeur QObject.

Une fois que Qt Widgets Designer a chargé un plugin de widget personnalisé, il appelle la fonction initialize() de l'interface pour lui permettre de mettre en place toutes les ressources dont il peut avoir besoin. Cette fonction est appelée avec un paramètre QDesignerFormEditorInterface qui fournit au plugin une passerelle vers l'ensemble de l'API de Qt Widgets Designer.

Qt Widgets Designer construit des instances du widget personnalisé en appelant la fonction createWidget() du plugin avec un widget parent approprié. Les plugins doivent construire et renvoyer une instance de widget personnalisé avec le widget parent spécifié.

Exporter votre plugin de widget personnalisé vers Qt Widgets Designer à l'aide de la macro Q_PLUGIN_METADATA(). Par exemple, si une bibliothèque appelée libcustomwidgetplugin.so (sous Unix) ou libcustomwidget.dll (sous Windows) contient une classe de widget appelée MyCustomWidget, nous pouvons l'exporter en ajoutant la ligne suivante au fichier contenant l'en-tête du plugin :

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

Cette macro garantit que Qt Widgets Designer peut accéder au widget personnalisé et le construire. Sans cette macro, Qt Widgets Designer ne peut pas l'utiliser.

Lorsque vous mettez en œuvre un plugin de widget personnalisé, vous le construisez comme une bibliothèque distincte. Si vous souhaitez inclure plusieurs plugins de widgets personnalisés dans la même bibliothèque, vous devez en outre sous-classer QDesignerCustomWidgetCollectionInterface.

Attention : Si votre plugin de widget personnalisé contient des propriétés QVariant, sachez que seules les propriétés types suivantes sont prises en charge :

  • QVariant::ByteArray
  • QVariant::Bool
  • QVariant::Color
  • QVariant::Cursor
  • QVariant::Date
  • QVariant::DateTime
  • QVariant::Double
  • QVariant::Int
  • QVariant::Point
  • QVariant::Rect
  • QVariant::Size
  • QVariant::SizePolicy
  • QVariant::String
  • QVariant::Time
  • QVariant::UInt

Pour un exemple complet utilisant la classe QDesignerCustomWidgetInterface, voir l'exemple de widget personnalisé. L'exemple montre comment créer un plugin de widget personnalisé pour Qt Widgets Designer.

Voir également QDesignerCustomWidgetCollectionInterface et Créer des widgets personnalisés pour Qt Widgets Designer.

Documentation des fonctions membres

[virtual constexpr noexcept] QDesignerCustomWidgetInterface::~QDesignerCustomWidgetInterface()

Détruit l'interface du widget personnalisé.

[virtual] QString QDesignerCustomWidgetInterface::codeTemplate() const

Cette fonction est réservée pour une utilisation future par Qt Widgets Designer.

[pure virtual] QWidget *QDesignerCustomWidgetInterface::createWidget(QWidget *parent)

Renvoie une nouvelle instance du widget personnalisé, avec la valeur parent.

[virtual] QString QDesignerCustomWidgetInterface::domXml() const

Renvoie le XML utilisé pour décrire les propriétés du widget personnalisé à Qt Widgets Designer.

[pure virtual] QString QDesignerCustomWidgetInterface::group() const

Renvoie le nom du groupe auquel appartient le widget personnalisé.

[pure virtual] QIcon QDesignerCustomWidgetInterface::icon() const

Renvoie l'icône utilisée pour représenter le widget personnalisé dans la boîte à widgets de Qt Widgets Designer.

[pure virtual] QString QDesignerCustomWidgetInterface::includeFile() const

Renvoie le chemin d'accès au fichier d'inclusion que l 'uic utilise lors de la création du code pour le widget personnalisé.

[virtual] void QDesignerCustomWidgetInterface::initialize(QDesignerFormEditorInterface *formEditor)

Initialise le widget pour l'utiliser avec l'interface formEditor spécifiée.

Voir aussi isInitialized().

[pure virtual] bool QDesignerCustomWidgetInterface::isContainer() const

Retourne true si le widget personnalisé est destiné à être utilisé comme conteneur ; sinon, retourne false.

La plupart des widgets personnalisés ne sont pas utilisés pour contenir d'autres widgets, de sorte que leurs implémentations de cette fonction renverront false, mais les conteneurs personnalisés renverront true pour s'assurer qu'ils se comportent correctement dans Qt Widgets Designer.

[virtual] bool QDesignerCustomWidgetInterface::isInitialized() const

Retourne true si le widget a été initialisé, sinon retourne false.

Voir aussi initialize().

[pure virtual] QString QDesignerCustomWidgetInterface::name() const

Renvoie le nom de classe du widget personnalisé fourni par l'interface.

Le nom renvoyé doit être identique au nom de classe utilisé pour le widget personnalisé.

[pure virtual] QString QDesignerCustomWidgetInterface::toolTip() const

Renvoie une brève description du widget qui peut être utilisée par Qt Widgets Designer dans une info-bulle.

[pure virtual] QString QDesignerCustomWidgetInterface::whatsThis() const

Renvoie une description du widget qui peut être utilisée par Qt Widgets Designer dans l'aide "What's This ?" pour le widget.

Documentation sur les macros

QDESIGNER_WIDGET_EXPORT

Cette macro est utilisée lors de la définition de widgets personnalisés afin de s'assurer qu'ils sont correctement exportés des plugins pour être utilisés avec Qt Widgets Designer.

Sur certaines plateformes, les symboles requis par Qt Widgets Designer pour créer de nouveaux widgets sont supprimés des plugins par le système de construction, ce qui les rend inutilisables. L'utilisation de cette macro garantit que les symboles sont conservés sur ces plates-formes et n'a aucun effet secondaire sur les autres plates-formes.

Par exemple, l'exemple Custom Widget Plugin exporte une classe de widget personnalisée avec la déclaration suivante :

class QDESIGNER_WIDGET_EXPORT AnalogClock : public QWidget
{
    Q_OBJECT
    ...
};

Voir aussi Création de widgets personnalisés à l'adresse Qt Widgets Designer.

© 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.