Des widgets natifs : premiers plans pour Qt 6 ?

Un utilisateur préfère très souvent une application qui s’intègre parfaitement à son environnement : des boutons dans le bon ordre, des raccourcis communs… mais aussi une apparence similaire. Évidemment, le plus simple, pour y arriver, est d’utiliser les API spécifiques à chaque plateforme — mais cela complexifie énormément le développement d’une bibliothèque multiplateforme comme Qt. Il vaut mieux alors réimplémenter complètement chaque composant (par exemple, avec OpenGL pour l’affichage) en se rapprochant de l’apparence des composants natifs, y compris pour les animations. Cependant, l’apparence et les animations peuvent changer d’une mise à jour à l’autre : difficile de se tenir à la page.

Quelques développeurs de Qt commencent donc à explorer l’autre piste : donner accès directement aux composants natifs à travers Qt. L’idée n’est pas neuve (wxWidgets l’implémente, par exemple), mais elle présente toute une série de défis — pas tellement pour les composants les plus simples, mais surtout les plus complexes, comme les onglets — : selon les systèmes, les composants natifs ont plus ou moins de fonctionnalités, une variété difficile à unifier.

Les développements actuels donnent un prototype d’ensemble de composants, avec une architecture à base d’extensions (une par plateforme). L’API (tant C++ que Qt Quick) est très réduite et fonctionne comme une boîte noire : les fonctionnalités exposées doivent être disponibles sur toutes les plateformes actuellement gérées… et celles du futur. Cette restriction signifie que cette solution n’est pas prévue pour ceux qui souhaitent personnaliser leur interface. À terme, l’objectif est de laisser l’utilisateur accéder directement aux composants natifs pour implémenter les fonctionnalités non disponibles lui-même.

Par exemple, voici une petite application Qt Quick qui mélange l’API commune (module Qt.CommonControls — le nom n’est pas définitif) et des composants natifs spécifiques à macOS (AppKit, module Qt.AppKitControls) :

import QtQml 2.0
import Qt.CommonControls 1.0 as Common
import Qt.AppKitControls 1.0 as AppKit

Window {
  id: window
  visible: true

  Common.Button {
    id: button
    x: 20
    y: 20
    text: "Click me"
    onClicked: text ="You clicked me!"
  }

  Common.TextField {
    id: textField
    placeholderText: "TextField"
    x: 20
    y: button.bottom + 8
  }

  AppKit.SearchField {
    placeholderText: "Search"
    x: 20
    y: textField.bottom + 8
  }
}

La même en C++ :

int main(int argc, char *argv[])
{
  QGuiApplication app(argc, argv);
  QCommonWindow window;

  QCommonButton commonButton(QStringLiteral("Click me"), &window);
  commonButton.move(20, 20);
  QObject::connect(&commonButton, &QCommonButton::clicked, [&commonButton](){
    commonButton.setText(QStringLiteral("Clicked!"));
  });

  QCommonTextField textField(&window);
  textField.setPlaceholderText(QStringLiteral("TextField"));
  textField.move(20, commonButton.bottom() + 8);

#if defined(Q_OS_MACOS)
  QAppKitSearchField searchField;
  searchField.setParent(&window);
  searchField.move(20, textField.bottom() + 8);
  NSSearchField *nsSearchField = searchField.nsSearchFieldHandle();
  nsSearchField.placeholderString = @"Search...";
#endif

  window.showFullScreen();
  return app.exec();
}

Des mécanismes de type préprocesseur devraient donc se retrouver dans Qt Quick, à un moment ou à un autre, pour gérer le code à utiliser selon la plateforme — exactement comme en C++.

Ces développements ne devraient pas arriver avant Qt 6. En effet, avec Qt 5, on compte déjà un certain nombre de manières de créer des interfaces graphiques :

  • Qt Widgets ;
  • Qt Quick et ses composants de base (de très bas niveau) ;
  • Qt Quick Controls 1 ;
  • Qt Quick Controls 2.

La situation est déjà complexe ; ajouter ces composants natifs ne ferait qu’embrouiller largement plus toute personne débutant avec Qt. Les plans sont donc de réduire le nombre d’options : soit Qt Widgets (pour la compatibilité avec les applications existantes), soit Qt Quick Controls 2 (pour l’embarqué et le mobile), soit cette nouvelle voie de composants entièrement natifs (pour les autres besoins).

Source : Native look and feel.

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s