Defining QML Types from C++

[원문] https://doc.qt.io/qt-5/qtqml-cppintegration-definetypes.html

Defining QML Types from C++

C++ 코드로 QML을 확장하면 C++ 클래스를 QML 유형 시스템에 등록하여 클래스를 QML 코드 내에서 데이터 유형으로 사용할 수 있습니다. C++ 유형의 속성을 QML에 표시에서 설명한대로 QObject에서 파생 된 클래스 의 속성, 메소드 및 신호는 QML에서 액세스 할 수 있지만 QML의 데이터 유형으로 사용할 수는 없습니다. 또한 등록을 통해 클래스를 QML 의 인스턴스화 가능한 QML 객체 유형 으로 사용 하거나 클래스의 싱글 톤 인스턴스를 가져 와서 QML에서 사용하는 등의 다른 기능을 제공 할 수 있습니다 .

또한 Qt QML 모듈은 C++에서 첨부 된 속성 및 기본 속성 과 같은 QML 관련 기능을 구현하기위한 메커니즘을 제공합니다 .

(이 문서에서 다루는 중요한 개념 은 C++로 작성 QML 확장(영문) 자습서에 설명되어 있습니다.)

Registering C++ Types with the QML Type System

QObject를 유래 QML 클래스 코드 내에서 데이터 형식으로 사용되는 유형을 활성화 QML 형 시스템에 등록 할 수있다.

엔진을 사용하면 인스턴스화 할 수있는 유형과 인스턴스화 할 수없는 유형을 모두 등록 할 수 있습니다. 인스턴스화 가능한 유형을 등록하면 C++ 클래스를 QML 객체 유형의 정의로 사용할 수 있으므로 QML 코드의 객체 선언에이 유형의 객체를 생성 할 수 있습니다. 또한 등록은 엔진에 추가 유형 메타 데이터를 제공하여 유형 (및 클래스에서 선언 한 열거 형)을 QML과 C++간에 교환되는 등록 정보 값, 메소드 매개 변수 및 리턴 값 및 신호 매개 변수의 데이터 유형으로 사용할 수 있습니다.

인스턴스화 할 수없는 유형을 등록하면이 방식으로 클래스가 데이터 유형으로 등록되지만 유형을 QML의 QML 오브젝트 유형으로 인스턴스화 할 수 없습니다. 예를 들어 유형에 QML에 노출되어야하는 열거 형이 있지만 유형 자체를 인스턴스화해서는 안되는 경우에 유용합니다.

Registering an Instantiable Object Type

모든 QObject 기반 C++ 클래스는 QML 객체 유형 의 정의로 등록 될 수 있습니다 . 클래스가 QML 타입 시스템에 등록되면 클래스는 QML 코드의 다른 객체 유형처럼 선언되고 인스턴스화 될 수 있습니다. 생성 된 클래스 인스턴스는 QML에서 조작 할 수 있습니다. 로 QML가 C++ 형식의 속성 노출 설명을, 어떤의 속성, 방법 및 신호 QObject를 유도 된 클래스는 QML 코드에서 액세스 할 수 있습니다.

레지스터하기 QObject를 인스턴스 작성 QML 오브젝트 유형으로 유도 된 클래스를 호출 qmlRegisterType을 특정 유형의 네임 스페이스로 QML 유형으로 클래스를 등록 (). 그런 다음 클라이언트는 유형을 사용하기 위해 해당 네임 스페이스를 가져올 수 있습니다.

예를 들어, author 및 creationDate 속성이있는 Message 클래스가 있다고 가정합니다.

class Message : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QString author READ author WRITE setAuthor NOTIFY authorChanged)
    Q_PROPERTY(QDateTime creationDate READ creationDate WRITE setCreationDate NOTIFY creationDateChanged)
public:
    // ...
};

이 유형은 qmlRegisterType ()을 적절한 유형 이름 공간 및 버전 번호 로 호출하여 등록 할 수 있습니다 . 예를 들어 com.mycompany.messaging버전 1.0 의 네임 스페이스에서 유형을 사용하려면 다음을 수행하십시오 .

qmlRegisterType<Message>("com.mycompany.messaging", 1, 0, "Message");

이 유형은 QML 의 객체 선언에 사용할 수 있으며 아래 예와 같이 속성을 읽고 쓸 수 있습니다.

import com.mycompany.messaging 1.0

Message {
    author: "Amelie"
    creationDate: new Date()
}

Registering Non-Instantiable Types

때로는 QObject 기반 클래스가 QML 유형 시스템에 등록되어야 하지만 인스턴스화 가능 유형으로 등록되지 않아야 할 수도 있습니다. 예를 들어, C++ 클래스 인 경우 다음과 같습니다.

    > 인스턴스화 할 수없는 인터페이스 유형입니다.

    > QML에 노출 될 필요가없는 기본 클래스 유형입니다.

    > QML에서 액세스 할 수 있어야하는 일부 열거 형을 선언하지만 그렇지 않으면 인스턴스화 할 수 없습니다.

    > 싱글 톤 인스턴스를 통해 QML에 제공되어야하는 유형이며 QML에서 인스턴스화 할 수 없습니다.

Qt는 QML의 모듈은 비 인스턴스화 유형을 등록하는 몇 가지 방법을 제공합니다 :

    > qmlRegisterType() (매개 변수 없음)은 인스턴스화 할 수없고 QML에서 참조 할 수없는 C++ 유형을 등록합니다. 이를 통해 엔진은 QML에서 인스턴스화 할 수있는 상속 된 유형을 강제 변환 할 수 있습니다.

    > qmlRegisterInterface()는 Qt 인터페이스 유형을 특정 QML 유형 이름으로 등록합니다. 유형은 QML에서 인스턴스화 할 수 없지만 유형 이름으로 참조 할 수 있습니다.

    > qmlRegisterUncreatableType()은 인스턴스화 할 수 없지만 QML 유형 시스템의 유형으로 식별 할 수있는 명명 된 C++ 유형을 등록합니다. QML에서 형식의 열거 형 또는 연결된 속성에 액세스 할 수 있지만 유형 자체를 인스턴스화 할 수없는 경우 유용합니다.

    > qmlRegisterSingletonType()은 아래에 설명 된 것처럼 QML에서 가져올 수있는 싱글 톤 유형을 등록합니다.

QML 유형 시스템에 등록 된 모든 C++ 유형은 인스턴스화 할 수 없더라도 QObject에서 파생 되어야합니다 .

Registering Singleton Objects with a Singleton Type

싱글 톤 유형은 클라이언트가 객체 인스턴스를 수동으로 인스턴스화하지 않고도 네임 스페이스에서 속성, 신호 및 메서드를 노출 할 수있게합니다. QObject 싱글 톤 유형은 특히 기능 또는 전역 속성 값을 제공하는 효율적이고 편리한 방법입니다.

싱글 톤 유형은 엔진의 모든 컨텍스트에서 공유 되므로 연관된 QQmlContext 를 갖지 않습니다 . QObject를 싱글 형 인스턴스 구축과가 소유 QQmlEngine , 엔진이 파괴 될 때 파괴됩니다.

QObject를의 싱글 타입은 다른 유사한 방식으로 상호 작용 할 수 있는 QObject 인스턴스가 존재하는 것 하나 (엔진이 건설하고 소유)를 제외하고, 또는 인스턴스 유형, 그것은 형식 이름이 아닌 ID로 참조해야합니다. QObject 싱글 톤 유형의 Q_PROPERTY는 바인딩 될 수 있으며, QObject 모듈 API 의 Q_INVOKABLE 함수는 시그널 핸들러 표현식에서 사용될 수 있습니다. 이것은 싱글 톤 형식을 스타일링이나 테마 구현에 이상적인 방법으로 만들며 ".pragma library"스크립트 가져 오기 대신 전역 상태를 저장하거나 전역 기능을 제공하는 데 사용할 수도 있습니다.

일단 등록되면 QObject 싱글 톤 유형을 가져 와서 QML에 노출 된 다른 QObject 인스턴스 처럼 사용할 수 있습니다 . 다음 예제에서는 QObject 단독 유형이 "MyThemeModule"네임 스페이스에 1.0 버전으로 등록되어 있다고 가정합니다 . 여기서 QObject 는 QColor "color" Q_PROPERTY를가집니다 .

import MyThemeModule 1.0 as Theme

Rectangle {
    color: Theme.color // binding.
}

      

QJSValue는 또한 싱글 형식으로 노출 될 수 있지만 클라이언트는 싱글 타입의 속성에 바인딩 할 수 없음을 알고 있어야합니다.

새 싱글 톤 유형을 구현하고 등록하는 방법과 기존 싱글 톤 유형을 사용하는 방법에 대한 자세한 내용은 qmlRegisterSingletonType ()을 참조하십시오.

참고 : QML에 등록 된 유형의 열거 형 값은 대문자로 시작해야합니다.

Type Revisions and Versions

많은 유형의 등록 기능은 등록 된 유형에 대해 버전을 지정해야합니다. 유형 개정 및 버전을 사용하면 새 특성 또는 메소드가 이전 버전과 호환되도록 새 버전에 존재할 수 있습니다.

다음 두 가지 QML 파일을 고려하십시오.

// main.qml
import QtQuick 1.0

Item {
    id: root
    MyType {}
}

// MyType.qml
import MyTypes 1.0

CppType {
    value: root.x
}

여기서 CppType는 CppType C++ 클래스 에 매핑됩니다.

CppType의 저자가 추가하는 경우 root자신의 유형 정의의 새 버전에 CppType에 속성을 root.x하기 때문에 지금 다른 값으로 해석 root도있다 id최상위 구성 요소. 작성자는 새 root속성을 특정 부 버전에서 사용할 수 있음을 지정할 수 있습니다 . 이를 통해 기존 프로그램을 손상시키지 않고 기존 유형에 새로운 특성 및 기능을 추가 할 수 있습니다.

REVISION 태그는 root유형의 개정 1에 추가 된 것으로 특성 을 표시하는 데 사용됩니다 . Q_INVOKABLE , signals 및 slots 과 같은 메소드 는 Q_REVISION(x)매크로 를 사용하여 개정판에 태그를 지정할 수 있습니다 .

class CppType : public BaseType
{
    Q_OBJECT
    Q_PROPERTY(int root READ root WRITE setRoot NOTIFY rootChanged REVISION 1)

signals:
    Q_REVISION(1) void rootChanged();
};

특정 버전에 새 클래스 개정판을 등록하려면 다음 함수가 사용됩니다.

template<typename T, int metaObjectRevision>
int qmlRegisterType(const char *uri, int versionMajor, int versionMinor, const char *qmlName)

CppType버전 1 을 등록하려면 MyTypes 1.1:

qmlRegisterType<CppType,1>("MyTypes", 1, 1, "CppType")

rootMyTypes버전 1.1을 가져올 때만 사용할 수 있습니다.

같은 이유로 이후 버전에서 도입 된 새로운 유형은 qmlRegisterType의 부 버전 인수를 사용해야 합니다.

이 언어 기능을 사용하면 기존 응용 프로그램을 손상시키지 않고 동작 변경을 수행 할 수 있습니다. 따라서 QML 모듈 작성자는 마이너 버전간에 변경된 사항을 항상 기억해야하며, QML 모듈 사용자는 업데이트 된 import 문을 배포하기 전에 해당 응용 프로그램이 올바르게 실행되는지 확인해야합니다.

qmlRegisterRevision() 함수 를 사용하여 유형에 따라 달라지는 기본 클래스의 개정판을 등록 할 수도 있습니다 .

template<typename T, int metaObjectRevision>
int qmlRegisterRevision(const char *uri, int versionMajor, int versionMinor)

template<typename T, int metaObjectRevision>
int qmlRegisterUncreatableType(const char *uri, int versionMajor, int versionMinor, const char *qmlName, const QString& reason)

template<typename T, typename E, int metaObjectRevision>
int qmlRegisterExtendedUncreatableType(const char *uri, int versionMajor, int versionMinor, const char *qmlName, const QString& reason)

예를 들어, if BaseType가 변경되고 현재 리비전 1이있는 경우 유형에서 새 리비전을 사용하도록 지정할 수 있습니다.

qmlRegisterRevision<BaseType,1>("MyTypes", 1, 1);

Qt Quick 모듈에서 클래스를 확장하는 경우와 같이 다른 작성자가 제공 한 기본 클래스에서 파생되는 경우 유용합니다.

Registering Extension Objects

기존 클래스와 기술을 QML에 통합 할 때 API는 종종 선언적 환경에 맞게 조정해야합니다. 최상의 결과는 대개 원래 클래스를 직접 수정하여 얻어 지지만, 이것이 가능하지 않거나 다른 문제로 인해 복잡해지면 확장 객체는 직접 수정하지 않고 제한된 확장 가능성을 허용합니다.

확장 개체 는 기존 유형에 추가 속성을 추가합니다. 확장 객체는 신호 또는 메서드가 아닌 속성 만 추가 할 수 있습니다. 확장 타입 정의는 프로그래머가 알려진 추가적인 유형 공급할 수 있도록 확장 타입 클래스를 등록 할 때. 속성은 QML 내에서 사용될 때 원래 대상 클래스와 투명하게 병합됩니다. 예 :

QLineEdit {
    leftMargin: 20
}

     

이 leftMargin속성은 소스 코드를 수정하지 않고 기존 C++ 유형 인 QLineEdit 에 추가 된 새 속성 입니다.

qmlRegisterExtendedType () 함수는 확장 타입을 등록하기위한 것이다. 여기에는 두 가지 형식이 있습니다.

template<typename T, typename ExtendedT>
int qmlRegisterExtendedType(const char *uri, int versionMajor, int versionMinor, const char *qmlName)

template<typename T, typename ExtendedT>
int qmlRegisterExtendedType()

이 함수는 일반 qmlRegisterType()변형 대신 사용되어야합니다 . 인수는 확장 오브젝트의 유형 인 ExtendedT 매개 변수를 제외하고는 해당 비 확장 등록 기능과 동일합니다.

확장 클래스는 QObject 포인터 를 사용하는 생성자 가있는 일반 QObject 입니다. 그러나 확장 클래스 생성은 첫 번째 확장 속성에 액세스 할 때까지 지연됩니다. 확장 클래스가 작성되고 대상 오브젝트가 상위로 전달됩니다. 원본의 속성에 액세스 할 때 확장 객체의 해당 속성이 대신 사용됩니다.

확장 개체 예제 에서는 확장 개체 의 사용법을 보여줍니다.

Defining QML-Specific Types and Attributes

Providing Attached Objects for Data Annotations

QML 언어 구문에는 첨부 된 속성 및 첨부 된 신호 처리기 라는 개념 이 있는데, 이는 객체에 추가 된 속성입니다. 본질적으로 그러한 속성은 부착 유형 에 의해 구현되고 제공되며 이러한 속성은 다른 유형의 객체에 첨부 될 수 있습니다 . 이것은 오브젝트 유형 자체 (또는 오브젝트의 상속 유형)가 제공하는 일반 오브젝트 특성과 대조됩니다.

예를 들어 아래 Item 은 연결된 속성과 연결된 핸들러를 사용합니다.

import QtQuick 2.0

Item {
    width: 100; height: 100

    focus: true
    Keys.enabled: false
    Keys.onReturnPressed: console.log("Return key was pressed")
}

여기에서 항목 개체에 액세스하고의 값을 설정 할 수 있습니다 Keys.enabled와 Keys.onReturnPressed. 이렇게하면 Item 객체가 기존 속성에 대한 확장으로 이러한 추가 속성에 액세스 할 수 있습니다.

Steps for Implementing Attached Objects

위의 예를 고려할 때 여러 당사자가 참여합니다.

    > Item 객체에 연결되어 이러한 속성에 액세스하고 설정할 수 있도록 설정된 enabled 및 returnPressed 신호와 함께 익명 첨부 객체 유형의 인스턴스가 있습니다.

    > Item 객체는 연결된 객체 유형의 인스턴스가 첨부 된 Attachee입니다.

    > Keys는 첨부 유형이며, 첨부 된 객체 유형의 속성에 액세스 할 수있는 명명 된 한정자 인 "키"가 부착되어 있습니다.

QML 엔진은이 코드를 처리 할 때 첨부 된 객체 유형 의 단일 인스턴스를 생성 하고이 인스턴스를 Item 객체 에 연결하여 인스턴스의 속성 enabled및 returnPressed속성에 대한 액세스를 제공합니다 .

첨부 된 개체를 제공하기위한 메커니즘은 클래스를 제공함으로써 C++로 구현 될 수있다 부착 오브젝트 유형 과 형태를 첨부 . 를 들어 첨부 된 개체 유형 하는 제공 QObject를 속성 정보는 다음의 제품에 접근 할을 정의 유도 된 클래스 attachee 객체. 를 들어 부착 형 하는 제공 QObject를 그 유래 클래스를 :

    > 다음 서명을 사용하여 정적 qmlAttachedProperties()를 구현합니다.

static <AttachedPropertiesType> *qmlAttachedProperties(QObject *object);

이 메서드는 연결된 개체 형식 의 인스턴스를 반환해야 합니다 .

QML 엔진은 첨부 된 객체 유형의 인스턴스를 매개 변수로 지정된 attachee에 첨부하기 위해이 메소드를 호출 object합니다. 엄격하게 요구되는 것은 아니지만, object메모리 누출을 막기 위해 반환 된 인스턴스를 부모로 지정하는 것이이 메서드 구현에 일반적 입니다.

이 메소드는 엔진이 이후에 연결된 속성 액세스를 위해 반환 된 인스턴스 포인터를 캐시하므로 각 attachee 객체 인스턴스에 대해 엔진에서 최대 한 번만 호출됩니다. 결과적으로 첨부 객체는 attachee object가 삭제 될 때까지 삭제되지 않을 수 있습니다 .

QML_HAS_ATTACHED_PROPERTIES 플래그와 함께 QML_DECLARE_TYPEINFO () 매크로 를 호출하여 첨부 유형으로 선언됩니다.

Implementing Attached Objects: An Example

예를 들어 앞의 예제Message 에서 설명한 유형을 사용하십시오 .

class Message : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QString author READ author WRITE setAuthor NOTIFY authorChanged)
    Q_PROPERTY(QDateTime creationDate READ creationDate WRITE setCreationDate NOTIFY creationDateChanged)
public:
    // ...
};

Message메시지 게시판에 게시 될 때 신호를 트리거 해야하며 메시지 게시판에서 메시지가 만료 된 시점을 추적 한다고 가정합니다 . 이러한 속성을 a Message에 직접 추가하는 것은 의미가 없기 때문에 속성이 메시지 보드 컨텍스트와 더 관련이 있으므로 "MessageBoard"한정자를 통해 제공되는 객체 에 첨부 된 속성으로 구현할 수 있습니다 Message. 앞에서 설명한 개념과 관련하여 여기에 참여한 당사자는 다음과 같습니다.

    > 게시된 신호와 만료된 속성을 제공하는 익명 첨부 객체 유형의 인스턴스입니다. 이 유형은 아래의 MessageBoardAttachedType에 의해 구현됩니다.

    > Message 객체는 attachee 될 것이다.

    > 첨부된 속성에 엑세스하기 위해 Message객체가 사용하는 첨부 유형이 될 MessageBoard 유형입니다.

다음은 구현 예입니다. 먼저, attachee에 액세서 할 수 있는 필수 특성 및 신호가 있는 첨부된 오브젝트 유형이 있어야 합니다.

class MessageBoardAttachedType : public QObject
{
    Q_OBJECT
    Q_PROPERTY(bool expired READ expired WRITE expired NOTIFY expiredChanged)
public:
    MessageBoardAttachedType(QObject *parent);
    bool expired() const;
    void setExpired(bool expired);
signals:
    void published();
    void expiredChanged();
};

그 후 부착 타입 , MessageBoard하는 선언해야 qmlAttachedProperties()의 인스턴스를 반환 방법 부착 개체 유형 MessageBoardAttachedType에서 구현한다. 또한 Message보드는 QML_DECLARE_TYPEINFO () 매크로 를 통해 첨부 된 유형으로 선언되어야합니다 .

class MessageBoard : public QObject
{
    Q_OBJECT
public:
    static MessageBoard *qmlAttachedProperties(QObject *object)
    {
        return new MessageBoardAttachedType(object);
    }
};
QML_DECLARE_TYPEINFO(MessageBoard, QML_HAS_ATTACHED_PROPERTIES)

이제 Message유형은 첨부 된 객체 유형의 특성 및 신호에 액세스 할 수 있습니다.

Message {
    author: "Amelie"
    creationDate: new Date()

    MessageBoard.expired: creationDate < new Date("January 01, 2015 10:45:00")
    MessageBoard.onPublished: console.log("Message by", author, "has been
published!")
}

또한 C++ 구현은 qmlAttachedPropertiesObject () 함수 를 호출하여 개체에 연결된 첨부 된 개체 인스턴스에 액세스 할 수 있습니다 .

예 :

Message *msg = someMessageInstance();
MessageBoardAttachedType *attached =
        qobject_cast<MessageBoardAttachedType*>(qmlAttachedPropertiesObject<MessageBoard>(msg));

qDebug() << "Value of MessageBoard.expired:" << attached->expired();

Property Modifier Types

속성 수정 자 유형은 특수한 종류의 QML 객체 유형입니다. 속성 수정 자 유형 인스턴스는 적용되는 QML 객체 인스턴스의 속성에 영향을줍니다. 속성 수정 자 유형에는 두 가지 종류가 있습니다.

    > property value write interceptors

    > property value sources

속성 값 쓰기 인터셉터는 속성에 쓰여지는 값을 필터링하거나 수정하는 데 사용할 수 있습니다. 현재 지원되는 속성 값 쓰기 인터셉터는 가져 오기에서 제공 하는 동작 유형 뿐입니다 QtQuick.

속성 값 소스를 사용하여 시간 경과에 따라 속성 값을 자동으로 업데이트 할 수 있습니다. 클라이언트는 고유 한 특성 값 소스 유형을 정의 할 수 있습니다. 가져 오기에서 제공 하는 다양한 속성 애니메이션 유형 QtQuick은 속성 값 소스의 예입니다.

속성 수정 자 유형 인스턴스는 다음 예제와 같이 "<ModifierType> on <propertyName>"구문을 통해 QML 객체의 속성에 만들어져 적용될 수 있습니다.

import QtQuick 2.0

Item {
    width: 400
    height: 50

    Rectangle {
        width: 50
        height: 50
        color: "red"

        NumberAnimation on x {
            from: 0
            to: 350
            loops: Animation.Infinite
            duration: 2000
        }
    }
}

클라이언트는 자신의 속성 값 소스 유형을 등록 할 수 있지만 현재 속성 값은 인터셉터를 작성하지 않습니다.

Property Value Sources

속성 값 소스 는 <PropertyValueSource> on <property>구문을 사용하여 시간 경과에 따라 속성 값을 자동으로 업데이트 할 수있는 QML 유형입니다 . 예를 들어 모듈에서 제공 하는 다양한 속성 애니메이션 유형 QtQuick이 속성 값 소스의 예입니다.

속성 값 소스는 QQmlPropertyValueSource를 하위 클래스 화 하고 시간 경과에 따라 속성에 다른 값을 쓰는 구현을 제공 함으로써 C++로 구현 될 수 있습니다 . 속성 값 소스가 <PropertyValueSource> on <property>QML 의 구문을 사용하여 속성에 적용 되면 속성 값을 업데이트 할 수 있도록 엔진에서이 속성에 대한 참조가 제공됩니다.

예를 들어, RandomNumberGeneratorQML 속성에 적용될 때 500 밀리 초마다 속성 값을 다른 임의의 숫자로 업데이트 할 수 있도록 속성 값 소스로 사용할 수 있는 클래스 가 있다고 가정 합니다. 또한,이 난수 생성기에 maxValue를 제공 ​​할 수 있습니다. 이 클래스는 다음과 같이 구현할 수 있습니다.

class RandomNumberGenerator : public QObject, public QQmlPropertyValueSource
{
    Q_OBJECT
    Q_INTERFACES(QQmlPropertyValueSource)
    Q_PROPERTY(int maxValue READ maxValue WRITE setMaxValue NOTIFY maxValueChanged);
public:
    RandomNumberGenerator(QObject *parent)
        : QObject(parent), m_maxValue(100)
    {
        qsrand(QDateTime::currentMSecsSinceEpoch() / 1000);
        QObject::connect(&m_timer, SIGNAL(timeout()), SLOT(updateProperty()));
        m_timer.start(500);
    }

    int maxValue() const;
    void setMaxValue(int maxValue);

    virtual void setTarget(const QQmlProperty &prop) { m_targetProperty = prop; }

signals:
    void maxValueChanged();

private slots:
    void updateProperty() {
        m_targetProperty.write(qrand() % m_maxValue);
    }

private:
    QQmlProperty m_targetProperty;
    QTimer m_timer;
    int m_maxValue;
};

QML 엔진 RandomNumberGenerator이 속성 값 소스 RandomNumberGenerator::setTarget()로 사용될 때 값 소스가 적용된 속성을 유형에 제공하기 위해 호출 합니다. 내부 타이머가 RandomNumberGenerator500 밀리 초마다 트리거되면 지정된 수의 속성에 새로운 숫자 값이 기록됩니다.

일단 RandomNumberGenerator등급이 QML 형 시스템에 등록되어,이를 속성 값 소스로 QML에서 사용될 수있다. 아래에서는 500 밀리 초 마다 Rectangle 의 너비를 변경하는 데 사용됩니다 .

import QtQuick 2.0

Item {
    width: 300; height: 300

    Rectangle {
        RandomNumberGenerator on width { maxValue: 300 }

        height: 100
        color: "red"
    }
}

다른 모든 측면에서 속성 값 소스는 속성을 가질 수 있고 메서드를 신호 할 수있는 일반 QML 유형이지만 <PropertyValueSource> on <property>구문을 사용하여 속성 값을 변경하는 데 사용할 수있는 추가 기능이 있습니다 .

속성 값 소스 객체가 속성에 할당되면 QML은 일반 QML 유형 인 것처럼 정상적으로 할당하려고 시도합니다. 이 할당이 실패한 경우에만 엔진은 setTarget () 메서드를 호출합니다 . 이것에 의해, 형식을 값의 소스 이외의 문맥에서도 사용할 수 있습니다.

Specifying Default Properties for QML Object Types

인스턴스화 가능한 QML 객체 유형 으로 등록 된 모든 QObject에서 파생 된 유형은 유형에 대한 기본 속성 을 선택적으로 지정할 수 있습니다 . 기본 속성은 개체의 자식이 특정 속성에 할당되지 않은 경우 자동으로 할당되는 속성입니다.

기본 속성은 특정 "DefaultProperty"값을 가진 클래스에 대해 Q_CLASSINFO () 매크로를 호출하여 설정할 수 있습니다 . 예를 들어 MessageBoard아래 클래스는 messages속성을 클래스의 기본 속성으로 지정합니다.

class MessageBoard : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QQmlListProperty<Message> messages READ messages)
    Q_CLASSINFO("DefaultProperty", "messages")
public:
    QQmlListProperty<Message> messages();

private:
    QList<Message *> messages;
};

이렇게하면 MessageBoard개체의 자식이 messages특정 속성에 할당되지 않은 경우 개체의 속성에 자동으로 할당 할 수 있습니다 . 예 :

MessageBoard {
    Message { author: "Naomi" }
    Message { author: "Clancy" }
}

messages기본 속성으로 설정되지 않은 경우 다음과 같이 Message개체 를 명시 적으로 속성에 할당해야 messages합니다.

MessageBoard {
    messages: [
        Message { author: "Naomi" },
        Message { author: "Clancy" }
    ]
}

(덧붙여, Item :: data 속성은 기본 속성입니다. 이 속성에 추가 된 Item 객체 data도 Item :: children 목록에 추가 되므로 기본 속성을 사용하면 시각적 자식을 항목에 대해 선언 할 수 있습니다. 명시 적으로 그것들을 children 속성에 할당합니다 .)

Defining Visual Items with the Qt Quick Module

Qt Quick 모듈로 사용자 인터페이스를 구축 할 때 시각적으로 렌더링되어야하는 모든 QML 객체는 Qt Quick의 모든 시각적 객체에 대한 기본 유형이므로 항목 유형 에서 파생되어야합니다 . 이 항목 유형은 Qt Quick 모듈 에서 제공 하는 QQuickItem C++ 클래스에 의해 구현됩니다 . 따라서이 클래스는 QML 기반 사용자 인터페이스에 통합 될 수있는 C++의 시각적 유형을 구현해야 할 때 하위 클래스로 만들어야합니다.

자세한 정보는 QQuickItem 문서를 참조하십시오. 또한 Q ++ Extension with C++ 자습서는 QQuickItem 기반 시각 자료를 C++로 구현하고 Qt Quick 기반 사용자 인터페이스에 통합하는 방법을 보여줍니다.

Receiving Notifications for Object Initialization

일부 사용자 정의 QML 객체 유형의 경우 객체가 생성되고 모든 속성이 설정 될 때까지 특정 데이터의 초기화를 지연하는 것이 좋습니다. 예를 들어, 초기화가 비용이 많이 들거나 모든 속성 값이 초기화 될 때까지 초기화를 수행하지 않아야하는 경우입니다.

Qt QML 모듈은 이러한 용도로 서브 클래스화할 QQmlParserStatus를 제공합니다. 구성 요소 인스턴스화 중에 다양한 단계에서 호출되는 많은 가상 메소드를 정의합니다. 이러한 통지를 수신하기 위해 C ++ 클래스는 QQmlParserStatus를 상속해야하며 Q_INTERFACES() 매크로를 사용하여 Qt 메타 시스템에 통지해야합니다.

예 :

class MyQmlType : public QObject, public QQmlParserStatus
{
    Q_OBJECT
    Q_INTERFACES(QQmlParserStatus)
public:
    virtual void componentComplete()
    {
        // Perform some initialization here now that the object is fully created
    }
};