Intégration des plates-formes

La principale force de Qt en tant que boîte à outils multiplateforme pour le développement d'applications est de supprimer la nécessité de dupliquer le code de l'application pour chaque plateforme cible.

Bien que Qt résolve de nombreuses tâches typiques de l'écriture d'une application, il y a toujours des cas particuliers que Qt ne peut pas couvrir, ou lorsqu'il est plus logique de construire une fonctionnalité au-dessus des API spécifiques à la plate-forme, ou d'une autre boîte à outils.

Pour prendre en charge ces cas d'utilisation, tout en permettant à Qt de gérer la majeure partie de la logique de l'application, Qt fournit une large gamme d'API d'intégration de plateforme, allant de simples conversions de type à des interfaces natives spécifiques à la plateforme.

Conversions de types

De nombreux types de données de base de Qt, tels que QString, QPoint, ou QImage, offrent des conversions vers et depuis les types équivalents natifs.

Par exemple, pour obtenir le nom d'utilisateur de l'utilisateur actuel sur les plateformes Apple :

NSProcessInfo *processInfo = NSProcessInfo.processInfo;
QString userName = QString::fromNSString(processInfo.userName)

Pour une liste complète de toutes les conversions de types, voir l'aperçu des conversions de types.

Intégration de fenêtres

Les fenêtres créées par les API des plateformes sous-jacentes peuvent être utilisées comme conteneurs parents pour les fenêtres Qt, ou intégrées dans les fenêtres Qt en tant que fenêtres enfants.

Le premier cas est utile si l'application est principalement écrite à l'aide des API natives de la plateforme, mais que certaines parties de l'application utilisent Qt, par exemple pour dessiner une interface utilisateur spécialisée. Pour intégrer Qt dans la hiérarchie des fenêtres de l'application native, utilisez QWindow::winId() pour obtenir la poignée native de la fenêtre Qt, puis utilisez les API natives pour re-parenter la fenêtre dans l'interface utilisateur native.

Ce dernier point est utile si la plateforme native, ou une autre boîte à outils, expose un contrôle spécialisé en tant que fenêtre native. En utilisant QWindow::fromWinId() pour envelopper la poignée de la fenêtre native dans une QWindow, la fenêtre peut alors être re-parentée dans la hiérarchie des fenêtres Qt comme n'importe quelle autre QWindow. Pour re-parenter cette QWindow dans une interface utilisateur basée sur des Qt Widgets, utilisez la fonction QWidget::createWindowContainer() spécifique aux widgets.

Gestion des événements

La plupart des cas d'utilisation de la gestion d'événements dans Qt XML sont suffisamment couverts par la livraison d'événements multiplateforme, via QWindow::event() et ses amis, ou via QObject::installEventFilter().

Dans les cas où cela n'est pas suffisant, Qt fournit un accès à la livraison des événements natifs. Un filtre d'événements global qui reçoit tous les événements natifs peut être installé en utilisant QCoreApplication::installNativeEventFilter(), tandis que les événements natifs par fenêtre peuvent être gérés dans QWindow::nativeEvent().

Interfaces natives

Les fonctionnalités spécifiques à la plate-forme qui ne sont pas couvertes par les API mentionnées ci-dessus sont gérées par le mécanisme plus générique des interfaces natives de Qt. Les interfaces permettent d'accéder aux API natives ou spécifiques à la plate-forme des classes qu'elles étendent.

Les interfaces se trouvent dans l'espace de noms QNativeInterface et couvrent des cas d'utilisation tels que l'accès aux poignées natives sous-jacentes, l'adoption des poignées natives existantes ou la fourniture d'API spécifiques à la plate-forme.

Par exemple, pour accéder au NSOpenGLContext sous-jacent d'un QOpenGLContext sur macOS, il faut utiliser l'interface native QNativeInterface::QCocoaGLContext:

using namespace QNativeInterface;
if (auto *cocoaGLContext = glContext->nativeInterface<QCocoaGLContext>())
    [cocoaGLContext->nativeContext() makeCurrentContext];

Pour une liste complète de toutes les interfaces natives, voir l'aperçu des interfaces natives.

Prise en charge de la plate-forme

En plus des API pour les développeurs d'applications, Qt s'interface également avec la plateforme en fournissant les implémentations sous-jacentes des blocs de construction multiplateforme de Qt.

Des exemples sont les abstractions du distributeur d'événements de Qt Core et les abstractions du matériel de rendu dans RHI.

La principale couche d'abstraction ici est la Qt Platform Abstraction, ou QPA en abrégé, qui traite de l'intégration du système de fenêtres et des cas d'utilisation connexes.