<qqmlintegration.h> - Registering C++ types to QML

매크로 문서

QML_ADDED_IN_VERSION(MAJOR, MINOR)

둘러싸는 타입 또는 네임스페이스가 지정된 MAJOR.MINOR 버전에 추가되었음을 선언합니다. 이 버전은 메서드, 슬롯 또는 신호에 대한 Q_REVISION() 매크로와 Q_PROPERTY()로 선언된 속성에 대한 REVISION() 속성에 의해 주어진 모든 개정판과 일치하는 것으로 간주됩니다.

QML_ADDED_IN_VERSION()은 QML_ELEMENT, QML_NAMED_ELEMENT(), QML_ANONYMOUS, 또는 QML_INTERFACE 매크로를 통해 유형 또는 네임스페이스를 QML에서 사용할 수 있는 경우에만 적용됩니다.

유형이 속한 QML 모듈을 이 방법으로 결정된 버전보다 낮은 버전으로 가져오는 경우 QML 유형은 보이지 않습니다.

QML_ELEMENT 및 QML_NAMED_ELEMENT 을참조하세요 .

QML_ANONYMOUS

둘러싸는 형식을 사용할 수 있지만 QML에서는 익명인 것으로 선언합니다. 이 유형은 QML에서 프로퍼티를 선언하는 데 생성하거나 사용할 수 없지만 C++에서 전달하면 인식됩니다. QML에서는 이 유형의 프로퍼티가 C++로 선언된 경우 사용할 수 있습니다.

QML_ELEMENT, QML_NAMED_ELEMENT(), QML_UNCREATABLE() 및 QML_INTERFACE 을참조하세요 .

QML_ATTACHED(ATTACHED_TYPE)

둘러싸는 유형이 다른 유형에 첨부 프로퍼티로 ATTACHED_TYPE 를 첨부한다고 선언합니다. 이는 해당 유형이 QML_ELEMENT 또는 QML_NAMED_ELEMENT() 매크로를 사용하여 QML에 노출된 경우에 적용됩니다.

QML_ELEMENT, QML_NAMED_ELEMENT(), qmlAttachedPropertiesObject() 및 첨부된 속성 제공을참조하세요 .

[since 6.5] QML_CONSTRUCTIBLE_VALUE

주변 값 유형을 생성 가능한 것으로 표시합니다. 즉, 이 유형의 프로퍼티에 JavaScript 값을 할당할 때 정확히 하나의 인수를 받는 유형의 Q_INVOKABLE 생성자를 사용할 수 있습니다.

다음과 같이 구성 가능한 값 유형을 선언할 수 있습니다:

class MyValueType
{
    Q_GADGET
    QML_VALUE_TYPE(myValueType)
    QML_CONSTRUCTIBLE_VALUE
public:
    Q_INVOKABLE MyValueType(double d);

    // ...
};

위의 유형을 사용하면 다음 QML 코드는 지정된 생성자를 사용하여 MyValueType 값을 생성하고 이를 프로퍼티에 할당합니다.

QtObject {
    property myValueType v: 5.4
}

이 방법으로 값 목록을 구성할 수도 있습니다:

QtObject {
    property list<myValueType> v: [5.4, 4.5, 3.3]
}

값 유형을 주소 지정이 가능하도록 만들면 유형 어설션에서 이러한 유형을 사용하여 명시적으로 구성할 수 있습니다:

pragma ValueTypeBehavior: Addressable

QtObject {
    function process(d: real) {
        let v = d as myValueType;
        // v is a myValueType now, not a number
    }
}

이 매크로는 Qt 6.5에 도입되었습니다.

QML_VALUE_TYPE 를참조하십시오 .

QML_ELEMENT

클래스 또는 네임스페이스 이름을 QML 요소 이름으로 사용하여 둘러싸는 유형 또는 네임스페이스를 QML에서 사용할 수 있도록 선언합니다.

예를 들어, 이렇게 하면 C++ 클래스 Slider 를 Slider 이라는 QML 유형으로 사용할 수 있습니다. 모든 속성, 호출 가능한 메서드 및 열거 형이 노출됩니다.

class Slider : public QObject
{
    Q_OBJECT
    QML_ELEMENT
    Q_PROPERTY(int value READ value WRITE setValue NOTIFY valueChanged FINAL)
    // ...
public:
    enum Slippiness {
        Dry, Wet, Icy
    };
    Q_ENUM(Slippiness)

    Q_INVOKABLE void slide(Slippiness slippiness);

    // ...
}

빌드 시스템을 사용하여 주 버전이 1 인 유형 네임스페이스 com.mycompany.qmlcomponents에 유형을 등록할 수 있습니다. qmake의 경우 프로젝트 파일에 다음을 지정합니다:

CONFIG += qmltypes
QML_IMPORT_NAME = com.mycompany.qmlcomponents
QML_IMPORT_MAJOR_VERSION = 1

CMake를 사용하면 URI와 버전을 qt_add_qml_module에 전달합니다.

qt6_add_qml_module(myapp
  URI com.mycompany.qmlcomponents
  VERSION 1.0
)

일단 등록되면 동일한 타입 네임스페이스와 버전 번호를 가져와서 QML에서 해당 타입을 사용할 수 있습니다:

import com.mycompany.qmlcomponents 1.0

Slider {
    value: 12
    Component.onCompleted: slide(Slider.Icy)

    // ...
}

Q_NAMESPACE 태그가 지정된 네임스페이스를 이 방법으로 사용할 수 있도록 설정하여 여기에 포함된 Q_ENUM_NS 태그가 지정된 열거형을 노출할 수도 있습니다:

namespace MyNamespace {
  Q_NAMESPACE
  QML_ELEMENT

  enum MyEnum {
      Key1,
      Key2,
  };
  Q_ENUM_NS(MyEnum)
}

그런 다음 QML에서 열거형을 사용할 수 있습니다:

Component.onCompleted: console.log(MyNamespace.Key2)

참고: 클래스의 이름이 같지만 서로 다른 네임스페이스에 있는 경우 두 클래스 모두에 QML_ELEMENT를 사용하면 충돌이 발생할 수 있습니다. 그 중 하나에 QML_NAMED_ELEMENT()를 사용해야 합니다.

C++과 QML 간의 올바른 통합 방법 선택하기, QML_NAMED_ELEMENT(), Q_REVISION() 및 QML_ADDED_IN_VERSION()도 참조하세요 .

QML_EXTENDED(EXTENDED_TYPE)

둘러싸는 유형이 EXTENDED_TYPE 을 확장으로 사용하여 QML에서 추가 속성, 메서드 및 열거형을 제공한다고 선언합니다. 이는 해당 유형이 QML_ELEMENT 또는 QML_NAMED_ELEMENT() 매크로를 사용하여 QML에 노출된 경우에 적용됩니다.

QML_ELEMENT, QML_NAMED_ELEMENT(), QML_EXTENDED_NAMESPACE() 및 확장 객체 등록하기를참조하세요 .

QML_EXTENDED_NAMESPACE(EXTENSION_NAMESPACE)

둘러싸는 타입이 EXTENSION_NAMESPACE 을 확장으로 사용하여 QML에서 추가 열거를 제공한다고 선언합니다. 이는 QML_ELEMENT 또는 QML_NAMED_ELEMENT() 매크로를 사용하여 유형이 QML에 노출된 경우에 적용됩니다. 이 기능이 작동하려면 열거형이 메타객체 시스템에 노출되어야 합니다.

예를 들어 다음 C++ 코드를 제공하면

namespace MyNamespace {
    Q_NAMESPACE
    enum MyEnum { MyEnumerator = 10 };
    Q_ENUM_NS(MyEnum)
}

class QmlType : public QObject
{
    Q_OBJECT
    QML_ELEMENT
    QML_EXTENDED_NAMESPACE(MyNamespace)
}

를 사용하면 QML에서 열거형에 액세스할 수 있습니다:

QmlType {
    property int i: QmlType.MyEnumerator // i will be 10
}

QML_NAMESPACE_EXTENDED(), QML_ELEMENT, QML_NAMED_ELEMENT(), QML_EXTENDED(), 확장 객체 등록하기, Q_ENUM, 및 Q_ENUM_NS 를참조하세요 .

QML_EXTRA_VERSION(MAJOR, MINOR)

MAJOR.MINOR 에서도 유형을 사용할 수 있어야 한다고 선언합니다. 이는 한 유형을 여러 주요 버전에서 사용할 수 있어야 하는 경우에 유용합니다.

유형은 자동으로 등록됩니다:

• 도입된 주요 버전은 QML_ADDED_IN_VERSION 을 참조하세요.
• 해당 멤버가 도입된 모든 주요 버전.
• 해당 모듈의 현재 주요 버전( QML_REMOVED_IN_VERSION 이전 버전이 아닌 경우).

특히, 위 사이의 PAST_MAJOR_VERSIONS에는 자동으로 등록되지 않습니다. QML_EXTRA_VERSION을 사용하여 추가 주요 버전에 유형을 수동으로 등록할 수 있습니다.

QML_ELEMENT 및 QML_ADDED_IN_VERSION 을참조하세요 .

QML_FOREIGN(FOREIGN_TYPE)

둘러싸는 C++ 타입의 QML_ELEMENT, QML_NAMED_ELEMENT(), QML_ANONYMOUS, QML_INTERFACE, QML_UNCREATABLE(), QML_SINGLETON, QML_ADDED_IN_VERSION(), QML_REMOVED_IN_VERSION(), QML_ADDED_IN_MINOR_VERSION(), QML_REMOVED_IN_MINOR_VERSION(), QML_EXTENDED(), QML_EXTENDED_NAMESPACE() 또는 QML_NAMESPACE_EXTENDED() 매크로가 둘러싸는 타입에 적용되지 않고 FOREIGN_TYPE 에 적용되도록 선언합니다. 둘러싸는 타입은 여전히 Q_GADGET 또는 Q_OBJECT 매크로를 사용하여 메타 객체 시스템에 등록해야 합니다.

이는 예를 들어 타사 라이브러리에 속해 있어 매크로를 추가하기 위해 수정할 수 없는 유형을 등록하는 데 유용합니다. 네임스페이스를 등록하려면 QML_FOREIGN_NAMESPACE()를 참조하세요.

QML_ELEMENT, QML_NAMED_ELEMENT() 및 QML_FOREIGN_NAMESPACE()도 참조하세요 .

QML_FOREIGN_NAMESPACE(FOREIGN_NAMESPACE)

둘러싸는 C++ 네임스페이스의 QML_ELEMENT, QML_NAMED_ELEMENT(), QML_ANONYMOUS, QML_INTERFACE, QML_UNCREATABLE(), QML_SINGLETON, QML_ADDED_IN_VERSION(), QML_REMOVED_IN_VERSION(), QML_ADDED_IN_MINOR_VERSION() 또는 QML_REMOVED_IN_MINOR_VERSION() 매크로가 둘러싸는 유형에 적용되지 않고 FOREIGN_NAMESPACE. 둘러싸는 네임스페이스는 여전히 Q_NAMESPACE 매크로를 사용하여 메타 객체 시스템에 등록해야 합니다.

이는 예를 들어 타사 라이브러리에 속해 있어 매크로를 추가하기 위해 수정할 수 없는 네임스페이스를 등록하는 데 유용합니다.

QML_ELEMENT, QML_NAMED_ELEMENT() 및 QML_FOREIGN()도 참조하세요 .

QML_IMPLEMENTS_INTERFACES(interfaces)

이 매크로는 클래스가 구현하는 QML interfaces 을 Qt에 알려줍니다. 이 매크로는 QML_INTERFACE 을 사용하는 클래스와 인터페이스할 때만 사용해야 하며, 그렇지 않으면 Q_INTERFACES 을 사용해야 합니다. QML_ELEMENT 을 통한 선언적 등록이 제대로 작동하려면 이 매크로가 필요합니다.

QML_INTERFACE 와 Q_INTERFACES도 참조하십시오 .

QML_INTERFACE

이 매크로는 둘러싸는 C++ 타입을 QML 시스템에 인터페이스로 등록합니다.

QML에서 인터페이스로 등록된 유형은 메타 객체 시스템에서도 자신을 인터페이스로 선언해야 합니다. 예를 들어

struct FooInterface
{
    QML_INTERFACE
public:
    virtual ~FooInterface();
    virtual void doSomething() = 0;
};

Q_DECLARE_INTERFACE(FooInterface, "org.foo.FooInterface")

이러한 방식으로 QML에 등록하면 속성 유형으로 사용할 수 있습니다:

Q_PROPERTY(FooInterface *foo READ foo WRITE setFoo)

이 프로퍼티에 QObject 서브클래스를 할당하면 QML 엔진이 자동으로 FooInterface* 로 인터페이스 형변환을 수행합니다.

인터페이스 유형은 암시적으로 익명이며 QML에서 생성할 수 없습니다.

참고: QML_INTERFACE를 사용하여 유형에서 상속할 때는 Q_INTERFACES 대신 QML_IMPLEMENTS_INTERFACES 을 사용합니다.

QML_IMPLEMENTS_INTERFACES(), QML_ELEMENT, QML_NAMED_ELEMENT(), QML_UNCREATABLE() 및 QML_ANONYMOUS도 참조하세요 .

QML_NAMED_ELEMENT(name)

요소 이름으로 name 을 사용하여 QML에서 사용할 수 있는 둘러싸는 유형 또는 네임스페이스를 선언합니다. 그렇지 않으면 QML_ELEMENT 과 동일하게 동작합니다.

class SqlEventDatabase : public QObject
{
    Q_OBJECT
    QML_NAMED_ELEMENT(EventDatabase)

    // ...
};

C++과 QML 간의 올바른 통합 방법 선택 및 QML_ELEMENT도 참조하세요 .

QML_REMOVED_IN_VERSION(MAJOR, MINOR)

둘러싸는 유형 또는 네임스페이스가 지정된 MAJOR.MINOR 버전에서 제거되었음을 선언합니다. 이는 주로 QML 유형의 구현을 교체할 때 유용합니다. 해당 QML_ADDED_IN_VERSION()가 동일한 QML 이름의 다른 유형 또는 네임스페이스에 있는 경우, 제거된 유형은 MAJOR.MINOR 보다 낮은 버전의 모듈을 가져올 때 사용되고 추가된 유형은 MAJOR.MINOR 보다 크거나 같은 버전의 모듈을 가져올 때 사용됩니다.

QML_REMOVED_IN_VERSION()은 QML_ELEMENT, QML_NAMED_ELEMENT(), QML_ANONYMOUS, 또는 QML_INTERFACE 매크로를 통해 유형 또는 네임스페이스를 QML에서 사용할 수 있는 경우에만 적용됩니다.

QML_ELEMENT 및 QML_NAMED_ELEMENT 을참조하십시오 .

QML_SEQUENTIAL_CONTAINER(VALUE_TYPE)

이 매크로는 VALUE_TYPE 요소의 시퀀스를 관리하는 순차 컨테이너로 둘러싸는 유형 또는 참조 유형을 선언합니다. VALUE_TYPE 실제 값 유형이거나 객체 유형에 대한 포인터일 수 있습니다. 컨테이너는 일반적으로 템플릿이므로 이 매크로를 실제 컨테이너 선언에 추가할 수 있는 경우는 거의 없습니다. QML_FOREIGN 을 사용하여 템플릿 인스턴스화에 유형 등록을 첨부해야 합니다. 이 기술을 사용하면 예를 들어 다음과 같이 순차적인 컨테이너를 선언할 수 있습니다:

class IntDequeRegistration
{
  Q_GADGET
  QML_FOREIGN(std::deque<int>)
  QML_ANONYMOUS
  QML_SEQUENTIAL_CONTAINER(int)
};

그런 다음 QML에서 컨테이너를 자바스크립트 배열처럼 사용할 수 있습니다.

class Maze
{
  Q_OBJECT
  Q_ELEMENT
  // 0: North, 1: East, 2: South, 3: West
  Q_PROPERTY(std::deque<int> solution READ solution CONSTANT FINAL)
  [...]
}

Item {
  Maze {
    id: maze
  }

  function showSolution() {
      maze.solution.forEach([...])
  }
}

QML_ANONYMOUS 및 QML_FOREIGN()도 참조하세요 .

QML_SINGLETON

둘러싸는 타입을 QML에서 싱글톤으로 선언합니다. 이는 유형이 Q_OBJECT 이고 QML에서 사용할 수 있는 경우에만 적용됩니다( QML_ELEMENT 또는 QML_NAMED_ELEMENT() 매크로를 사용하여). 기본적으로 각 QQmlEngine 은 타입이 처음 액세스될 때 타입의 기본 생성자 또는 T *create(QQmlEngine *, QJSEngine *) 서명의 정적 팩토리 함수를 사용하여 싱글톤 인스턴스를 생성하려고 시도합니다. 둘 다 존재하고 액세스할 수 있는 경우 기본 생성자가 선호됩니다. 기본 생성자도 없고 팩토리 함수도 없는 경우 싱글톤에 액세스할 수 없습니다. QML 엔진은 일반적으로 싱글톤의 소유권을 가지며 엔진 자체가 파괴되면 싱글톤을 삭제합니다. 싱글톤에서 QJSEngine::setObjectOwnership()를 호출하여 이를 방지할 수 있습니다.

기본 구성 가능한 클래스를 싱글톤으로 선언하려면 QML_SINGLETON을 추가하기만 하면 됩니다:

class MySingleton : public QObject
{
    Q_OBJECT
    QML_ELEMENT
    QML_SINGLETON
    // Q_PROPERTY( ... )
public:
    // members, Q_INVOKABLE functions, etc.
};

싱글톤 클래스가 기본 구성 가능 클래스는 아니지만 수정할 수 있는 경우 팩토리 함수를 추가하여 액세스할 수 있도록 만들 수 있습니다:

class MySingleton : public QObject
{
    Q_OBJECT
    QML_ELEMENT
    QML_SINGLETON
    // Q_PROPERTY( ... )

public:
    static MySingleton *create(QQmlEngine *qmlEngine, QJSEngine *jsEngine)
    {
        MySingleton *result = nullptr;
        // Create the object using some custom constructor or factory.
        // The QML engine will assume ownership and delete it, eventually.
        return result;
    }

    // members, Q_INVOKABLE functions, etc
};

클래스를 수정할 수 없고 기본 생성자나 적절한 팩토리 함수가 없는 경우 QML_FOREIGN 래퍼를 제공하여 팩토리 함수를 정의할 수 있습니다:

struct SingletonForeign
{
    Q_GADGET
    QML_FOREIGN(MySingleton)
    QML_SINGLETON
    QML_NAMED_ELEMENT(MySingleton)
public:

    static MySingleton *create(QQmlEngine *, QJSEngine *engine)
    {
        MySingleton *result = nullptr;
        // Create the instance using some custom constructor or factory.
        // The QML engine will assume ownership and delete it, eventually.
        return result;
    }
};

마지막으로, 생성을 제어할 수 없는 특정 싱글톤 객체 하나를 제공하려는 경우 팩토리 함수에서 이를 반환할 수 있습니다. 이는 qmlRegisterSingletonInstance 함수를 대체할 수 있습니다. 호출하는 경우

qmlRegisterSingletonInstance("MyModule", 1, 0, "MySingleton", myObject);

를 호출하는 경우 MySingleton * 대신 다음과 같이 할 수 있습니다:

struct SingletonForeign
{
    Q_GADGET
    QML_FOREIGN(MySingleton)
    QML_SINGLETON
    QML_NAMED_ELEMENT(MySingleton)
public:

    // Initialize this using myObject where you would previously
    // call qmlRegisterSingletonInstance().
    inline static MySingleton *s_singletonInstance = nullptr;

    static MySingleton *create(QQmlEngine *, QJSEngine *engine)
    {
        // The instance has to exist before it is used. We cannot replace it.
        Q_ASSERT(s_singletonInstance);

        // The engine has to have the same thread affinity as the singleton.
        Q_ASSERT(engine->thread() == s_singletonInstance->thread());

        // There can only be one engine accessing the singleton.
        if (s_engine)
            Q_ASSERT(engine == s_engine);
        else
            s_engine = engine;

        // Explicitly specify C++ ownership so that the engine doesn't delete
        // the instance.
        QJSEngine::setObjectOwnership(s_singletonInstance,
                                      QJSEngine::CppOwnership);
        return s_singletonInstance;
    }

private:
    inline static QJSEngine *s_engine = nullptr;
};

이렇게 하면 기존 클래스 MySingleton 가 MySingleton 이라는 QML 싱글톤으로 선언됩니다. s_singletonInstance 멤버를 설정하여 사용하기 전에 언제든지 인스턴스를 지정할 수 있습니다. 이 과정에서 MySingleton 자체를 수정할 필요는 없습니다.

QML_ELEMENT, QML_NAMED_ELEMENT(), qmlRegisterSingletonInstance(), QQmlEngine::singletonInstance() 및 QML의 싱글톤도참조하세요 .

[since 6.5] QML_STRUCTURED_VALUE

주변 값 유형을 구조화된 것으로 표시합니다. 구조화된 값 유형은 자바스크립트 객체에서 속성별로 구성할 수 있으며, 가급적 그렇게 하는 것이 좋습니다. 그러나 구조화된 값 유형은 항상 QML_CONSTRUCTIBLE_VALUE 입니다. 즉, 기본 유형에서 구성을 처리하기 위해 Q_INVOKABLE 생성자를 제공할 수 있습니다.

다음과 같이 구조화된 값 타입을 선언할 수 있습니다:

class MyValueType
{
    Q_GADGET
    QML_VALUE_TYPE(myValueType)
    QML_STRUCTURED_VALUE
    Q_PROPERTY(double d READ d WRITE setD)
    Q_PROPERTY(string e READ e WRITE setE)

    // ...
};

그런 다음 다음과 같이 이 유형의 프로퍼티를 채울 수 있습니다:

QtObject {
    property myValueType v: ({d: 4.4, e: "a string"})
}

추가 괄호는 자바스크립트 코드 블록으로 해석될 수 있는 것과 자바스크립트 객체를 구분하기 위해 필요합니다.

이 방법으로 값 목록을 구성할 수도 있습니다:

QtObject {
    property list<myValueType> v: [
        {d: 4.4, e: "a string"},
        {d: 7.1, e: "another string"}
    ]
}

값 유형을 주소 지정이 가능하도록 만들면 유형 어설션에서 이러한 유형을 사용하여 명시적으로 구성할 수 있습니다:

pragma ValueTypeBehavior: Addressable

QtObject {
    function process(d: real) {
        let v = {d: d, e: objectName} as myValueType;
        // v is a myValueType now
    }
}

이 매크로는 Qt 6.5에 도입되었습니다.

QML_VALUE_TYPE 와 QML_CONSTRUCTIBLE_VALUE 를참조하십시오 .

QML_UNAVAILABLE

이 매크로는 QML에서 둘러싸는 유형을 사용할 수 없도록 선언합니다. 이 매크로는 QQmlTypeNotAvailable 라는 내부 더미 유형을 QML_FOREIGN() 유형으로 등록하고, 사용자가 지정한 추가 QML 매크로를 사용합니다.

일반적으로 모듈에서 내보내는 유형은 고정되어 있어야 합니다. 그러나 C++ 유형을 사용할 수 없는 경우 최소한 QML 유형 이름을 "예약"하고 사용할 수 없는 유형의 사용자에게 의미 있는 오류 메시지를 제공해야 합니다.

예시:

#ifdef NO_GAMES_ALLOWED
struct MinehuntGame
{
    Q_GADGET
    QML_NAMED_ELEMENT(Game)
    QML_UNAVAILABLE
    QML_UNCREATABLE("Get back to work, slacker!");
};
#else
class MinehuntGame : public QObject
{
    Q_OBJECT
    QML_NAMED_ELEMENT(Game)
    // ...
};
#endif

이렇게 하면 "Game" 유형을 사용하려고 시도하는 모든 QML에 오류 메시지가 표시됩니다:

fun.qml: Get back to work, slacker!
   Game {
   ^

이 기술을 사용하면 완전한 QObject 이 아닌 Q_GADGET 구조체만 있으면 오류 메시지를 사용자 지정할 수 있습니다. QML_UNCREATABLE () 없이도 QML_UNAVAILABLE은 완전히 알 수 없는 유형에 대해 일반적인 "유형이 아닙니다"보다 더 구체적인 오류 메시지를 생성합니다.

QML_ELEMENT, QML_NAMED_ELEMENT(), QML_UNCREATABLE() 및 QML_FOREIGN()도 참조하세요 .

QML_UNCREATABLE(reason)

둘러싸는 타입을 QML에서 생성할 수 없음을 선언합니다. 이는 QML_ELEMENT 또는 QML_NAMED_ELEMENT() 매크로를 통해 QML에서 해당 유형을 사용할 수 있는 경우에 적용됩니다. QML에서 유형을 생성하려는 시도가 감지되면 reason 이 오류 메시지로 전송됩니다.

특히 QML_ANONYMOUS 로 노출된 타입이나 QML_ELEMENT 또는 QML_NAMED_ELEMENT()로 노출된 네임스페이스와 같이 일부 QML 타입은 암시적으로 생성할 수 없습니다.

Qt 6.0부터는 표준 메시지를 사용하는 이유 대신 ""를 사용할 수 있습니다.

QML_ELEMENT, QML_NAMED_ELEMENT() 및 QML_ANONYMOUS 를참조하십시오 .

QML_VALUE_TYPE(name)

name 을 이름으로 사용하여 QML에서 사용할 수 있는 둘러싸는 유형 또는 네임스페이스를 선언합니다. 유형은 값 유형이어야 하고 이름은 소문자여야 합니다.

class MyValueType
{
    Q_GADGET
    QML_VALUE_TYPE(myValueType)

    // ...
};

C++과 QML 간의 올바른 통합 방법 선택하기 및 QML_NAMED_ELEMENT 를참조하세요 .