QQuickAttachedPropertyPropagator Class

Description détaillée

En QML, il est possible d'associer des propriétés et des gestionnaires de signaux à des objets. La section « Fournir des propriétés associées » explique plus en détail comment exposer vos propres types associés en C++.

QQuickAttachedPropertyPropagator fournit une API permettant de propager les propriétés associées d’un objet parent vers ses enfants, à l’instar de la propagation des objets « font » et « palette ». Il prend en charge la propagation via « items », « popups » et « windows ».

Si la propagation des propriétés n’est pas importante, envisagez plutôt d’utiliser un singleton C++ ou QML, car il est mieux adapté à ce cas d’utilisation et plus efficace dans la mesure où il ne nécessite qu’une seule QObject.

Pour implémenter une propriété attachée personnalisée :

1. Dérivez une classe qui expose la propriété attachée à partir de `QQuickAttachedPropertyPropagator`.

   Par exemple, pour implémenter une propriété attachée de type « MyStyle.theme », déclarez la classe ` MyStyle ` :

   class MYSTYLE_EXPORT MyStyle : public QQuickAttachedPropertyPropagator

2. Appelez ` initialize()` dans le constructeur de votre classe :

   MyStyle::MyStyle(QObject *parent)
       : QQuickAttachedPropertyPropagator(parent)
       , m_theme(globalTheme)
   {
       // A static function could be called here that reads globalTheme from a
       // settings file once at startup. That value would override the global
       // value. This is similar to what the Imagine and Material styles do, for
       // example.
   
       initialize();
   }

3. Définissez les fonctions set, inherit, propagate et reset pour la propriété attachée selon vos besoins. Par exemple, pour définir une propriété attachée de type « theme » :

   MyStyle::Theme MyStyle::theme() const
   {
       return m_theme;
   }
   
   void MyStyle::setTheme(Theme theme)
   {
       // When this function is called, we know that the user has explicitly
       // set a theme on this attached object. We set this to true even if
       // the effective theme didn't change, because it's important that
       // the user's specified value is respected (and not inherited from
       // from the parent).
       m_explicitTheme = true;
       if (m_theme == theme)
           return;
   
       m_theme = theme;
       propagateTheme();
       themeChange();
   
   }
   
   void MyStyle::inheritTheme(Theme theme)
   {
       if (m_explicitTheme || m_theme == theme)
           return;
   
       m_theme = theme;
       propagateTheme();
       themeChange();
   }
   
   void MyStyle::propagateTheme()
   {
       const auto styles = attachedChildren();
       for (QQuickAttachedPropertyPropagator *child : styles) {
           MyStyle *myStyle = qobject_cast<MyStyle *>(child);
           if (myStyle)
               myStyle->inheritTheme(m_theme);
       }
   }
   
   void MyStyle::resetTheme()
   {
       if (!m_explicitTheme)
           return;
   
       m_explicitTheme = false;
       MyStyle *myStyle = qobject_cast<MyStyle *>(attachedParent());
       inheritTheme(myStyle ? myStyle->theme() : globalTheme);
   }

4. Réimplémentez la méthode ` attachedParentChange()` pour gérer l'héritage de la propriété :

   void MyStyle::attachedParentChange(QQuickAttachedPropertyPropagator *newParent, QQuickAttachedPropertyPropagator *oldParent)
   {
       Q_UNUSED(oldParent);
       MyStyle *attachedParentStyle = qobject_cast<MyStyle *>(newParent);
       if (attachedParentStyle) {
           inheritTheme(attachedParentStyle->theme());
           // Do any other inheriting here...
       }
   }

5. Implémentez une fonction statique ` qmlAttachedProperties ` et déclarez le type en tant que type QML attaché à l'aide de ` QML_ELEMENT ` et ` QML_ATTACHED`, comme détaillé dans la section « Fournir des propriétés attachées » :

   MyStyle *MyStyle::qmlAttachedProperties(QObject *object)
   {
       return new MyStyle(object);
   }

L'implémentation complète est disponible dans Qt Quick Controls - Exemple de propriétés de style associées.