QQuickAttachedPropertyPropagator Class

Descripción detallada

En QML, es posible adjuntar propiedades y manejadores de señales a los objetos. Providing Attached Properties entra en más detalle sobre cómo exponer sus propios tipos adjuntos C++.

QQuickAttachedPropertyPropagator proporciona una API para propagar propiedades adjuntas desde un objeto padre a sus hijos, similar a la propagación de font y palette. Soporta la propagación a través de items, popups, y windows.

Si la propagación de propiedades no es importante, considere utilizar un singleton C++ o QML en su lugar, ya que es más adecuado para ese caso de uso, y es más eficiente en el sentido de que sólo requiere un QObject.

Para implementar una propiedad adjunta personalizada

1. Derive una clase que exponga la propiedad adjunta de QQuickAttachedPropertyPropagator.

   Por ejemplo, para implementar una propiedad adjunta MyStyle.theme, declare la clase MyStyle:

   class MYSTYLE_EXPORT MyStyle : public QQuickAttachedPropertyPropagator

2. Llame a initialize() en el constructor de su clase:

   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. Defina funciones set/inherit/propagate/reset para la propiedad adjunta según sea necesario. Por ejemplo, para definir una propiedad adjunta 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. Reimplemente attachedParentChange() para manejar la herencia de propiedades:

   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. Implemente una función estática qmlAttachedProperties y declare el tipo como un tipo QML adjunto con QML_ELEMENT y QML_ATTACHED, como se detalla en Proporcionar propiedades adjuntas:

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

La implementación completa está disponible en Qt Quick Controls - Attached Style Properties Example.