Qt

Un article de Wikipédia, l'encyclopédie libre.
(Redirigé depuis Qt4)
Aller à : navigation, rechercher
Page d'aide sur l'homonymie Pour les articles homonymes, voir QT.
Qt
Image illustrative de l'article Qt
Logo

Développeur Qt Development Frameworks/Digia
Première version 1995
Dernière version 5.3.1 (25 juin 2014) [+/-]
Version avancée 5.3 bêta (25 mars 2014) [+/-]
État du projet Actif
Écrit en C++
Environnement GNU/Linux, Windows, Windows CE, Mac OS X, BSD, Unix, Symbian OS, Maemo, Tizen
Type création d'interfaces graphique
Licence GNU GPL v3, GNU LGPL 2.1 à partir de Qt 4.6
Site web http://qt-project.org (version open-source) et http://qt.digia.com/ (version commerciale)
Wayland, libwayland-client et Qt

Qt (prononcé officiellement en anglais cute (/kjuːt/) mais couramment prononcé Q.T.[1]) :

Qt permet la portabilité des applications qui n'utilisent que ses composants par simple recompilation du code source. Les environnements supportés sont les Unix (dont GNU/Linux) qui utilisent le système graphique X Window System ou Wayland, Windows, Mac OS X et également Tizen. Le fait d'être une bibliothèque logicielle multiplate-forme attire un grand nombre de personnes qui ont donc l'occasion de diffuser leurs programmes sur les principaux OS existants.

Qt supporte des bindings avec plus d'une dizaine de langages autres que le C++, comme Java, Python, Ruby, Ada, C#, Pascal, Perl, Common Lisp, etc.

Qt est notamment connu pour être la bibliothèque sur laquelle repose l'environnement graphique KDE, l'un des environnements de bureau les plus utilisés dans le monde GNU/Linux.

Histoire[modifier | modifier le code]

Ancien logo de Qt

C'est au Norwegian Institute of Technology à Trondheim que Haavard Nord (CEO de Trolltech) et Eirik Chambe-Eng (président de Trolltech) se rencontrent. En 1988, Haavard Nord est chargé par une entreprise suédoise de développer une bibliothèque logicielle en C++ pour gérer une interface graphique, c'est la première fois qu'il commence à aborder le sujet[2]. Deux ans plus tard, avec Chambe-Eng, ils développent une application multi-plateforme (Unix, Macintosh et Windows) et commencent sérieusement à réfléchir à la conception d'une bibliothèque graphique multi-plateforme généraliste.

En 1991, ils entament le développement de cette bibliothèque. L'année suivante, Chambe-Eng propose le principe des « signaux et slots », qui devient la pierre angulaire de Qt. Et en 1993, le noyau de Qt est prêt et permet aux informaticiens de développer leurs propres composants graphiques. C'est à la fin de cette année que Haavard Nord propose de créer une entreprise pour commercialiser leur bibliothèque[2].

Quasar Technologies est créé le 4 mars 1994 et renommé six mois plus tard en Troll Tech, puis Trolltech, puis Qt Software et enfin Qt Development Frameworks. Les débuts sont particulièrement difficiles financièrement. Mais ils ont la chance d'être mariés : leurs femmes subviennent à leurs besoins[2].

Le projet a été nommé Qt parce que le caractère « Q » était joli dans l'écriture Emacs de Haavard, et le « t » provient de Xt Xtoolkit. Le tout se prononçant en anglais cute, ce qui se traduit par « mignon ». Le « t » étant minuscule, ne pas prononcer cutie. Ce n'est pas un sigle (QT)[2].

C'est en avril 1995 que Trolltech a son premier client, l'entreprise norvégienne Metis. Et durant presque un an, elle n'en a pas d'autre, rendant l'entreprise très fragile financièrement. Son second client, l'Agence spatiale européenne (ESA), lui achète dix licences en mars 1996[2].

Qt1[modifier | modifier le code]

Le 26 mai 1995 est annoncée la première version publique de Qt sur le newsgroup comp.os.linux.announce[3]. Et un an plus tard la version 0.97, puis le 24 septembre 1996 la version 1.0 est publiée et annoncée quelques jours plus tard[4].

C'est en 1997 que le projet KDE est lancé par Matthias Ettrich (qui est embauché par Trolltech l'année suivante). Ce dernier prend la décision d'utiliser Qt comme bibliothèque de base. Le fait qu'un projet de cette envergure utilise Qt sera une très bonne publicité pour Trolltech et sa bibliothèque. Depuis, les liens entre Trolltech et KDE n'ont fait que se renforcer.

Qt2[modifier | modifier le code]

La seconde version majeure de Qt est publiée en juin 1999 et une version pour les systèmes embarqués, Qt/Embedded, connue depuis sous le nom de Qtopia, est publiée en 2000. Cette dernière version est conçue pour Linux et utilise directement son framebuffer, sans passer par le système de fenêtrage X11 (qui est inadapté pour les systèmes embarqués)[5].

Qt3[modifier | modifier le code]

Les deux premières versions majeures de Qt sont disponibles uniquement pour X11 et Windows, le support de Mac OS X arrive avec la version 3.0, publiée en 2001. Par rapport à la version 2.0, cette nouvelle version apporte un meilleur support de l'internationalisation, de l'Unicode ou encore des expressions rationnelles comme en Perl.

Qt4[modifier | modifier le code]

Le 28 juin 2005, la version 4 est publiée et améliore notamment le moteur de rendu, désormais appelé Arthur[6], la séparation entre données et présentation et sépare la bibliothèque en modules :

  • QtCore : pour les fonctionnalités non graphiques utilisées par les autres modules ;
  • QtGui : pour les composants graphiques ;
  • QtNetwork : pour la programmation réseau ;
  • QtOpenGL : pour l'utilisation d'OpenGL ;
  • QtSql : pour l'utilisation de base de données SQL ;
  • QtXml : pour la manipulation et la génération de fichiers XML ;
  • QtDesigner : pour étendre les fonctionnalités de Qt Designer, l'assistant de création d'interfaces graphiques ;
  • QtAssistant : pour l'utilisation de l'aide de Qt [7];
  • Qt3Support : pour assurer la compatibilité avec Qt 3.

À cela s'ajoute pour la version commerciale sous Windows deux autres modules liés à l'utilisation d'ActiveX : QAxContainer et QAxServer.

Avec l'évolution de Qt 4, d'autres modules sont conçus :

  • QtDBus : pour la communication inter-processus en utilisant D-Bus (uniquement sous Unix à partir de Qt 4.2) ;
  • QtSvg : pour l'affichage d'images au format SVG (à partir de Qt 4.1) ;
  • QtUiTools : pour charger dynamiquement les interfaces graphiques créées avec Qt Designer (à partir de Qt 4.1) ;
  • QtTest : pour effectuer des tests unitaires (à partir de Qt 4.1) ;
  • QtScript : pour l'évaluation de scripts utilisant Qt Script (à partir de Qt 4.3) ;
  • QtWebKit : portage du moteur de rendu web WebKit (à partir de Qt 4.4) ;
  • QtXmlPatterns : pour manipuler des documents XML via XQuery et XPath (à partir de Qt 4.4) ;
  • Phonon : intégration de Phonon, framework multimédia de KDE 4, développé en collaboration avec la communauté KDE (à partir de Qt 4.4) ;
  • QtHelp : remplace le module QtAssistant en permettant d'utiliser le format d'aide de Qt au sein des applications (à partir de Qt 4.4) ;
  • QtScriptTools : divers outils pour QtScript comme un débogueur (à partir de Qt 4.5) ;
  • QtMultimedia : diverses classes offrant des fonctionnalités multimédia de bas niveau comparées à Phonon (à partir de Qt 4.6) ;
  • QtOpenVG : permet d'utiliser, si elle est présente, l'accélération matérielle d'OpenVG pour les images vectorielles en 2D (à partir de Qt 4.6) ;
  • QtDeclarative : permet la conception d'interfaces graphiques dynamiques à l'aide d'un langage déclaratif (QML) (à partir de Qt 4.7).

Le 28 janvier 2008, Nokia lance une OPA amicale pour racheter Qt et Trolltech. Trolltech, renommé en Qt Software, devient une division de Nokia. Dès lors, Nokia prend la décision en janvier 2009 d'abaisser le maximum de barrières pour faciliter l'adoption de Qt, qui depuis est utilisé par leurs développements en interne :

  • ajout d'une licence plus permissive que la GPL, la LGPL ;
  • ouverture du développement à des développeurs externes en rendant accessible le dépôt de Qt[8].

Nokia se recentrant sur Windows, elle cède en mars 2011 l'activité services et gestion des licences commerciales de Qt à la société Digia [9]. Le 9 août 2012, elle cède intégralement la gestion du framework Qt à Digia [10] pour une somme de 4,9 millions € (à comparer au 150 millions de 2008[11]). Digia annonce vouloir étendre le support de Qt à Android, iOS et Windows 8.

Qt5[modifier | modifier le code]

Qt 5.0 est sorti le 19 décembre 2012[12]. Bien que marquant des changements majeurs sur bien des points (rôle important de QML et de JavaScript pour la création des interfaces graphiques avec Qt Quick, séparation en modules indépendants pour faciliter les livraisons, couche d'abstraction pour faciliter les portages, etc.), le passage à Qt5 casse au minimum la compatibilité au niveau des sources. De cette façon, le passage est bien plus facile que pour Qt4.

Qt Quick[modifier | modifier le code]

Qt Quick est un framework libre développé et maintenu par Digia faisant partie de la bibliothèque Qt. Il fournit la possibilité de créer des interfaces utilisateur personnalisables et dynamiques avec des effets de transition fluides de manière déclarative. Ce type d'interface dynamique est de plus en plus commune, notamment sur les smartphones. Qt Quick inclut un langage de script déclaratif appelé QML comparable au XAML créé par Microsoft pour sa bibliothèque WPF.

Qt Quick et QML sont officiellement supportés depuis Qt 4.7 (avec Qt Creator 2.1).

Licences[modifier | modifier le code]

Le projet d'environnement graphique KDE a dès le début utilisé la bibliothèque Qt. Mais avec le succès de cet environnement, une certaine partie de la communauté du logiciel libre a critiqué la licence de Qt qui était propriétaire et incompatible avec la GNU GPL utilisée par KDE. Ce problème fut résolu par la société Trolltech qui mit les versions GNU/Linux et UNIX de Qt sous licence GNU GPL lorsque l'application développée était également sous GNU GPL. Pour le reste, c'est la licence commerciale qui entre en application. Cette politique de double licence a été appliquée uniquement pour GNU/Linux et UNIX dans un premier temps, mais depuis la version 4.0 de Qt, elle est appliquée pour tous les systèmes.

Créé en juin 1998, la fondation KDE Free Qt Foundation est chargée de s'assurer de la disponibilité de Qt pour le développement de logiciels libres. Dans le cadre d'un accord avec Trolltech, cette fondation a le droit de diffuser Qt sous une licence de style BSD dans le cas où Trolltech cesserait le développement de la version libre pour diverses raisons, y compris un dépôt de bilan[13]. Le rachat de Trolltech par Nokia le 28 janvier 2008 ne remet pas en cause la politique de double licence, l'entreprise finlandaise soutient même KDE[14].

Le 18 janvier 2008, Trolltech annonce que la version 3 et 4 de Qt sont à partir de cette date sous licence GPLv2 et GPLv3. Ce changement de version ne s'applique que pour les versions libres de Qt. Ainsi la version 3 de Qt pour Windows, qui n'est pas libre, ne voit pas sa licence changer[15]. Ce changement s'inscrit dans le désir de KDE de passer également en version 3 de la GPL, en plus de la version 2 déjà utilisée[16].

Un an plus tard, le 14 janvier 2009, Trolltech annonce qu'à partir de Qt 4.5, Qt sera également disponible sous licence LGPL v2.1[17]. Cette nouvelle licence permet ainsi des développements de logiciels propriétaires, sans nécessiter l'achat d'une licence commerciale auprès de Qt Development Frameworks. Ce changement, voulu par Nokia pour faire en sorte que Qt soit utilisé par un maximum de projets, est rendu possible par le fait que Nokia peut se passer des ventes des licences commerciales, contrairement à Trolltech qui ne pouvait pas se passer de cette source de revenus[8].

Architecture[modifier | modifier le code]

Structure générale[modifier | modifier le code]

L'API Qt est constituée de classes aux noms préfixés par Q et dont chaque mot commence par une majuscule (ex: QLineEdit), c'est la typographie CamelCase. Ces classes ont souvent pour attributs des types énumérés déclarés dans l'espace de nommage Qt[18]. Mis à part une architecture en pur objet, certaines fonctionnalités basiques sont implémentées par des macros (chaîne de caractères à traduire avec tr, affichage sur la sortie standard avec qDebug...).

Les conventions de nommage des méthodes sont assez semblables à celles de Java : le lowerCamelCase est utilisé, c'est-à-dire que tous les mots sauf le premier prennent une majuscule (ex: indicatorFollowsStyle()), les modificateurs sont précédés par set, en revanche les accesseurs prennent simplement le nom de l'attribut (ex : text()) ou commencent par is dans le cas des booléens (ex : isChecked()).

Arborescence des objets[modifier | modifier le code]

Les objets Qt (ceux héritant de QObject) peuvent s'organiser d'eux-mêmes sous forme d'arbre. Ainsi, lorsqu'une classe est instanciée, on peut lui définir un objet parent. Cette organisation des objets sous forme d'arbre facilite la gestion de la mémoire car avant qu'un objet parent ne soit détruit, Qt appelle récursivement le destructeur de tous les enfants [19].

Cette notion d'arbre des objets permet également de débugger plus facilement, via l'appel de méthodes comme QObject::dumpObjectTree() et Object::dumpObjectInfo() [19].

Compilateur de meta-objets[modifier | modifier le code]

Le moc[20] (pour Meta Object Compiler) est un préprocesseur qui, appliqué avant compilation du code source d'un programme Qt, génère des meta-informations relatives aux classes utilisées dans le programme. Ces meta-informations sont ensuite utilisées par Qt pour fournir des fonctions non disponibles en C++, comme les signaux et slots et l'introspection.

L'utilisation d'un tel outil additionnel démarque les programmes Qt du langage C++ standard. Ce fonctionnement est vu par Qt Development Frameworks comme un compromis nécessaire pour fournir l'introspection et les mécanismes de signaux. À la sortie de Qt 1.x, les implémentations des templates par les compilateurs C++ n'étaient pas suffisamment homogènes[21].

Signaux et slots[modifier | modifier le code]

Article détaillé : Signaux et slots.

Les signaux et slots sont une implémentation du patron de conception observateur. L'idée est de connecter des objets entre eux via des signaux qui sont émis et reçus par des slots. Du point de vue du développeur, les signaux sont représentés comme de simples méthodes de la classe émettrice, dont il n'y a pas d'implémentation. Ces "méthodes" sont par la suite appelées, en faisant précéder "emit", qui désigne l'émission du signal. Pour sa part, le slot connecté à un signal est une méthode de la classe réceptrice, qui doit avoir la même signature (autrement dit les mêmes paramètres que le signal auquel il est connecté), mais à la différence des signaux, il doit être implémenté par le développeur. Le code de cette implémentation représente les actions à réaliser à la réception du signal.

C'est le MOC qui se charge de générer le code C++ nécessaire pour connecter les signaux et les slots.

Concepteur d'interface[modifier | modifier le code]

Qt Designer, le concepteur d'interface

Qt Designer est un logiciel qui permet de créer des interfaces graphiques Qt dans un environnement convivial. L'utilisateur, par glisser-déposer, place les composants d'interface graphique et y règle leurs propriétés facilement. Les fichiers d'interface graphique sont formatés en XML et portent l'extension .ui [22].

Lors de la compilation, un fichier d'interface graphique est converti en classe C++ par l'utilitaire uic. Il y a plusieurs manières pour le développeur d'employer cette classe [23] :

  • l'instancier directement et connecter les signaux et slots
  • l'agréger au sein d'une autre classe
  • l'hériter pour en faire une classe mère et ayant accès ainsi à tous les éléments constitutifs de l'interface créée
  • la générer à la volée avec la classe QUiLoader qui se charge d'interpréter le fichier XML .ui et retourner une instance de classe QWidget

qmake[modifier | modifier le code]

Qt se voulant un environnement de développement portable et ayant le MOC comme étape intermédiaire avant la phase de compilation/édition de liens, il a été nécessaire de concevoir un moteur de production spécifique. C'est ainsi qu'est conçu le programme qmake.

Ce dernier prend en entrée un fichier (avec l'extension .pro) décrivant le projet (liste des fichiers sources, dépendances, paramètres passés au compilateur, etc.) et génère un fichier de projet spécifique à la plateforme. Ainsi, sous les systèmes UNIX qmake produit un Makefile qui contient la liste des commandes à exécuter pour génération d'un exécutable, à l'exception des étapes spécifiques à Qt (génération des classes C++ lors de la conception d'interface graphique avec Qt Designer, génération du code C++ pour lier les signaux et les slots, ajout d'un fichier au projet, etc.).

Le fichier de projet est fait pour être très facilement éditable par un développeur. Il consiste en une série d'affectations de variables. En voici un exemple pour un petit projet:

TARGET = monAppli
SOURCES = main.cpp mainwindow.cpp
HEADERS = mainwindow.h
FORMS = mainwindow.ui
QT += sql

Ces déclarations demandent que l'exécutable soit nommé monAppli, donne la liste des fichiers sources, en-têtes et fichiers d'interface graphique. La dernière ligne déclare que le projet requiert le module SQL de Qt.

Internationalisation[modifier | modifier le code]

Qt intègre son propre système de traduction, qui n'est pas foncièrement différent dans le principe de la bibliothèque gettext. Selon le manuel de Qt Linguist, l'internationalisation est assurée par la collaboration de trois types de personnes : les développeurs, le chef de projet et les traducteurs [24].

Dans leur code source, les développeurs entrent des chaînes de caractères dans leur propre langue. Ils doivent permettre la traduction de ces chaînes grâce à la méthode tr(). En cas d'ambiguïté sur le sens d'une expression, ils peuvent également indiquer des commentaires destinés à aider les traducteurs.

Le chef de projet déclare les fichiers de traduction (un pour chaque langue) dans le fichier de projet. L'utilitaire lupdate parcourt les sources à la recherche de chaînes à traduire et synchronise les fichiers de traduction avec les sources. Les fichiers de traductions sont des fichiers XML portant l'extension .ts.

Les traducteurs utilisent Qt Linguist pour renseigner les fichiers de traduction. Quand les traductions sont finies, le chef de projet peut compiler les fichiers .ts à l'aide de l'utilitaire lrelease qui génère des fichiers binaires portant l'extension .qm, exploitables par le programme. Ces fichiers sont lus à l'exécution et les chaînes de caractères qui y sont trouvées remplacent celles qui ont été écrites par les développeurs.

Style[modifier | modifier le code]

La bibliothèque embarque divers thèmes de widgets qui lui donnent une bonne intégration visuelle sur toutes les plateformes. Sur les environnements de bureau GNOME, Mac OS X et Windows les applications Qt ont ainsi l'apparence d'applications natives.

Qt permet de personnaliser l'apparence des différents composants d'interface graphique en utilisant le principe des feuilles de style en cascade (CSS) [25].

Outils de développement[modifier | modifier le code]

Qt Development Frameworks fournit un ensemble de logiciels libres pour faciliter le développement d'applications Qt :

  • Qt Designer est un concepteur d'interface graphique, il enregistre les fichiers .ui ;
  • Qt Assistant permet de visualiser la documentation complète de Qt hors-ligne ;
  • Qt Linguist est un outil dédié aux traducteurs, il leur permet d'ouvrir les fichiers .ts qui contiennent les chaînes de caractères à traduire, et d'entrer ensuite leur traduction ;
  • Qt Creator est l'environnement de développement intégré dédié à Qt et facilite la gestion d'un projet Qt. Son éditeur de texte offre les principales fonctions que sont la coloration syntaxique, le complètement, l'indentation, etc. Qt Creator intègre en son sein les outils Qt Designer et Qt Assistant ;
  • Qt Demo présente un ensemble de petits programmes (sous forme d'exécutables et de sources) qui montrent les fonctionnalités offertes par la bibliothèque.
  • Qt Installer Framework est un outil permettant de créer facilement des programmes d'installations.

Même si Qt Creator est présenté comme l'environnement de développement de référence pour Qt, il existe des modules Qt pour les environnements de développement Eclipse[26] et Visual Studio [27]. Il existe d'autres EDI dédiés à Qt et développés indépendamment de Nokia, comme QDevelop et Monkey Studio.

Bindings[modifier | modifier le code]

Des bindings existent afin de pouvoir utiliser Qt avec d'autres langages que le C++. Ainsi les langages Java (Qt Jambi [28]), Python (PyQt, PySide, PythonQt), Ruby (QtRuby), Ada (QtAda), C# (Qyoto), Pascal (FreePascal Qt4), Perl (Perl Qt4), Haskell (Qt Haskell), Lua (lqt, QtLua), Dao (DaoQt), Tcl (qtcl), Common Lisp (CommonQt), D (QtD) peuvent être utilisés.

Utilisations[modifier | modifier le code]

Voir la catégorie : Logiciel utilisant Qt.

De plus en plus de développeurs utilisent Qt, y compris parmi de grandes entreprises. On peut notamment citer : Google, Adobe Systems, Skype ou encore la NASA. Le site de Digia recense les entreprises utilisant Qt et les applications basées sur Qt[29].

Syntaxe[modifier | modifier le code]

Le classique "Hello World" dans différents langages : C++, Java (avec QtJambi), Python (avec PyQt et PySide) et C# (avec Qyoto) :

C++[modifier | modifier le code]

#include <QApplication>
#include <QPushButton>
 
int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    QPushButton hello("Hello world!");
    hello.show();
    return app.exec();
}

Java (QtJambi)[modifier | modifier le code]

import com.trolltech.qt.gui.QApplication;
import com.trolltech.qt.gui.QPushButton;
 
public class HelloWorld
{
    public static void main(String args[])
    {
        QApplication.initialize(args);
        QPushButton hello = new QPushButton("Hello World!");
        hello.show();
        QApplication.exec();
    }
}

Python (PyQt)[modifier | modifier le code]

from PyQt4 import QtGui, QtCore
import sys
 
app = QtGui.QApplication(sys.argv)
hello = QtGui.QPushButton("Hello World!", None)
hello.show()
app.exec_()

Python (PySide)[modifier | modifier le code]

from PySide import QtGui
import sys
 
app = QtGui.QApplication(sys.argv)
hello = QtGui.QPushButton("Hello World!", None)
hello.show()
app.exec_()

C# (Qyoto)[modifier | modifier le code]

using System;
using Qyoto;
 
public class HelloWorld 
{
    public static int Main(String[] args) {
        QApplication app = new QApplication(args);
        QPushButton hello = new QPushButton("Hello world!");
        hello.Show();
        return QApplication.Exec();
    }
}

Communautés francophones[modifier | modifier le code]

  • (fr) Qt.Developpez.com (traduction de la documentation, FAQ, tutoriels, forums, binaires, défis...).

Notes et références[modifier | modifier le code]

  1. (en) Christian D. Kamm, « Prononciation de Qt lors de la release du SDK 1.1 », Qt Studio,‎ 27 avril 2011 (consulté le 3 août 2011)
  2. a, b, c, d et e (en) Jasmin Blanchette et Mark Summerfield, C++ GUI Programming with Qt 4, Prentice Hall,‎ 21 juin 2006, 560 p. (ISBN 978-0-13-187249-3, lire en ligne), « A Brief History of Qt »
  3. (en) « Beta of Motif-like C++ library available », Trolltech,‎ 26 mai 1995 (consulté le 13 décembre 2007)
  4. (en) « Qt 1.0 released (c++ gui library) », Trolltech,‎ 1er octobre 1996 (consulté le 13 décembre 2007)
  5. (en) « Qtopia Core », Trolltech,‎ 2007 (consulté le 7 janvier 2008)
  6. Documentation en ligne Qt
  7. ce module, considéré comme obsolète, disparait dans Qt 4.6. La seule classe qui en fait partie reste présente pour des raisons de compatibilité
  8. a et b Aaron Seigo, « Qt goes LGPL! »,‎ 14 janvier 2009 (consulté le 14 janvier 2009)
  9. Nokia cède la gestion des licences Qt à Digia
  10. http://www.digia.com/en/Home/Company/News/Digia-to-acquire-Qt-from-Nokia/
  11. Digia to pay Nokia €4 million for Qt as framework heads towards cross-platform future
  12. http://qt-project.org/wiki/Qt_5.0
  13. (fr) « KDE Free Qt Foundation », KDE (consulté le 28 janvier 2008)
  14. (en) « Open letter to KDE and the Open Source community - Joint announcement », Trolltech et Nokia,‎ 28 janvier 2008 (consulté le 28 janvier 2008)
  15. (en) « Trolltech releases Qt under the GPL v3 license », Trolltech,‎ 18 janvier 2008 (consulté le 19 janvier 2008)
  16. (fr) « Projects/KDE Relicensing », KDE (consulté le 19 janvier 2008)
  17. (en). « LGPL License Option Added to Qt », Trolltech,‎ 14 janvier 2009 (consulté le 14 janvier 2009)
  18. http://doc.trolltech.com/qq/qq13-apis.html
  19. a et b (en) « Object Trees and Object Ownership », Qt Development Frameworks,‎ 2009 (consulté le 18 juin 2009)
  20. (fr) Utilisation du moc
  21. (en) Pourquoi Qt n'utilise pas les templates pour les signaux et les slots ?
  22. (en) « Qt Designer's UI File Format », Qt Development Frameworks,‎ 2009 (consulté le 17 juin 2009)
  23. (en) « Using a Designer .ui File in Your Application », Qt Development Frameworks,‎ 2009 (consulté le 17 juin 2009)
  24. (en) « Qt Linguist Manual », Qt Development Frameworks,‎ 2009 (consulté le 23 juin 2009)
  25. (en) « Qt Style Sheets », Qt Development Frameworks,‎ 2009 (consulté le 23 juin 2009)
  26. (en) « Qt Eclipse Integration for C++ », Qt Development Frameworks,‎ 2009 (consulté le 23 juin 2009)
  27. (en) « Qt Visual Studio .NET Integration », Qt Development Frameworks,‎ 2008 (consulté le 23 juin 2009)
  28. initialement développé par Qt Development Frameworks, le support de ce binding est abandonné en février 2009 et sa maintenance est laissée à la communauté suite à la libération du code source
  29. (en) Qt in Action

Voir aussi[modifier | modifier le code]

Sur les autres projets Wikimedia :

Autres bibliothèques généralistes multiplateformes 
  • GTK+, utilisée par l'environnement graphique GNOME
  • wxWidgets, utilisée notamment par aMule
  • Qt Extended, version embarquée de Qt

Liens externes[modifier | modifier le code]