Modifications apportées à Qt Qml

Qt 6 résultent d'un effort délibéré visant à rendre le framework plus efficace et plus facile à utiliser.

Nous nous efforçons de maintenir la compatibilité binaire et source pour toutes les API publiques à chaque version. Cependant, certaines modifications étaient inévitables afin d’améliorer le framework Qt.

Dans cette rubrique, nous résumons ces modifications dans « Qt Qml » et fournissons des conseils pour les prendre en compte.

Langage QML

Résolution des URL

Dans Qt 5, les URL relatives étaient souvent, bien qu’de manière incohérente, résolues directement, en particulier lorsqu’elles étaient attribuées à une propriété url. Dans Qt 6, ce n’est plus le cas.

Si vous aviez un fichier QML stocké sous « /home/qml/example.qml », et que « example.qml » contenait

property url imageFolder: "./images"

alors la propriété url stockait l’URL « /home/qml/images ». Cela rendait impossible l’utilisation des URL relatives dans Qml de cette manière ; ainsi, dans Qt 6, l’URL reste relative et n’est résolue que lorsque cela est nécessaire (par exemple, lorsqu’elle est utilisée comme source d’un composant Image). Si vous avez besoin de l’ancien comportement, vous pouvez utiliser Qt.resolvedUrl

Par exemple, si vous avez un code tel que

property url imageFolder: "./images"

vous pouvez le réécrire comme suit

property url imageFolder: Qt.resolvedUrl("./images")

Qt.resolvedUrl peut être utilisé aussi bien dans Qt 5 que dans Qt 6.

Pour faciliter le portage, la variable d’environnement ` QML_COMPAT_RESOLVE_URLS_ON_ASSIGNMENT ` peut être définie sur 1 afin de reproduire le comportement de Qt 5. Cette option est disponible depuis Qt 6.2.2. Il est toutefois recommandé de ne l’utiliser que pour débloquer un portage et d’utiliser ` Qt.resolvedUrl ` comme expliqué ci-dessus.

Propriétés de variante

variant Les propriétés de type « variant », marquées comme obsolètes depuis Qt 5, sont désormais traitées exactement de la même manière que les propriétés de type « var ». Le code qui s’appuyait sur une conversion implicite de chaîne déclenchée lors de l’affectation à des propriétés de type « variant » doit être mis à jour afin de créer explicitement un objet du type correct.

Par exemple, si vous avez un code tel que

property variant myColor: "red"

vous pouvez le réécrire ainsi

property variant myColor: Qt.color("red")

Des conversions implicites étaient effectuées pour les chaînes pouvant être analysées comme

• couleur (utilisez plutôt Qt.color),
• date (utilisez plutôt l’objet Date),
• rect (utilisez Qt.rect à la place) et
• size (utilisez Qt.size à la place)

variant reste un mot-clé obsolète dans Qt 6, bien qu’il soit fortement recommandé, dans le nouveau code, d’utiliser plutôt des propriétés de type « var ».

Modifications de l'API entraînant une incompatibilité avec le code source

API modifiée

QQmlListPropertyLes propriétés ` CountFunction ` et ` AtFunction ` ont été modifiées pour utiliser ` qsizetype ` au lieu de ` int `, afin de s’aligner sur les modifications correspondantes apportées aux conteneurs Qt.

Par exemple, si vous avez un code tel que

int myCountFunction(QQmlListProperty<MyType> *);
MyType *myAtFunction(QQmlListProperty<MyType> *, int);

QQmlListProperty<MyType> myReadOnlyList(containingObject, container, &myCountFunction,
                                        &myAtFunction);

vous pouvez le réécrire comme suit

qsizetype myCountFunction(QQmlListProperty<MyType> *);
MyType *myAtFunction(QQmlListProperty<MyType> *, qsizetype);

QQmlListProperty<MyType> myReadOnlyList(containingObject, container, &myCountFunction,
                                        &myAtFunction);

Le code devant prendre en charge à la fois Qt 5 et Qt 6 peut soit utiliser un typedef, à savoir int dans Qt 5 et qsizetype dans Qt 6, soit utiliser QList::size_type, qui est déjà un alias de type.

API supprimées

Diverses fonctions obsolètes ont été supprimées.

• Le constructeur ` QQmlListProperty ` prenant une référence a été supprimé.

  Par exemple, si vous avez du code du type

  QQmlListProperty<QObject>(owner, owner->objectList);

  vous pouvez le réécrire ainsi :

  QQmlListProperty<QObject>(owner, &owner->objectList);

• Les fonctions qmlDebug, qmlInfo, qmlWarning, qmlContext et qmlEngine existaient auparavant à la fois dans l'espace de noms global (ou dans l'espace de noms Qt dans les versions avec espaces de noms) et dans l'espace de noms QtQml. Ces fonctions n'existent désormais plus que dans l'espace de noms global.

  Par exemple, si vous avez un code tel que

  QQmlEngine *engine = QtQml::qmlEngine(qmlObject);

  vous pouvez le réécrire ainsi :

  QQmlEngine *engine = qmlEngine(qmlObject);

• La surcharge de ` qmlRegisterType ` ne prenant aucun argument a été supprimée. Utilisez plutôt ` qmlRegisterAnonymousType `, ou passez à l'enregistrement déclaratif des types avec ` QML_ANONYMOUS`.

  Par exemple, si vous avez un code tel que

  class AnonymousType : public QObject {
    // ...
  };
  
  qmlRegisterType<AnonymousType>();

  vous pouvez le réécrire comme suit :

  class AnonymousType : public QObject {
    // ...
  };
  
  qmlRegisterAnonymousType<AnonymousType>("MyModule", 1);

  Ou bien

  class AnonymousType : public QObject {
      QML_ANONYMOUS
      // ...
  };

• Les surcharges de ` qmlRegisterExtendedType ` et ` qmlRegisterInterface ` qui ne prennent aucun argument de version ont été supprimées. Utilisez les surcharges fournissant une version, ou passez à l'enregistrement déclaratif des types avec ` QML_EXTENDED ` et ` QML_INTERFACE`.

  Par exemple, si vous avez un code tel que

  struct GreetInterface
  {
     virtual ~GreetInterface();
     virtual void greet();
  };
  Q_DECLARE_INTERFACE(GreetInterface, "org.hi.GreetInterface")
  
  qmlRegisterInterface<GreetInterface>("Greeter");

  vous pouvez le réécrire comme suit :

  struct GreetInterface
  {
     virtual ~GreetInterface();
     virtual void greet();
  };
  Q_DECLARE_INTERFACE(GreetInterface, "org.hi.GreetInterface")
  
  qmlRegisterInterface<GreetInterface>("Greeter", 1);

  Sinon,

  struct GreetInterface
  {
     QML_INTERFACE(Greeter)
     virtual ~GreetInterface();
     virtual void greet();
  };
  Q_DECLARE_INTERFACE(GreetInterface, "org.hi.GreetInterface")

  Remarque : dans le nouveau code, il est préférable d’utiliser l’enregistrement déclaratif des types.

• La fonction QJSValue::engine a été supprimée. Si l'accès au moteur est nécessaire, il faut plutôt stocker une référence à celui-ci.
• qmlAttachedPropertiesObjectById et qmlAttachedPropertiesObject(int *, const QObject *, const QMetaObject *, bool) ont été supprimées. Utilisez plutôt la surcharge qmlAttachedPropertiesObject(QObject *, QQmlAttachedPropertiesFunc, bool) de qmlAttachedPropertiesObject.
• QJSEngine::installTranslatorFunctions a été supprimée. QJSEngine::installExtensions est disponible en remplacement.

  Par exemple, si vous avez un code tel que

  QJSEngine engine;
  engine.installTranslatorFunctions();

  vous pouvez le réécrire comme suit :

  QJSEngine engine;
  engine.installExtensions(QJSEngine::TranslationExtension);