QQuickAttachedPropertyPropagator Class

Detaillierte Beschreibung

In QML ist es möglich, Eigenschaften und Signalhandler an Objekte anzuhängen. Providing Attached Properties geht näher darauf ein, wie Sie Ihre eigenen angehängten C++-Typen bereitstellen können.

QQuickAttachedPropertyPropagator bietet eine API zur Weitergabe von angehängten Eigenschaften von einem übergeordneten Objekt an seine Kinder, ähnlich wie font und palette. Es unterstützt die Weitergabe durch items, popups und windows.

Wenn die Weitergabe von Eigenschaften nicht wichtig ist, sollten Sie stattdessen ein C++ oder ein QML-Singleton verwenden, da es für diesen Anwendungsfall besser geeignet ist und effizienter ist, da es nur ein QObject benötigt.

So implementieren Sie eine benutzerdefinierte angehängte Eigenschaft:

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

   Um zum Beispiel eine angehängte Eigenschaft MyStyle.theme 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 je nach Bedarf Set/Inherit/Propagate/Reset-Funktionen für die angehängte Eigenschaft. Zum Beispiel, um eine theme angehängte Eigenschaft 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. Reimplementieren Sie attachedParentChange(), um die Eigenschaftsvererbung zu behandeln:

   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 in Bereitstellen von angehängten Eigenschaften beschrieben:

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

Die vollständige Implementierung ist in Qt Quick Controls - Attached Style Properties Example verfügbar.