QQuickAttachedPropertyPropagator Class

Description détaillée

En QML, il est possible d'attacher des propriétés et des gestionnaires de signaux aux objets. Fournir des propriétés attachées explique en détail comment exposer vos propres types attachés en C++.

QQuickAttachedPropertyPropagator fournit une API pour propager les propriétés attachées d'un objet parent à ses enfants, de manière similaire à 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, il est préférable d'utiliser un singleton C++ ou QML, qui est mieux adapté à ce cas d'utilisation et plus efficace car il ne nécessite qu'une seule adresse QObject.

Pour mettre en œuvre une propriété attachée personnalisée :

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

   Par exemple, pour mettre en œuvre une propriété attachée 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 des fonctions set/inherit/propagate/reset pour la propriété attachée si nécessaire. Par exemple, pour définir une propriété attachée 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 attachedParentChange() pour gérer l'héritage des propriétés :

   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émenter une fonction statique qmlAttachedProperties et déclarer le type comme un type QML attaché avec QML_ELEMENT et QML_ATTACHED, comme détaillé dans Fournir des propriétés attachées:

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

L'implémentation complète est disponible sur Qt Quick Controls - Attached Style Properties Example.