QQuickAttachedPropertyPropagator Class

Ausführliche Beschreibung

In QML ist es möglich, Eigenschaften und Signal-Handler an Objekte anzuhängen. Der Abschnitt „Bereitstellung von angehängten Eigenschaften“ geht näher darauf ein, wie Sie Ihre eigenen C++-Typen mit angehängten Eigenschaften verfügbar machen können.

„QQuickAttachedPropertyPropagator“ stellt eine API bereit, um zugeordnete Eigenschaften von einem übergeordneten Objekt an dessen untergeordnete Objekte weiterzugeben, ähnlich wie bei der Weitergabe von „ font “ und „ palette “. Es unterstützt die Weitergabe über „ items “, „ popups “ und „ windows “.

Wenn die Weitergabe von Eigenschaften nicht wichtig ist, sollten Sie stattdessen die Verwendung eines C++- oder QML-Singletons in Betracht ziehen, da dieses für diesen Anwendungsfall besser geeignet und effizienter ist, da es nur ein einziges ` QObject` erfordert.

So implementieren Sie eine benutzerdefinierte angehängte Eigenschaft:

1. Leiten Sie eine Klasse, die die angehängte Eigenschaft bereitstellt, von `QQuickAttachedPropertyPropagator` ab.

   Um beispielsweise eine angehängte „ MyStyle.theme “-Eigenschaft zu implementieren, deklarieren Sie die Klasse „ MyStyle “:

   class MYSTYLE_EXPORT MyStyle : public QQuickAttachedPropertyPropagator

2. Rufen Sie ` initialize()` im Konstruktor Ihrer Klasse auf:

   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. Definieren Sie nach Bedarf Set-, Inherit-, Propagate- und Reset-Funktionen für die angehängte Eigenschaft. Um beispielsweise eine angehängte Eigenschaft „ theme “ zu definieren:

   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. Implementieren Sie ` attachedParentChange()` neu, um die Vererbung der Eigenschaft zu handhaben:

   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. Implementieren Sie eine statische Funktion ` qmlAttachedProperties ` und deklarieren Sie den Typ als angehängten QML-Typ mit ` QML_ELEMENT ` und ` QML_ATTACHED`, wie unter „Bereitstellen von angehängten Eigenschaften“ beschrieben:

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

Die vollständige Implementierung finden Sie unter „Qt Quick Controls – Beispiel für angehängte Stileigenschaften“.