diff options
| author | Timothy Pearson <kb9vqf@pearsoncomputing.net> | 2011-12-18 03:08:08 -0600 |
|---|---|---|
| committer | Timothy Pearson <kb9vqf@pearsoncomputing.net> | 2011-12-18 03:08:08 -0600 |
| commit | bcc95cd92ca12c1783464b8ada6816d430dc0e98 (patch) | |
| tree | 4701c447365db5392df0174b4bb00b5b5c369da4 /doc/fr/index.html | |
| download | libtqt-perl-bcc95cd92ca12c1783464b8ada6816d430dc0e98.tar.gz libtqt-perl-bcc95cd92ca12c1783464b8ada6816d430dc0e98.zip | |
Initial import of libqt-perl (not yet TQt compatible)
Diffstat (limited to 'doc/fr/index.html')
| -rw-r--r-- | doc/fr/index.html | 1120 |
1 files changed, 1120 insertions, 0 deletions
diff --git a/doc/fr/index.html b/doc/fr/index.html new file mode 100644 index 0000000..2f5e788 --- /dev/null +++ b/doc/fr/index.html @@ -0,0 +1,1120 @@ +<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> +<html xmlns="http://www.w3.org/1999/xhtml"> +<head> +<title>Programmer avec PerlQt</title> +<link rel="stylesheet" href="../css/pod.css" type="text/css" /> +<link rev="made" href="mailto:root@localhost" /> +</head> + +<body> + +<p><a name="__index__"></a></p> +<!-- INDEX BEGIN --> + +<ul> + + <li><a href="#programmer_avec_perlqt">Programmer avec PerlQt</a></li> + <li><a href="#introduction">Introduction</a></li> + <li><a href="#installation">Installation</a></li> + <ul> + + <li><a href="#conditions_requises">Conditions requises</a></li> + <li><a href="#compilation_de_perlqt">Compilation de PerlQt</a></li> + <li><a href="#installation_avec_les_droits_d'utilisateur">Installation avec les droits d'utilisateur</a></li> + </ul> + + <li><a href="#anatomie_de_perlqt">Anatomie de PerlQt</a></li> + <ul> + + <li><a href="#hello_world">Hello World</a></li> + <li><a href="#l'héritage_et_les_objets">L'héritage et les objets</a></li> + <ul> + + <li><a href="#un_widget_personnalisé">Un Widget personnalisé</a></li> + <li><a href="#l'utilisation_d'attributs">L'utilisation d'attributs</a></li> + </ul> + + <li><a href="#signaux_et_slots">Signaux et Slots</a></li> + </ul> + + <li><a href="#développement_rapide_(rad)_avec_qt_designer_et_puic">Développement rapide (RAD) avec Qt Designer et Puic</a></li> + <ul> + + <li><a href="#introduction">Introduction</a></li> + <li><a href="#inclure_des_images">Inclure des Images</a></li> + <li><a href="#travailler_avec_des_fichiers_.ui">Travailler avec des fichiers <strong>.ui</strong></a></li> + </ul> + + <li><a href="#autres_outils_de_développement">Autres outils de développement</a></li> + <ul> + + <li><a href="#pqtapi">pqtapi</a></li> + <li><a href="#pqtsh">pqtsh</a></li> + </ul> + + <li><a href="#limitations">Limitations</a></li> + <li><a href="#crédits">Crédits</a></li> + <li><a href="#appendice:_les_conventions_de_c++_et_leur_traduction_en_perl">Appendice: Les conventions de C++ et leur traduction en Perl</a></li> + <li><a href="#annexe_2_:_internationalisation">Annexe 2 : Internationalisation</a></li> + <ul> + + <ul> + + <li><a href="#désactiver_l'encodage_utf8">désactiver l'encodage utf8</a></li> + </ul> + + </ul> + + <li><a href="#annexe_3_:_canaux_de_déboguage">Annexe 3 : Canaux de déboguage</a></li> + <li><a href="#annexe_4_:_marshalleurs">Annexe 4 : Marshalleurs</a></li> +</ul> +<!-- INDEX END --> + +<hr /> +<p> +</p> +<h1><a name="programmer_avec_perlqt">Programmer avec PerlQt</a></h1> +<p><strong>Germain Garand</strong> traduit par <strong>Stéphane Payrard</strong>, révisé et augmenté par l'auteur.</p> +<p>Ce document décrit l'interface Perl au toolkit Qt 3.x. Contacter +l'auteur à <<a href="mailto:germain@ebooksfrance.com">germain@ebooksfrance.com</a>> ou le traducteur à +<<a href="mailto:stef@mongueurs.net">stef@mongueurs.net</a>>. Vous trouverez le document original sur le site +<a href="http://perlqt.sourceforge.net">perlqt.sourceforge.net</a></p> +<p> +</p> +<hr /> +<h1><a name="introduction">Introduction</a></h1> +<p>PerlQt-3, crée par Ashley Winters, est une interface perl aux composants +graphiques (et non graphiques) fournis par Qt3.</p> +<p>Le toolkit Qt 3.0 auquel PerlQt accède à été écrit en C++ par la société +Trolltech: <a href="http://www.trolltech.com">Trolltech</a>.</p> +<p>PerlQt3 est fondé sur la librairie +<a href="http://webcvs.kde.org/cgi-bin/cvsweb.cgi/kdebindings/smoke">SMOKE</a>, +une surcouche fine indépendante du langage. Cette couche a été générée +à partir des fichiers d'en tête de Qt par le +<a href="http://webcvs.kde.org/cgi-bin/cvsweb.cgi/kdebindings/kalyptus">kalyptus</a> +de Richard Dale grâce au module de David Faure.</p> +<p>Le présent document décrit les principes de la programmation PerlQt. +Vous devez avoir des notions de programmation orientée objet en Perl pour le +lire. Une connaissance de C++ est recommandée mais non requise. Avec +celle de l'anglais, elle vous facilitera la consultation des <a href="http://doc.trolltech.com">manuels en ligne de Qt</a>. Ladite documentation est +la seule référence qui fasse autorité.</p> +<p>Si Qt est installé sur votre système, sa documentation l'est +certainement aussi : voyez le programme $QTDIR/bin/assistant.</p> +<p> +</p> +<hr /> +<h1><a name="installation">Installation</a></h1> +<p> +</p> +<h2><a name="conditions_requises">Conditions requises</a></h2> +<p>Pour compiler et utiliser PerlQt, vous devez avoir:</p> +<ul> +<li></li> +un système conforme à la norme POSIX. +<p></p> +<li></li> +<a href="http://www.perl.org">Perl >= v5.6.0</a> +<p></p> +<li></li> +<a href="http://www.trolltech.com/developer/download/qtx11.html">Qt >= v3.0</a> +<p></p> +<li></li> +<a href="http://webcvs.kde.org/cgi-bin/cvsweb.cgi/kdebindings/smoke">SmokeQt 1.2.1</a> La +librarie SMOKE (Scripting Meta Object Kompiler) fait partie du module +<a href="http://www.kde.org">KDE</a>'s <strong>kdebindings</strong>. Vous pouvez vérifier si +une version précompilée de ce module existe pour votre système. Mais +perlQt inclut une copie, donc la version précompilée n'est pas +nécessaire. +<p></p> +<li></li> +Les outils GNU : automake(>=1.5), autoconf (>=2.13), aclocal... +<p></p></ul> +<p>L'installation de Perl et de Qt sont en dehors du sujet du présent +document. Se référer aux documentations respectives de ces logiciels.</p> +<p> +</p> +<h2><a name="compilation_de_perlqt">Compilation de PerlQt</a></h2> +<p>Les instructions de cette section présupposent que le répertoire courant est +le répertoire racine de l'arborescence des sources de PerlQt.</p> +<p>PerlQt utilise le système GNU Autoconf, mais il est préférable de le lancer via +le script standard <code>Makefile.PL</code> :</p> +<pre> + perl Makefile.PL</pre> +<p><strong>N.B :</strong> Si la variable d'environnement <strong>QTDIR</strong> n'est pas définie, vous devrez +peut-être spécifier manuellement l'emplacement de Qt à l'aide de l'option :</p> +<pre> + --with-qtdir=/emplacement/de/Qt</pre> +<p>Si la bibliothèque SMOKE est manquante, <code>configure</code> générera ses sources dans +un sous-répertoire.</p> +<pre> + make</pre> +<pre> + make install</pre> +<p>Cela installera PerlQt, Puic et les utilitaires pqtsh et pqtapi.</p> +<p>Le lieu d'installation privilégié de SMOKE et de PUIC est le système de +fichiers de KDE3. Si KDE3 n'est pas installé (ou que la variable KDEDIR n'est pas +définie), spécifier ce lieu avec l'option <code>--prefix</code> de <code>configure</code>'s. Ainsi :</p> +<pre> + perl Makefile.PL --prefix=/usr</pre> +<p> +</p> +<h2><a name="installation_avec_les_droits_d'utilisateur">Installation avec les droits d'utilisateur</a></h2> +<p>Pour réaliser une installation locale, sans les droits de super-utilisateur, +suivez les instructions suivantes :</p> +<ul> +<li></li> +Réalisez tout d'abord une configuration normale, en spécifiant le préfixe de la hiérarchie de fichier +dans laquelle la bibliothèque Smoke et l'exécutable 'puic' seront installés : +<pre> + perl Makefile.PL --prefix=~</pre> +<p>Ceci installera Smoke dans ~/lib et puic dans ~/bin</p> +<p></p> +<li></li> +Reconfigurez le module PerlQt pour qu'il ne s'installe pas dans la hiérarchie Perl ordinaire : +<pre> + cd PerlQt + perl Makefile.PL PREFIX=~ + cd ..</pre> +<p>Attention : il ne s'agit pas du Makefile.PL situé à la racine de l'arborescence mais bien de celui +situé dans le sous-répertoire PerlQt</p> +<p></p> +<li></li> +Lancez la compilation et l'installation +<pre> + make && make install</pre> +<p>Pour exécuter des programmes PerlQt, il vous faudra désormais indiquer à Perl l'emplacement de cette hiérarchie externe, +à l'aide d'une ligne de la forme :</p> +<pre> + perl -Mlib="~/local/lib/perl/5.x.x" programme.pl</pre> +<p>où 5.x.x représente la version de Perl utilisée, ligne qui peut également être placée en tête de programme :</p> +<pre> + use lib qw( ~/local/lib/perl/5.x.x );</pre> +<p></p></ul> +<p> +</p> +<hr /> +<h1><a name="anatomie_de_perlqt">Anatomie de PerlQt</a></h1> +<p>Un programme Qt typique utilisant des composants GUI est fondé sur une +boucle événementielle.</p> +<p>Il ne se comporte pas comme une suite séquentielle +d'instructions où vous devriez gérer vous-même chaque événement (tels +que le clic de la souris ou l'enfoncement d'une touche).</p> +<p>Au lieu de cela, vous créez un objet <strong>Qt::Application</strong> et les composants +du GUI qu'il utilise, puis vous définissez les méthodes d'objet à appeler +lors de l'occurrence d'un événement, puis démarrez la boucle événementielle.</p> +<p>C'est tout. Qt gérera les événements et les dirigera vers les +routines appropriées.</p> +<p>Voyons un programme PerlQt minimal.</p> +<p> +</p> +<h2><a name="hello_world">Hello World</a></h2> +<pre> + 1: use Qt; + 2: my $a = Qt::Application(\@ARGV); + 3: my $hello = Qt::PushButton("Hello World!", undef); + 4: $hello->resize(160, 25); + 5: $a->setMainWidget($hello); + 6: $hello->show; + 7: exit $a->exec;</pre> +<br/> +<div class='image'><img src="../images/ex1.png"/></div><p>Ce programme charge d'abord le module Qt [line 1] puis crée l'objet +application <strong>$a</strong> en lui passant une référence au tableau <code>@ARGV</code> +contenant les arguments de la ligne de commande [l.2]. Cet objet +application est unique pour un interpréteur Perl donné et peut être +ensuite accédé par la fonction pure <strong>Qt::app()</strong>.</p> +<p>La ligne 3, crée un PushButton orphelin (c.à.d sans parent: non +contenu dans un autre widget) dont nous passons la valeur <strong>undef</strong> +comme argument pour le parent. <strong>undef</strong> est l'équivalent perlQt d'un +pointeur null en C++.</p> +<p>Après les instructions de ``mise en page'' [l.4], nous indiquons à +l'objet application que le widget principal est ce +PushButton... Ainsi, il saura que fermer la fenêtre associée à ce +widget signifie: <em>sortir de l'application</em>.</p> +<p>Pour rendre ce widget visible (qui est par défaut caché), on +appelle la méthode <strong>show</strong> [l.6] et lance la boucle +événementielle [l.7].</p> +<p><strong>Sommaire de la syntaxe :</strong></p> +<ol> +<li></li> +Les classes PerlQt sont accessibles par le préfixe <strong>Qt::</strong> au lieu du +<strong>Q</strong> initial des classes Qt en C++. En consultant la <a href="http://doc.trolltech.com">documentation Qt</a>, vous devez donc mentalement changer le +nom d'une clasee <strong>QFoo</strong> en <strong>Qt::Foo</strong>. +<p></p> +<li></li> +De manière similaire à C++, un objet est créé par l'appel d'un +<strong>constructeur</strong> de même nom que la classe dont il est une méthode. +<p>Vous ne devez donc pas dire <code>new Qt::Foo</code> ou <code>Qt::Foo->new()</code> +contrairement à l'usage commun en Perl.</p> +<p>Dites simplement:</p> +<pre> + my $object = Qt::<classname>(arg_1, ..., arg_n);</pre> +<p>Un constructeur sans argument s'énonce encore plus brièvement :</p> +<pre> + my $object = Qt::<classname>;</pre> +<p></p> +<li></li> +Comme il a déjà été dit, l'équivalent Perl d'un pointeur C++ est le mot-clé +Perl <strong>undef</strong>. +<p>Les pointeurs sont les arguments précédés par le caractère <strong>*</strong> dans la +documentation Qt (Par exemple: ``<code>QWidget* widget</code>'').</p> +<p></p></ol> +<p> +</p> +<h2><a name="l'héritage_et_les_objets">L'héritage et les objets</a></h2> +<p>Avant d'expliquer comment les routines Perl peuvent être appelées de Qt, +parlons du mécanisme d'héritage vu de PerlQt.</p> +<p>PerlQt est conçu pour allier la simplicité de Qt à la puissance et à la +flexibilité de Perl. Pour ce faire, PerlQt étend le paradigme objet de +Perl pour mimer Qt et son mécanisme de <strong>métaobjets</strong>.</p> +<p> +</p> +<h3><a name="un_widget_personnalisé">Un Widget personnalisé</a></h3> +<p>Réécrivons le programme ``Hello World!'' avec une version personnalisée +de PushButton:</p> +<pre> + 1: use strict; + 2: + 3: package Button; + 4: use Qt; + 5: use Qt::isa qw(Qt::PushButton); + 6: + 7: sub NEW + 8: { + 9: shift->SUPER::NEW(@_[0..2]); + 10: resize(130, 40); + 11: } + 12: + 13: 1; + 14: + 15: package main; + 16: + 17: use Qt; + 18: use Button; + 19: + 20: my $a = Qt::Application(\@ARGV); + 21: my $w = Button("Hello World!", undef); + 22: $a->setMainWidget($w); + 23: $w->show; + 24: exit $a->exec;</pre> +<p>Pour implanter notre propre version de PushButton, nous créons un nouveau +package [l.3] et importons Qt [l.4].</p> +<p>Nous utilisons le pragma <code>Qt::isa</code> [l.5] pour déclarer notre widget +comme sous-classe de PushButton. Ce pragma accepte une liste de une ou +plusieurs classes dont dérive la classe à définir.</p> +<p>Créons maintenant un constructeur pour notre nouveau widget +en écrivant une routine appelée <strong>NEW</strong> <em>(notez les majuscules qui +marquent une méthode différente du constructeur ``new'' usuel)</em>. +Le constructeur PerlQt est appelé <strong>implicitement</strong> <em>comme ligne 21</em>.</p> +<p>Note widget doit d'abord appeler le constructeur de sa classe de base +(ici: Qt::PushButton) à la ligne 9, avec tous les arguments que nous +avons reçus.</p> +<p>Nous créons ainsi un objet instance de notre classe. Cette objet est +accessible par la fonction <strong>this</strong> (Attention: ce n'est pas la +variable <code>$this</code> mais simplement <code>this</code>).</p> +<p>Chaque fois que nous invoquons une méthode à partir de notre package +nous pouvons écrire indifféremment <code>method()</code> ou +<code>this->method()</code>;</p> +<p> +</p> +<h3><a name="l'utilisation_d'attributs">L'utilisation d'attributs</a></h3> +<p>Lors de la construction d'un objet composite, vous pouvez simplement créer +ses différents composants à l'intérieur de variables de scope lexical +(c.à.d déclarées par <strong>my</strong>) puisque les widgets sont seulement détruits +par leur parent et non nécessairement quand leur conteneur disparaît +du scope.</p> +<p>En d'autres termes, PerlQt utilise un système de comptage de +références pour gérer la destruction des objets.</p> +<p>Souvent cependant, vous souhaiterez accéder aux composants de votre objet depuis +un tout autre endroit que celui où vous l'avez créé (par exemple pour modifier une +légende de bouton dynamiquement). Dans ce cas, la syntaxe traditionnelle de perl +propose de stocker une référence à ces composants dans la table associative (hash) de +l'objet lui-même. Mais cette syntaxe s'avère peu pratique à l'usage et beaucoup +trop libre - il n'y a pas de vérification à la compilation de sorte que vous pouvez +accéder à des clefs non existantes sans déclencher d'erreur.</p> +<p>En lieu et place de cette syntaxe, PerlQt introduit le concept d'<strong>attributs</strong>.</p> +<p>Les attributs sont de simples variables perl, écrites sans le signe dollar initial, et +pouvant contenir toute donnée qui est une propriété de votre objet. +Leur principal avantage est de fournir une syntaxe très rapide et vérifiable à la compilation.</p> +<p>Pour définir et pouvoir utiliser de nouveaux attributs, il suffit d'utiliser +le pragma <code>use Qt::attributes</code>, suivi d'une liste des noms d'attributs souhaités. +Ainsi:</p> +<pre> + 1: use strict; + 2: + 3: package Button; + 4: use Qt; + 5: use Qt::isa qw(Qt::PushButton); + 6: use Qt::attributes qw( + 7: itsTime + 8: pData + 9: ); + 10: + 11: sub NEW + 12: { + 13: shift->SUPER::NEW(@_[0..2]); + 14: itsTime = Qt::Time; + 15: itsTime->start; + 16: pData->{'key'} = " Foo "; + 17: } + 18: + 19: sub resizeEvent + 20: { + 21: setText( "w: ". width() ." h: ". height() . + 22: "\nt: ". itsTime->elapsed . pData->{'key'} ); + 23: } + 24: + 25: 1;</pre> +<br/> +<div class='image'><img src="../images/ex2.png"/></div><p>L'attribut itsTime est déclaré à la ligne 7 et initialisé par un objet <code>Qt::Time</code> +à la ligne 14.</p> +<p>Puisque nous réimplémentons la fonction virtuelle ``resizeEvent'' +[l.19], chaque fois que le widget principal est redimensionné, cette +fonction ``resizeEvent'' sera déclenchée et le texte de notre Button mis +à jour avec les valeurs venant de l'objet [1.21] et les attributs que +nous avons définis [1.22].</p> +<p><strong>Récapitulation</strong></p> +<ul> +<li></li> +Pour hériter d'une classe Qt, un package doit contenir un +pragma <code>use Qt::isa</code>. +<p>Ainsi:</p> +<pre> + use Qt::isa "Qt::widget";</pre> +<p></p> +<li></li> +Le constructeur d'objet est nommé <strong>NEW</strong> et est appelé implicitement. +Vous ne devez donc pas dire: +<pre> + my $o = MyButton->NEW("Hello");</pre> +<p>Mais bien :</p> +<pre> + my $o = MyButton("Hello");</pre> +<p></p> +<li></li> +A l'intérieur d'un package, on accéde l'instance courante par la +fonction <strong>this</strong>. +<p>Quand une fonction membre est appelée, les arguments sont accessibles +par le tableau <strong>@_</strong>, mais le premier élément de <strong>@_</strong> n'est pas une +référence à l'objet contrairement à l'usage commun en Perl.</p> +<p>Vous ne pouvez donc pas dire :</p> +<pre> + sub myMember + { + my $moi = shift; + my $arg = shift; + $arg->doThat($moi); + $moi->doIt; + }</pre> +<p>Écrivez plutôt :</p> +<pre> + sub myMember + { + my $arg = shift; + $arg->doThat(this); + doIt(); + }</pre> +<p>De plus, si vous voulez appeler une méthode dans une classe de base à +partir d'une classe dérivée, utilisez l'attribut spécial SUPER :</p> +<pre> + sub exemple + { + print "Appel de la méthode 'exemple' dans la classe de base"; + SUPER->exemple(@_) + }</pre> +<p>Notez aussi que la construction :</p> +<pre> + this->SUPER::Exemple(@_);</pre> +<p>est possible, mais qu'elle passe l'objet comme premier argument.</p> +<p></p> +<li></li> +Lorsque vous devez stocker dans votre package un objet contenu, vous +devez le définir comme <strong>attribut</strong> : +<pre> + use Qt::attributes qw( + firstAttribute + ... + lastAttribute);</pre> +<p>Il sera alors disponible comme accesseur :</p> +<pre> + firstAttribute = myContainedWidget( this ); + firstAttribute->resize( 100, 100 );</pre> +<p><strong>NB:</strong> Pour ceux qui souhaitent en savoir plus, les attributs sont implémentés +à l'aide de sub lvalue, c'est à dire de fonctions assignables. +En interne, elles ne font que pointer sur la clef de hachage correspondante dans +l'objet <strong>this</strong>, ce qui rend les tournures ``unAttribut->fonction()'' et +``this->{'unAttribut'}->fonction()'' strictement équivalentes +(si ce n'est que la première est vérifiée au moment de la compilation).</p> +<p></p> +<li></li> +Pour réimplémenter une <strong>fonction virtuelle</strong>, créez simplement une +<strong>sub</strong> de même nom que cette fonction. +<p>Les fonctions virtuelles existantes sont marquées comme telles dans +la documentation de Qt (ce sont les méthodes précédées du mot clef ``virtual'').</p> +<p>Vous pouvez visualiser les noms de méthodes virtuelles que Qt tentera d'appeler +dans votre classe en plaçant <code>use Qt::debug qw|virtual|</code> en tête de +votre programme.</p> +<p></p></ul> +<p> +</p> +<h2><a name="signaux_et_slots">Signaux et Slots</a></h2> +<p>Voyons maintenant comment les objets Qt peuvent communiquer entre eux +de manière à ce qu'un événement concernant un objet puisse déclencher +l'exécution d'une routine en un quelconque endroit de votre programme.</p> +<p>Dans d'autres toolkits, les callbacks (appels en retour) sont généralement +utilisés à cet effet. Mais Qt dispose d'un mécanisme beaucoup plus puissant +et plus flexible : les <strong>Signaux et Slots</strong>.</p> +<p>On peut se le représenter comme le cablage entre les composants d'une +chaîne Hi-Fi. Un amplificateur, par exemple, émet des signaux de sortie +sans chercher à savoir si des enceintes lui sont connectées ou non. +Un magnétophone peut attendre un signal sur sa prise d'entrée +pour commencer à enregistrer, et il ne cherchera pas à savoir s'il est +l'unique destinataire de ce signal ou si ce dernier est aussi reçu par un graveur de CD +ou écouté au casque.</p> +<p>Un composant Qt se comporte comme notre amplificateur ou notre +magnétophone. Il a des sorties ou <strong>Signaux</strong> et des entrées ou +<strong>Slots</strong>. Chaque sortie (signal) est connectable à un nombre illimité +d'entrées (slots). La sortie d'un composant peut être potentiellement +branchée à toute entrée d'un composant (y compris lui-même),</p> +<p>La syntaxe de ce système de connexion est soit:</p> +<p>Qt::Object::connect( envoyeur, SIGNAL 'mon_signal(types_d_arguments)', +recepteur, SLOT 'monslot(types_d_arguments)');</p> +<p>soit:</p> +<p>unObjet->connect( envoyeur, SIGNAL 'mon_signal(types_d_arguments)', +SLOT 'monslot(types_d_arguments)');</p> +<p>Dans le second cas, le récepteur est omis car c'est l'objet lui-même,</p> +<p>Ce mécanisme est extensible à volonté par la déclaration de nouveaux Signaux et +Slots par l'usage des pragma <code>use Qt::signals</code> et <code>use Qt::slots</code> +(voir aussi la deuxième syntaxe décrite plus bas).</p> +<p>Chaque slot déclaré appellera la routine correspondante de votre +objet. Chaque signal déclaré peut être déclenché via le mot-clé <strong>emit</strong>.</p> +<p><strong>Réécrivons encore notre exemple pour illustrer nos propos :</strong></p> +<pre> + 1: use strict; + 2: + 3: package Button; + 4: use Qt; + 5: use Qt::isa qw(Qt::PushButton); + 6: use Qt::attributes qw(itsTime); + 7: use Qt::slots + 8: aEteClicke => [], + 9: changement => ['int', 'int']; + 10: use Qt::signals + 11: changeLe => ['int', 'int']; + 12: + 13: sub NEW + 14: { + 15: shift->SUPER::NEW(@_[0..2]); + 16: itsTime = Qt::Time; + 17: itsTime->start; + 18: this->connect(this, SIGNAL 'clicked()', SLOT 'aEteClicke()'); + 19: this->connect(this, SIGNAL 'changeLe(int,int)', SLOT 'changement(int,int)'); + 20: } + 21: + 22: sub aEteClicke + 23: { + 24: my $w = width(); + 25: my $h = height(); + 26: setText( "w: $w h: $h\nt: ". itsTime->elapsed ); + 27: emit changeLe($w, $h); + 28: } + 29: + 30: sub changement + 31: { + 32: my ($w, $h) = @_; + 33: print STDERR "w: $w h: $h \n"; + 34: } + 35: + 36: 1;</pre> +<p>Nous définissons dans ce package deux nouveaux slots et un nouveau signal.</p> +<p>La documentation Qt nous dit que tout PushButton clické émet un signal +<code>clicked()</code> ; nous le connectons donc à notre nouveau slot [ligne 18].</p> +<p>Nous connectons aussi notre signal <code>ChangeLe</code> à notre slot +<code>changement</code>.</p> +<p>Ainsi, quand on appuie (clique) sur notre Button , le signal +<code>clicked()</code> est émit et déclenche le slot <code>aEteClicke()</code>. +<code>aEteClicke()</code> émet à son tour le signal <code>changeLe(int,int)</code>[l.27], +appelant de ce fait le slot <code>changement(int,int)</code>, avec deux arguments.</p> +<p>Enfin, il existe une syntaxe alternative introduite dans PerlQt-3.008 :</p> +<pre> + sub un_slot : SLOT(int, QString) + { + $int = shift; + $string = shift; + # faire quelque chose + }</pre> +<p>et</p> +<pre> + sub un_signal : SIGNAL(QString);</pre> +<p>Cette syntaxe est parfaitement compatible avec la déclaration par le biais de +<code>use Qt::signals</code> et <code>use Qt::slots</code>. +Il peut d'ailleurs d'avérer très profitable pour la clarté du programme de déclarer tout d'abord +les signaux/slots au moyen de <code>use Qt::slots/signals</code>, puis de rappeler cette déclaration au niveau de +l'implémentation à l'aide de la seconde syntaxe. +Les déclarations seront alors vérifiées à la compilation, et le moindre conflit +générera un avertissement.</p> +<p> +</p> +<hr /> +<h1><a name="développement_rapide_(rad)_avec_qt_designer_et_puic">Développement rapide (RAD) avec Qt Designer et Puic</a></h1> +<p> +</p> +<h2><a name="introduction">Introduction</a></h2> +<ul> +<li><strong><a name="item_n%2eb%3a">N.B:</a></strong><br /> +</li> +Depuis la version 3.008, il existe un plugin spécifique à PerlQt pour Qt Designer. +Ce plugin (disponible sur les pages internet du projet) apporte le confort d'une intégration poussée, +la coloration syntaxique Perl, la complétion automatique, et permet de lancer et déboguer un projet +sans quitter l'interface du Designer. +Ce qui suit reste néanmoins parfaitement valable pour ce qui est de l'utilisation de puic en ligne de commande, +et pour l'utilisation de Qt Designer <em>sans</em> le plugin spécifique. +<p></p></ul> +<p>Aussi puissant et intuitif que soit Qt, écrire une GUI complète reste un exercice +fastidieux.</p> +<p>Heureusement, Qt est fourni avec un constructeur de GUI sophistiqué +appelé Qt Designer qui est quasiment un environnement de développement +intégré. Il comporte la gestion de Projets, la création d'un GUI par +des actions de ``drag and drop'', un butineur d'objet complet, +l'interconnexion graphique de signaux et de slots, et plus encore.</p> +<p>L'information générée par Qt Designer's est en format XML et peut donc +être parsée par différentes commandes comme dont <strong>puic</strong> (le +compilateur d'interface utilisateur PerlQt).</p> +<p>Supposons que vous avez déja construit un fichier d'interface avec +Qt Designer, la transcription en un programme PerlQt se fait par +la simple exécution de la commande :</p> +<pre> + puic -x -o program.pl program.ui</pre> +<p>Cela génèrera le package défini dans votre fichier ui et un package +principal à fins de test,</p> +<p>Vous pouvez préférer :</p> +<pre> + puic -o package.pm program.ui</pre> +<p>Cela ne générera que le package qui pourra être utilisé par un programme séparé.</p> +<p> +</p> +<h2><a name="inclure_des_images">Inclure des Images</a></h2> +<p>Il y a deux manières d'inclure des <strong>images ou icônes</strong>:</p> +<ul> +<li><strong><a name="item_inclusion_inline">Inclusion Inline</a></strong><br /> +</li> +A cette fin, nous devons sélectionner ``Edit->Form +Settings->Pixmaps->Save inline'' dans Qt Designer et executer ensuite: +<pre> + puic -x -o F<program.pl> F<program.ui></pre> +<p></p> +<li><strong><a name="item_image_collection">Image Collection</a></strong><br /> +</li> +Cette stratégie est plus complexe, mais plus propre et plus puissante. +<pre> + puic -o F<Collection.pm> -embed F<unique_identifier> F<image-1> ... F<image-n></pre> +<p>Ajoutez l'instruction <code>use Collection.pm</code> dans le package principal +de votre programme.</p> +<p>Si vous avez créé un fichier projet dans Qt Designer et ajouté toutes +les images dans un groupe (par ``Project->Image Collection''), vous +disposez ensuite de ces images dans le répertoire où votre fichier +projet (*.pro) est stocké, dans le sous-répertoire <strong>image</strong>. Vous pouvez +alors générer la collection d'images par:</p> +<pre> + puic -o F<Collection.pm> -embed F<identifier> images/*</pre> +<p>Vous pouvez utiliser autant de collections d'images que vous voulez +dans un programme en ajoutant simplement une instruction <strong>use</strong> +pour chaque collection.</p> +<p></p></ul> +<p> +</p> +<h2><a name="travailler_avec_des_fichiers_.ui">Travailler avec des fichiers <strong>.ui</strong></a></h2> +<p>Souvent, vous voudrez regénérez votre interface utilisateur à +à cause d'une modification ou extension de votre design initial. +C'est donc une mauvais idée d'écrire votre code dans le fichier Perl +autogénéré car vous risquerez d'écraser le code que vous avez écrit +manuellement ou vous devrez faire des copier-coller intensifs.</p> +<p>Voici une meilleure méthode :</p> +<ul> +<li><strong><a name="item_écrire_l%27implémentation_de_slots_dans_le_designe">Écrire l'implémentation de slots dans le Designer</a></strong><br /> +</li> +Dans Qt Designer, selectionnez l'onglet <em>Source</em> dans l'explorateur +d'objets (<strong>Object Explorer</strong>). Vous pouvez ainsi voir représentées +sous forme d'arbre les classes que vous avez générées. Maintenant, si +vous cliquez deux fois sur l'entrée <em>Slots/public</em>, +un dialogue vous demande si vous voulez créer un nouveau slot pour +votre module. Une fois cela fait, le nouveau slot apparait à +l'intérieur de l'arbre l'explorateur d'objet; cliquer dessus vous +amènera à votre fichier <strong><Votre Classe>.ui.h</strong> où vous pouvez +écrire l'implémentation de votre slot. +<p>Par défaut, il devrait ressembler à ceci :</p> +<pre> + void Form1::newSlot() + {</pre> +<pre> + }</pre> +<p>La déclaration du slot est réellement du code C++, mais ignorons cela +et écrivons du code Perl entre les deux accolades en faisant bien +attention d'indenter notre code avec au moins un espace.</p> +<pre> + void Form1::newSlot() + { + print STDERR "Hello world from Form1::newSlot(); + if(this->foo()) + { + # faire quelque chose + } + }</pre> +<p>Notre code Perl ainsi écrit sera sauvé dans le fichier ui.h et +<strong>puic</strong> prendra soin de le placer dans notre programme final.</p> +<p>Ici, après l'exécution de <strong>puic</strong> sur le ficier Form1.ui, vous +devriez avoir:</p> +<pre> + sub newSlot + { + print STDERR "Hello world from Form1::newSlot(); + if(this->foo()) + { + # faire quelque chose + } + }</pre> +<p></p> +<li><strong><a name="item_sous%2dclassez_votre_gui">Sous-classez votre GUI</a></strong><br /> +</li> +En utilisant l'option <em>-subimpl</em> de <strong>puic</strong>, vous pouvez générer un +module dérivé qui hérite l'interface utilisateur originelle. +<p>Typiquement, vous générez le module dérivé une fois, et écrivez votre +code dans ce module dérivé. Ainsi, quand vous devez modifier votre +module GUI, regénérez le module dont il dérive et il héritera les +changements.</p> +<p>Pour générer le module de base :</p> +<pre> + puic -o Form1.pm form1.ui</pre> +<p>(faîtes cela aussi souvent que nécessaire: n'éditez jamais +manuellement form1.ui puisqu'il serait écrasé)</p> +<p>Pour générer le GUI dérivé :</p> +<pre> + puic -o Form2.pm -subimpl Form2 form1.ui</pre> +<p>ou</p> +<pre> + puic -o program.pl -x -subimpl Form2 form1.ui</pre> +<p>(faites cela une fois et travaillez avec le fichier résultant)</p> +<p></p></ul> +<p> +</p> +<hr /> +<h1><a name="autres_outils_de_développement">Autres outils de développement</a></h1> +<p>PerlQt comprend également deux programmes pouvant vous aider à maîtriser l'API de Qt :</p> +<p> +</p> +<h2><a name="pqtapi">pqtapi</a></h2> +<p>pqtapi est un outil d'introspection en ligne de commande.</p> +<pre> + utilisation: pqtapi [-r <re>] [<class>]</pre> +<pre> + options: + -r <re> : chercher les méthodes correspondant à l'expression régulière <re> + -i : avec -r, effectue une recherche insensible à la casse + -v : afficher les versions de PerlQt et de Qt + -h : afficher ce message d'aide</pre> +<p>ex:</p> +<pre> + $>pqtapi -ir 'setpoint.* int' + void QCanvasLine::setPoints(int, int, int, int) + void QPointArray::setPoint(uint, int, int)</pre> +<p> +</p> +<h2><a name="pqtsh">pqtsh</a></h2> +<p><strong>pqtsh</strong> est un shell graphique permettant de tester l'API de manière interactive. +Un exemple dynamique est accessible dans l'entrée de menu <code>Help->Example</code>.</p> +<br/> +<div class='image'><img src="../images/pqtsh.png"/></div><p> +</p> +<hr /> +<h1><a name="limitations">Limitations</a></h1> +<p>Les classes à modèle (templates) ne sont pas encore accessibles par PerlQt. +En revanche, les classes dérivées de classes à modèle sont disponibles.</p> +<p>Vous pouvez reconnaître ce type de classe en ce que leurs arguments comprennent un type générique placé entre +les signes ``<'' et ``>''.</p> +<p>ex: + QDictIterator ( const QDict<type> & dict )</p> +<p> +</p> +<hr /> +<h1><a name="crédits">Crédits</a></h1> +<p>PerlQt-3 est (c) 2002 Ashley Winters (et (c) 2003 Germain Garand)</p> +<p>Kalyptus et l'engin de génération Smoke sont (c) David Faure and Richard Dale</p> +<p>Puic is (c) TrollTech AS., Phil Thompson et Germain Garand,</p> +<p>Ledit logiciel est délivré sous la GNU Public Licence v.2 or later.</p> +<p> +</p> +<hr /> +<h1><a name="appendice:_les_conventions_de_c++_et_leur_traduction_en_perl">Appendice: Les conventions de C++ et leur traduction en Perl</a></h1> +<p>Lorsque vous voulez utiliser depuis PerlQt une classe ou méthode décrite +dans la <a href="http://doc.trolltech.com">documentation</a> Qt (voyez aussi le programme +$QTDIR/bin/assistant livré avec Qt), vous devez suivre des règles de translation simples.</p> +<dl> +<dt><strong><a name="item_noms_de_classe">Noms de classe</a></strong><br /> +</dt> +<ul> +<li></li> +Les noms de classes utilisent le préfixe <strong>Qt::</strong> au lieu de <strong>Q</strong> pour +être conforme à l'usage Perl. Ainsi: QComboBox est nommé Qt::ComboBox +dans PerlQt. +<p></p></ul> +<dt><strong><a name="item_fonctions">Fonctions</a></strong><br /> +</dt> +<ul> +<li></li> +Les fonctions décrites comme <strong>static</strong> sont accédées directement et non +à travers un objet. Ainsi la fonction statique Foo de la classe <strong>QBar</strong> +peut être accédée de PerlQt par +<pre> + Qt::Bar::Foo( arg-1,...,arg-n);</pre> +<p></p> +<li></li> +Les fonctions décrites comme <strong>members</strong> ou <strong>Signals</strong> sont +accessibles à travers l'objet par l'opérateur + <strong>-></strong> . +Par exemple: +<pre> + $widget->show;</pre> +<p>Il n'y a pas de différence fondamentale entre les méthodes et les +signaux, néanmoins PerlQt fournit le mot-clé <strong>emit</strong> comme une +mnémonique pratique pour rendre clair que vous émettez un signal :</p> +<pre> + emit $button->clicked;</pre> +<p></p></ul> +<dt><strong><a name="item_arguments">Arguments</a></strong><br /> +</dt> +<ul> +<li><strong><a name="item_par_valeur">Par valeur</a></strong><br /> +</li> +Lorsqu'un argument n'est pas précédé par un des caractères <strong>&</strong> or +<strong>*</strong>, il est passé par valeur. Pour tous les types basiques tels que +int, char, float and double, PerlQt convertira automatiquement les +valeurs litérales et scalaires dans le type correspondants C++. +<p>Ainsi pour le prototype d'un constructeur écrit dans la documentation +comme ceci: + QSize ( int w, int h )</p> +<p>Vous écrirez :</p> +<pre> + Qt::Size(8, 12);</pre> +<p></p> +<li><strong><a name="item_par_référence">Par référence</a></strong><br /> +</li> +Lorsqu'un argument est précédé par le caractère <strong>&</strong>, Il est une +référence à un objet ou à un type. Vous pouvez alors fournir un nom de +variable ou un objet temporaire : +<pre> + $keyseq = Qt::keySequence( &Qt::CTRL + &Qt::F3 ); + $widget->setAccel( $keyseq );</pre> +<p>ou</p> +<pre> + $widget->setAccel(Qt::keySequence( &Qt::CTRL + &Qt::F3 );</pre> +<p>Si l'argument n'est <em>pas</em> qualifié par <strong>const</strong> (constante), l'argument +est un objet qui peut être altéré par la méthode, vous devez +donc passer une variable.</p> +<p></p> +<li><strong><a name="item_par_pointeur">Par pointeur</a></strong><br /> +</li> +Lorsqu'un argument est précédé par le caractère <strong>*</strong>, +un pointeur vers un objet ou un type est attendu. En PerlQt, vous +pouvez fournir un nom de variable ou le mot clé <strong>undef</strong> à la place +du pointer Null. +<p>De plus, si l'argument est const, l'objet passé en argument est en +lecture seule: il ne peut pas être modifié.</p> +<p></p></ul> +<dt><strong><a name="item_énumérations">Énumérations</a></strong><br /> +</dt> +<dd> +Les Énumerations sont une forme d'alias pour des valeurs numériques +dont il serait autrement difficile de se souvenir: +</dd> +<dd> +<p>Exemple C++:</p> +</dd> +<dd> +<pre> + enum Strange { Apple, Orange, Lemon }</pre> +</dd> +<dd> +<p>Ici, <code>Strange</code> est le type (au sens de C++) de l'énumération, et +<code>Apple</code>, <code>Orange</code> et +<code>Lemon</code> ses valeurs possible , qui sont des aliases pour des +nombres (ici 0, 1 et 2)</p> +</dd> +<dd> +<p>L'accès aux valeurs d'énumération en Perl Qt est un appel +de fonction statique.</p> +</dd> +<dd> +<p>Donc, si vous voulez éviter des prblèmes de lisibilité, nous vous +recommandons l'usage d'une syntaxe alternative d'appel de fonction +pour marquer l'utilisation d'un alias d'énumération: <code>&fonction</code>.</p> +</dd> +<dd> +<p>Revenons à notre exemple <code>Strange</code>.</p> +</dd> +<dd> +<p>Si nous rencontrons sa définition dans la classe <code>QFruits</code>, vous +écrirez en PerlQt :</p> +</dd> +<dd> +<pre> + $pomme_plus_orange = &Qt::Fruit::Pomme + &Qt::Fruit::Orange;</pre> +</dd> +<p></p> +<dt><strong><a name="item_opérateurs">Opérateurs</a></strong><br /> +</dt> +<dd> +Dans PerlQt, la <strong>surcharge d'opérateurs</strong> fonctionne de manière transparente. +Si un opérateur est surchargé dans une classe Qt (ce qui signifie que son utilisation +déclenchera un appel de méthode, au lieu d'utiliser l'opérateur générique) +il sera également surchargé dans PerlQt. +</dd> +<dd> +<p>ex-1: surcharge de '+='</p> +</dd> +<dd> +<pre> + $p1 = Qt::Point(10, 10) + $p2 = Qt::Point(30,40) + $p2 += $p1; # $p2 devient (40,50)</pre> +</dd> +<dd> +<p>ex-2: surcharge de '<<'</p> +</dd> +<dd> +<pre> + $f = Qt::File("example"); + $f->open( IO_WriteOnly ); # voir l'entrée 'Constantes' plus bas + $s = Qt::TextStream( $f ); + $s << "Que faire avec " << 12 << " pommes ?";</pre> +</dd> +<dd> +<p><strong>Exception notable</strong> : le constructeur de copie (signe égal, '=') n'est jamais surchargé, +attendu qu'il ne pourrait fonctionner que partiellement et que le paradigme de +Perl est très différent de C++ en matière de copie d'objets.</p> +</dd> +<p></p> +<dt><strong><a name="item_constantes">Constantes</a></strong><br /> +</dt> +<dd> +Qt n'utilise pas beaucoup de constantes, mais on en trouve cependant dans le module d'Entrées/Sorties, +où elles font office de drapeaux pour les modes d'ouverture de fichiers. +</dd> +<dd> +<p>Pour éviter de polluer inutilement l'espace de nom, nous avons regroupé les constantes dans le module +<strong>Qt::constants</strong>, d'où elles seront chargées à la demande.</p> +</dd> +<dd> +<p>Ainsi, pour importer l'ensemble des constantes d'E/S, on écrira :</p> +</dd> +<dd> +<pre> + use Qt::constants;</pre> +</dd> +<dd> +<p>Et pour importer quelques symboles seulement :</p> +</dd> +<dd> +<pre> + use Qt::constants qw( IO_ReadOnly IO_WriteOnly );</pre> +</dd> +<p></p> +<dt><strong><a name="item_fonctions_globales">Fonctions globales</a></strong><br /> +</dt> +<dd> +Qt dispose de fonctions utilitaires, telles bitBlt, qCompress, etc. +</dd> +<dd> +<p>Ces fonctions ont été rassemblées dans un espace de nom commun: +<code>Qt::GlobalSpace</code>.</p> +</dd> +<dd> +<p>Vous pourrez donc y accéder soit par un appel pleinement qualifié :</p> +</dd> +<dd> +<pre> + Qt::GlobalSpace::qUncompress( $buffer )</pre> +</dd> +<dd> +<p>Soit en important préalablement ces fonctions dans l'espace de nom courant :</p> +</dd> +<dd> +<pre> + use Qt::GlobalSpace; + qUncompress( $buffer )</pre> +</dd> +<dd> +<p>Bien entendu, vous pouvez aussi n'importer que les fonctions souhaitées :</p> +</dd> +<dd> +<pre> + use Qt::GlobalSpace qw( qUncompress bitBlt )</pre> +</dd> +<dd> +<p><strong>N.B:</strong> GlobalSpace renferme également des opérateurs de portée globale, tels +celui permettant d'aditionner deux Qt::Point(). Ces opérateurs seront appelés +automatiquement.</p> +</dd> +<dd> +<p>ex:</p> +</dd> +<dd> +<pre> + $p1 = Qt::Point(10, 10) + Qt::Point(20, 20)</pre> +</dd> +<p></p></dl> +<p> +</p> +<hr /> +<h1><a name="annexe_2_:_internationalisation">Annexe 2 : Internationalisation</a></h1> +<p>PerlQt résout les problèmes d'internationalisation en convertissant systématiquement les <strong>QString</strong> +de Qt en <strong>utf8</strong> côté Perl.</p> +<p>Les conversions en sens inverse, depuis Perl vers Qt sont traitées différemment suivant le contexte :</p> +<ul> +<li><strong><a name="item_si_la_chaîne_de_caractère_est_déjà_marquée_comme_é">Si la chaîne de caractère est déjà marquée comme étant utf8</a></strong><br /> +</li> +alors elle sera convertie en QString directement. +<p>C'est la manière privilégiée d'opérer, et la plus simple : +Il vous suffit d'insérer un pragma <strong>use utf8</strong> en tête de vos programmes, puis d'utiliser un éditeur de +texte supportant l'utf8 (quasiment tous de nos jours) pour élaborer votre code source. +Les chaînes seront marquées par Perl automatiquement.</p> +<p></p> +<li><strong><a name="item_si_la_chaîne_n%27est_pas_marquée_comme_utf8%2c_et_">Si la chaîne n'est pas marquée comme utf8, et le pragma 'use locale' n'est pas actif</a></strong><br /> +</li> +alors la conversion en QString se fera depuis l'<strong>ISO-Latin-1</strong>. +<p></p> +<li><strong>Si la chaîne n'est pas marquée comme utf8, et le pragma 'use locale' est actif</strong><br /> +</li> +alors la conversion en QString se fera depuis votre <strong>locale</strong>. +<p></p></ul> +<p>Lorsque des chaînes contiennent de l'utf8, Perl adapte automatiquement ses opérateurs pour que +leur gestion soit entièrement transparente (comprendre opaque, comme toujours...). +Cependant, vous pourrez avoir besoin à l'occasion de les transcrire en d'autres jeux d'encodage. +Ceci peut se faire soit avec Qt :</p> +<pre> + $tr1=Qt::TextCodec::codecForLocale(); # ceci utilisera la locale en vigueur + $tr2=Qt::TextCodec::codecForName("KOI8-R"); # ceci force l'emploi d'une locale spécifique (Russe)</pre> +<pre> + print $tr1->fromUnicode(Qt::DateTime::currentDateTime()->toString)."\n\n"; + print $tr2->fromUnicode($une_chaine_utf8);</pre> +<p>Soit avec les outils de Perl (pour perl >= 5.8.0). +Se reporter à ce sujet à la documentation du module <strong>Encode</strong> (<code>perldoc Encode</code>).</p> +<p> +</p> +<h3><a name="désactiver_l'encodage_utf8">désactiver l'encodage utf8</a></h3> +<p>Les programmeurs souhaitant désactiver temporairement l'encodage utf8 +(pour la gestion de programmes externes ou de modules anciens ne supportant pas cet encodage) +pourront utiliser le pragma <strong>use bytes</strong> (et sa réciproque : <strong>no bytes</strong>).</p> +<p>Dans la portée de ce pragma, les conversions depuis QString vers les chaînes Perl se feront en ISO-Latin1 +(par défaut) ou suivant la locale en vigueur (si <strong>use locale</strong> est actif).</p> +<p>Notez bien qu'il est préférable de <em>ne pas utiliser ce pragma à la légère</em>, en ce qu'il ruine totalement les +efforts de standardisations autour d'utf8 entrepris depuis plusieurs années déjà. +Il est très préférable de corriger les programmes fautifs.</p> +<p> +</p> +<hr /> +<h1><a name="annexe_3_:_canaux_de_déboguage">Annexe 3 : Canaux de déboguage</a></h1> +<p>Le module <strong>Qt::debug</strong> offre divers canaux de déboguage permettant de filtrer +le flux conséquent d'informations disponibles pour l'adapter à vos besoins.</p> +<pre> + use Qt::debug;</pre> +<pre> + use Qt::debug qw|calls autoload verbose|;</pre> +<p>Avec le pragma <code>use Qt::debug</code>, seuls les canaux <strong>verbose</strong> et <strong>ambiguous</strong> sont activés. +Si vous le faites suivre d'une liste précise de canaux, seuls ceux-ci seront affichés.</p> +<p><strong>Liste et descriptif des canaux :</strong></p> +<ul> +<li><strong><a name="item_ambiguous">ambiguous</a></strong><br /> +</li> +Vérifier si les appels de méthodes sont ambigus, et dire quelle méthode, parmi le jeux +d'alternatives, à finalement été choisie. +<p></p> +<li><strong><a name="item_verbose">verbose</a></strong><br /> +</li> +Donner davantage d'informations. +<p>Utilisé avec <strong>ambiguous</strong>, vous donnera les correspondances les plus proches lorsqu'un appel de méthode échoue.</p> +<p>ex:</p> +<pre> + use Qt; + use Qt::debug; + $a= Qt::Application(\@ARGV); + $a->libraryPath("chose");</pre> +<pre> + --- No method to call for : + QApplication::libraryPath('chose') + Closer candidates are : + static void QApplication::addLibraryPath(const QString&) + static QStringList QApplication::libraryPaths() + static void QApplication::removeLibraryPath(const QString&) + static void QApplication::setLibraryPaths(const QStringList&)</pre> +<p></p> +<li><strong><a name="item_calls">calls</a></strong><br /> +</li> +Pour chaque appel de méthode, vous dira quelle méthode Qt est finalement appelée, +en précisant les arguments si <strong>verbose</strong> est actif. +<p></p> +<li><strong><a name="item_autoload">autoload</a></strong><br /> +</li> +Détaille le passage dans le code intermédiaire faisant la jonction entre Perl et Qt. +<p></p> +<li><strong><a name="item_gc">gc</a></strong><br /> +</li> +Donne des informations sur la collection des déchets, c'est à dire sur la destruction des objets, +qu'ils soient détruits depuis Perl ou Qt. +<p></p> +<li><strong><a name="item_virtual">virtual</a></strong><br /> +</li> +Vous averti chaque fois qu'une fonction virtuelle tente d'accéder à sa réimplémentation en Perl +(que cette réimplémentation existe ou non). +<p></p> +<li><strong><a name="item_all">all</a></strong><br /> +</li> +Activer tous les canaux. +<p></p></ul> +<p> +</p> +<hr /> +<h1><a name="annexe_4_:_marshalleurs">Annexe 4 : Marshalleurs</a></h1> +<p>Un marshalleur est un convertisseur permettant de transcrire un type de données en un autre.</p> +<p>Dans PerlQt, la plupart des objets Qt gardent leurs propriétés d'objet, ce qui permet d'invoquer leurs méthodes +et de changer leurs propriétés comme il se doit. +Cependant, il arrive que l'objet d'origine corresponde à ce point à un type natif de Perl qu'il serait malséant +d'utiliser l'interface C++ et beaucoup plus naturel de lui substituer son équivalent.</p> +<p>Ici interviennent les marshalleurs. +Plutôt que de retourner un objet Qt::StringList, qui serait délicat à manipuler, +PerlQt le transformera en référence de liste Perl. +Dès lors, tous les opérateurs de manipulation de liste pourront lui être appliqué : +on gagne en densité, en cohérence et en simplicité.</p> +<p>Cette transformation s'appliquera aussi en sens inverse, et n'importe quelle liste de chaînes Perl +pourra être donnée en argument à une méthode attendant une Qt::StringList.</p> +<pre> + Liste des marshalleurs (PerlQt-3.008) + ----------------------------------------------------------------- + float, double <=> réel Perl (NV) + char, uchar, int, uint, enum + long, ulong, short, ushort <=> entier Perl (IV) + QString, -&, -* => chaîne Perl (utf8) + QString, -&, -* <= chaîne Perl (utf8 ou iso-latin1 ou locale) + QCString, -&, -* <=> chaîne Perl (utf8 ou octets, suivant contenu ou pragma "bytes") + QStringList, -&, -* => référence à une liste de chaînes Perl (utf8) + QByteArray, -&, -* <=> chaîne Perl (octets) + int&, -* <=> entier Perl (IV) + bool&, -* <=> booléen Perl + char* <=> chaîne Perl (octets) + char** <= référence à une liste de chaînes Perl (octets) + uchar* <= chaîne Perl(octets) + QRgb* <= référence à une liste d'entiers Perl (IV) + QCOORD* <= référence à une liste d'entiers Perl (IV) + void* <=> référence à un entier Perl (IV) + QValueList<int>, - *, - & <=> référence à une liste d'entiers Perl (IV) + QCanvasItemList, - *, - & => réference à une liste de Qt::CanvasItem + QWidgetList, - *, - & <=> réference à une liste de Qt::Widget + QObjectList, - *, - & <=> réference à une liste de Qt::Object + QFileInfoList, - *, - & <=> réference à une liste de Qt::FileInfo + QPtrList<QTab>, - *, - & <=> réference à une liste de Qt::Tab + QPtrList<QToolBar>, - *, - & <=> réference à une liste de Qt::ToolBar + QPtrList<QNetworkOperation>, - *, - & <=> réference à une liste de Qt::NetworkOperation + QPtrList<QDockWindow>, - *, - & <=> réference à une liste de Qt::DockWindow + (QUObject*)</pre> + +</body> + +</html> |