3 pièce(s) jointe(s)
GTK 4.0, la boîte à outils pour réaliser des interfaces graphiques, est disponible
GTK 4.0 est disponible. La boîte à outils pour réaliser des interfaces graphiques apporte des améliorations dans le transfert des données,
une prise en charge intégrée de la lecture multimédia et bien d'autres
GTK est un ensemble de bibliothèques logicielles permettant de réaliser des interfaces graphiques. À l'origine, GTK a été développé pour les besoins du logiciel de traitement d'images GIMP (GNU Image Manipulation Program). Actuellement, son domaine d'application ne se limite plus seulement à GIMP, mais est utilisé dans d'autres projets. Par exemple, GTK est au cœur de l'environnement GNOME (GNU Network Object Model Environment), mais il peut également être utilisé pour écrire des applications pour d'autres environnements Linux, ainsi que des applications ciblant Microsoft Windows et Apple macOS.
L'utilisation de GTK pour la création de GUI est très intéressante sur plusieurs points :
- GTK est sous licence GNU LGPL. Cela fait de GTK une bibliothèque libre, permettant ainsi de l'utiliser ou de la modifier sans aucune contrainte financière. Pour avoir plus de renseignements, le plus simple est de visiter le site du projet GNU ;
- GTK existe sur plusieurs plateformes. En effet, GTK fonctionne sur les plateformes UNIX-like, Windows, BeOs ;
- GTK est utilisable avec plusieurs langages de programmation. Même si les créateurs de GTK ont écrit cette bibliothèque en C, sa structure orientée objet et sa licence ont permis à d'autres développeurs d'adapter GTK à leur langage préféré. Ainsi, il est possible de programmer des GUI GTK en C, C++, Ada, Perl, Python, PHP et bien d'autres.
Dans un billet de blog, les responsables de son développement ont annoncé la disponibilité de GTK 4.0 :
« 2020 a été une très longue année. Quelle meilleure façon d'y mettre fin qu'avec une version majeure! Aujourd'hui, nous avons publié GTK 4.0.
« GTK 4.0 est le résultat d'un travail acharné d'une petite équipe de développeurs dévoués. Nous aurons un article séparé pour passer en revue les statistiques, mais le bref résumé est que depuis la version 3.89.1 de novembre 2016, nous avons ajouté plus de 18 000 commits et réalisé plus de 20 versions de développement.
« Félicitations et un grand merci à tous ceux qui ont participé à cet effort, et en particulier à Benjamin, Emmanuele, Timm, Carlos, Jonas et Christian! »
GTK 4.0 propose de nouveaux widgets et des modifications apportées aux éléments existants, une prise en charge intégrée de la lecture multimédia, des améliorations de l'accélération GPU comme le travail sur son nouveau moteur de rendu Vulkan et une meilleure prise en charge de macOS. Nous pouvons également noter des améliorations du transfert de données, la refonte des shaders, le défilement accéléré par GPU, les améliorations du rendu OpenGL au-delà du travail de Vulkan, la restauration du travail sur HTMl5 Broadway, une meilleure prise en charge de Windows, etc.
Voyons quelques points un peu plus en profondeur.
Gestion des médias dans GT4
GTK 4 permettra aux applications GTK d'afficher plus facilement des animations; que ce soit une animation programmatique, un fichier webm ou un flux en direct.
GTK 4 apporte une nouvelle API appelée GdkPaintable qui a été inspirée par l'effort CSS Houdini. Elle est très flexible (tout ce que vous pouvez dessiner peut être un GdkPaintable). Le contenu peut être redimensionnable (comme svg) ou changer au fil du temps (comme webm).
Si vous avez des besoins plus spécialisés, tout ce qui peut être capturé dans un GtkSnapshot peut être transformé en un dessin avec gtk_snapshot_to_paintable(). Si vous créez un widget personnalisé qui souhaite dessiner un objet à peindre, c'est très simple. Appelez simplement gdk_paintable_snapshot().
Vous pouvez disposer du contrôle multimédia en vous servant du widget GtkVideo.
Transfert de données sur GTK4
Les méthodes traditionnelles de transfert de données initiées par l'utilisateur entre les applications de bureau sont le presse-papiers ou le glisser-déposer. GTK+ prend en charge ces méthodes mais, jusqu'à GTK3, les API dont la boîte à outils disposait pour ce type de transfert de données étaient des copies finement déguisées des API X11 correspondants. Ce n'est pas trop surprenant, puisque toute l'API GDK a été calquée sur X11. Malheureusement, l'implémentation inclut des résultats comme des transferts incrémentiels et des conversions de format de chaîne.
Pour GTK4, l'équipe a décidé d'abandonner cette façon de procéder, optant pour une modernisation. Voici le concept de la nouvelle approche :
« Si les données que votre application souhaite envoyer ne sont pas une chaîne, il s'agit probablement d'un objet, tel que GFile, un GdkTexture ou un GdkRGBA. L'application côté réception n'utilise peut-être pas GTK ou GLib et ne connaîtra donc pas ces types. Et même si c'est le cas, il n'y a aucun moyen de faire passer les objets d'un processus à l'autre en un seul morceau.
« En son sein, le transfert de données fonctionne en envoyant un descripteur de fichier à partir de l'application source et l'application cible en lisant un flux d'octets. Les protocoles pour le presse-papiers et le DND utilisent des types mime tels que text/uri-list, image/png ou application/x-color pour identifier le format du flux d'octets.
« L'envoi d'un objet implique la négociation d'un format de données pris en charge par les deux côtés, la sérialisation de l'objet du côté source dans un flux d'octets de ce format, le transfert des données et la désérialisation de l'objet du côté cible. »
Aussi, GTK4 s'accompagne de nouvelles API. « La première API que nous avons introduite pour gérer ces types est l'objet GdkContentFormats. Il peut contenir une liste de formats, qui peuvent être des GTypes ou des types mime. Nous utilisons des objets GdkContentFormats pour décrire les formats dans lesquels une application peut offrir des données, ainsi que les formats dans lesquels une application peut recevoir des données ».
Le presse-papiers
GTK3 a un objet GtkClipboard, qui fournit l'implémentation pour les opérations de copier / coller. Avoir cet objet dans GTK n'est pas idéal, car il nécessite différentes implémentations sur les plateformes prises en charge par GTK. Par conséquent, GTK4 déplace l'objet vers GDK et le renomme GdkClipboard. Il a également été porté sur les nouvelles API de transfert de données. Pour mettre des données dans le presse-papiers dans GTK4, vous devrez utiliser l’une des API « set »:
Code:
1
2
3
| gdk_clipboard_set_content()
gdk_clipboard_set_value()
gdk_clipboard_set_text() |
En fin de compte, toutes ces fonctions finissent par associer un GdkContentProvider au presse-papiers.
Pour lire les données du presse-papiers dans GTK4, vous devrez utiliser l’une des API asynchrones de «read»:
Code:
1
2
3
| gdk_clipboard_read_async()
gdk_clipboard_read_value_async()
gdk_clipboard_read_text_async() |
Glisser déposer
L'API Drag-and-Drop GTK3 consiste à écouter un certain nombre de signaux sur GtkWidget et à appeler quelques fonctions de configuration spéciales pour les sources et les destinations du glisser-déposer. Il est flexible, mais généralement considéré comme déroutant.
Dans GTK4, l'API Drag-and-Drop a été réorganisée autour des concepts de fournisseurs de contenu et de contrôleurs d'événements. Pour lancer une opération de glisser-déposer, vous créez un contrôleur d'événement GtkDragSource qui réagit aux mouvements de glissement (vous pouvez également démarrer des opérations de glisser-déposer "uniques" en appelant simplement gdk_drag_begin vous-même), et vous lui donnez un GdkContentProvider pour les données que vous souhaitez transférer. Pour recevoir des opérations de glisser-déposer, vous créez un contrôleur d'événements GtkDropTarget et appelez une méthode de lecture asynchrone lorsqu'elle émet le signal ::drop-done
Code:
1
2
| gdk_drop_read_value_async()
gdk_drop_read_text_async() |
Contrôleurs d'évènements
L'équipe indique que GTK4 s'est séparé des signaux dans la zone de saisie comme ::button-press-event, ::key-press-event, ::touch-event. À la place, vous devez ajouter des contrôleurs d'événements à votre widget et écouter leurs signaux. Par exemple, il existe GtkGestureClick, GtkEventControllerKey, GtkGestureLongPress et bien d'autres.
Les contrôleurs d'événements peuvent être créés dans des fichiers d'interface utilisateur, mais il est plus courant de le faire dans la fonction init ():
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| static void click_cb (GtkGestureClick *gesture,
int n_press,
double x,
double y)
{
GtkEventController *controller = GTK_EVENT_CONTROLLER (gesture);
GtkWidget *widget = gtk_event_controller_get_widget (controller);
if (x < gtk_widget_get_width (widget) / 2.0 &&
y < gtk_widget_get_height (widget) / 2.0)
g_print ("Red!\n");
}
...
controller = gtk_gesture_click_new ();
g_signal_handler_connect (controller, "pressed",
G_CALLBACK (click_cb), NULL);
gtk_widget_add_controller (widget, controller); |
gtk_widget_add_controller() prend possession du contrôleur et GTK nettoie automatiquement les contrôleurs lorsque le widget est finalisé, il n'y a donc plus rien à faire.
Source : annonce GTK4
Ce n'est pas vraiment multiplateforme
On ne peut pas mettre en avant le côté multiplateforme comme un avantage de GTK, ce toolkit n'est pas vraiment multiplateforme. D'accord on peut compiler des applications Windows et Mac avec, mais l'intégration est vraiment catastrophique, pire que du temps de GTK+2. C'est pratique si on veut porter un logiciel déjà développé destiné à Linux/GNOME, mais ce n'est pas une option envisageable si on veut choisir un toolkit pour développer un logiciel multiplateforme dès le début.
