You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1121 lines
47 KiB
1121 lines
47 KiB
<!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 PerlTQt</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 PerlTQt</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 PerlTQt</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 PerlTQt</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 TQt 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 PerlTQt</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 TQt 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>PerlTQt-3, crée par Ashley Winters, est une interface perl aux composants
|
|
graphiques (et non graphiques) fournis par TQt3.</p>
|
|
<p>Le toolkit TQt 3.0 auquel PerlTQt accède à été écrit en C++ par la société
|
|
Trolltech: <a href="http://www.trolltech.com">Trolltech</a>.</p>
|
|
<p>PerlTQt3 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 TQt 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 PerlTQt.
|
|
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 TQt</a>. Ladite documentation est
|
|
la seule référence qui fasse autorité.</p>
|
|
<p>Si TQt est installé sur votre système, sa documentation l'est
|
|
certainement aussi : voyez le programme $TQTDIR/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 PerlTQt, 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">TQt >= v3.0</a>
|
|
<p></p>
|
|
<li></li>
|
|
<a href="http://webcvs.kde.org/cgi-bin/cvsweb.cgi/kdebindings/smoke">SmokeTQt 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>tdebindings</strong>. Vous pouvez vérifier si
|
|
une version précompilée de ce module existe pour votre système. Mais
|
|
perlTQt 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 TQt 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 PerlTQt</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 PerlTQt.</p>
|
|
<p>PerlTQt 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>TQTDIR</strong> n'est pas définie, vous devrez
|
|
peut-être spécifier manuellement l'emplacement de TQt à l'aide de l'option :</p>
|
|
<pre>
|
|
--with-qtdir=/emplacement/de/TQt</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 PerlTQt, 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 TDEDIR 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 PerlTQt pour qu'il ne s'installe pas dans la hiérarchie Perl ordinaire :
|
|
<pre>
|
|
cd PerlTQt
|
|
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 PerlTQt</p>
|
|
<p></p>
|
|
<li></li>
|
|
Lancez la compilation et l'installation
|
|
<pre>
|
|
make && make install</pre>
|
|
<p>Pour exécuter des programmes PerlTQt, 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 PerlTQt</a></h1>
|
|
<p>Un programme TQt 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>TQt::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. TQt gérera les événements et les dirigera vers les
|
|
routines appropriées.</p>
|
|
<p>Voyons un programme PerlTQt minimal.</p>
|
|
<p>
|
|
</p>
|
|
<h2><a name="hello_world">Hello World</a></h2>
|
|
<pre>
|
|
1: use TQt;
|
|
2: my $a = TQt::Application(\@ARGV);
|
|
3: my $hello = TQt::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 TQt [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>TQt::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 perlTQt 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 PerlTQt sont accessibles par le préfixe <strong>TQt::</strong> au lieu du
|
|
<strong>Q</strong> initial des classes TQt en C++. En consultant la <a href="http://doc.trolltech.com">documentation TQt</a>, vous devez donc mentalement changer le
|
|
nom d'une clasee <strong>TQFoo</strong> en <strong>TQt::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 TQt::Foo</code> ou <code>TQt::Foo->new()</code>
|
|
contrairement à l'usage commun en Perl.</p>
|
|
<p>Dites simplement:</p>
|
|
<pre>
|
|
my $object = TQt::<classname>(arg_1, ..., arg_n);</pre>
|
|
<p>Un constructeur sans argument s'énonce encore plus brièvement :</p>
|
|
<pre>
|
|
my $object = TQt::<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 TQt (Par exemple: ``<code>TQWidget* 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 TQt,
|
|
parlons du mécanisme d'héritage vu de PerlTQt.</p>
|
|
<p>PerlTQt est conçu pour allier la simplicité de TQt à la puissance et à la
|
|
flexibilité de Perl. Pour ce faire, PerlTQt étend le paradigme objet de
|
|
Perl pour mimer TQt 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 TQt;
|
|
5: use TQt::isa qw(TQt::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 TQt;
|
|
18: use Button;
|
|
19:
|
|
20: my $a = TQt::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 TQt [l.4].</p>
|
|
<p>Nous utilisons le pragma <code>TQt::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 PerlTQt 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: TQt::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, PerlTQt 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, PerlTQt 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 TQt::attributes</code>, suivi d'une liste des noms d'attributs souhaités.
|
|
Ainsi:</p>
|
|
<pre>
|
|
1: use strict;
|
|
2:
|
|
3: package Button;
|
|
4: use TQt;
|
|
5: use TQt::isa qw(TQt::PushButton);
|
|
6: use TQt::attributes qw(
|
|
7: itsTime
|
|
8: pData
|
|
9: );
|
|
10:
|
|
11: sub NEW
|
|
12: {
|
|
13: shift->SUPER::NEW(@_[0..2]);
|
|
14: itsTime = TQt::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>TQt::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 TQt, un package doit contenir un
|
|
pragma <code>use TQt::isa</code>.
|
|
<p>Ainsi:</p>
|
|
<pre>
|
|
use TQt::isa "TQt::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 TQt::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 TQt (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 TQt tentera d'appeler
|
|
dans votre classe en plaçant <code>use TQt::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 TQt 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 TQt 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 TQt 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>TQt::Object::connect( envoyeur, TQT_SIGNAL 'mon_signal(types_d_arguments)',
|
|
recepteur, TQT_SLOT 'monslot(types_d_arguments)');</p>
|
|
<p>soit:</p>
|
|
<p>unObjet->connect( envoyeur, TQT_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 TQt::signals</code> et <code>use TQt::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 TQt;
|
|
5: use TQt::isa qw(TQt::PushButton);
|
|
6: use TQt::attributes qw(itsTime);
|
|
7: use TQt::slots
|
|
8: aEteClicke => [],
|
|
9: changement => ['int', 'int'];
|
|
10: use TQt::signals
|
|
11: changeLe => ['int', 'int'];
|
|
12:
|
|
13: sub NEW
|
|
14: {
|
|
15: shift->SUPER::NEW(@_[0..2]);
|
|
16: itsTime = TQt::Time;
|
|
17: itsTime->start;
|
|
18: this->connect(this, TQT_SIGNAL 'clicked()', TQT_SLOT 'aEteClicke()');
|
|
19: this->connect(this, TQT_SIGNAL 'changeLe(int,int)', TQT_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 TQt 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 PerlTQt-3.008 :</p>
|
|
<pre>
|
|
sub un_slot : TQT_SLOT(int, TQString)
|
|
{
|
|
$int = shift;
|
|
$string = shift;
|
|
# faire quelque chose
|
|
}</pre>
|
|
<p>et</p>
|
|
<pre>
|
|
sub un_signal : TQT_SIGNAL(TQString);</pre>
|
|
<p>Cette syntaxe est parfaitement compatible avec la déclaration par le biais de
|
|
<code>use TQt::signals</code> et <code>use TQt::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 TQt::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 TQt 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 à PerlTQt pour TQt 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 TQt Designer <em>sans</em> le plugin spécifique.
|
|
<p></p></ul>
|
|
<p>Aussi puissant et intuitif que soit TQt, écrire une GUI complète reste un exercice
|
|
fastidieux.</p>
|
|
<p>Heureusement, TQt est fourni avec un constructeur de GUI sophistiqué
|
|
appelé TQt 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 TQt 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 PerlTQt).</p>
|
|
<p>Supposons que vous avez déja construit un fichier d'interface avec
|
|
TQt Designer, la transcription en un programme PerlTQt 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 TQt 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 TQt 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 TQt 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>PerlTQt comprend également deux programmes pouvant vous aider à maîtriser l'API de TQt :</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 PerlTQt et de TQt
|
|
-h : afficher ce message d'aide</pre>
|
|
<p>ex:</p>
|
|
<pre>
|
|
$>pqtapi -ir 'setpoint.* int'
|
|
void TQCanvasLine::setPoints(int, int, int, int)
|
|
void TQPointArray::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 PerlTQt.
|
|
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:
|
|
TQDictIterator ( const TQDict<type> & dict )</p>
|
|
<p>
|
|
</p>
|
|
<hr />
|
|
<h1><a name="crédits">Crédits</a></h1>
|
|
<p>PerlTQt-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 PerlTQt une classe ou méthode décrite
|
|
dans la <a href="http://doc.trolltech.com">documentation</a> TQt (voyez aussi le programme
|
|
$TQTDIR/bin/assistant livré avec TQt), 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>TQt::</strong> au lieu de <strong>Q</strong> pour
|
|
être conforme à l'usage Perl. Ainsi: TQComboBox est nommé TQt::ComboBox
|
|
dans PerlTQt.
|
|
<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>TQBar</strong>
|
|
peut être accédée de PerlTQt par
|
|
<pre>
|
|
TQt::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 PerlTQt 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, PerlTQt 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:
|
|
TQSize ( int w, int h )</p>
|
|
<p>Vous écrirez :</p>
|
|
<pre>
|
|
TQt::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 = TQt::keySequence( &TQt::CTRL + &TQt::F3 );
|
|
$widget->setAccel( $keyseq );</pre>
|
|
<p>ou</p>
|
|
<pre>
|
|
$widget->setAccel(TQt::keySequence( &TQt::CTRL + &TQt::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 PerlTQt, 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 TQt 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>TQFruits</code>, vous
|
|
écrirez en PerlTQt :</p>
|
|
</dd>
|
|
<dd>
|
|
<pre>
|
|
$pomme_plus_orange = &TQt::Fruit::Pomme + &TQt::Fruit::Orange;</pre>
|
|
</dd>
|
|
<p></p>
|
|
<dt><strong><a name="item_opérateurs">Opérateurs</a></strong><br />
|
|
</dt>
|
|
<dd>
|
|
Dans PerlTQt, la <strong>surcharge d'opérateurs</strong> fonctionne de manière transparente.
|
|
Si un opérateur est surchargé dans une classe TQt (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 PerlTQt.
|
|
</dd>
|
|
<dd>
|
|
<p>ex-1: surcharge de '+='</p>
|
|
</dd>
|
|
<dd>
|
|
<pre>
|
|
$p1 = TQt::Point(10, 10)
|
|
$p2 = TQt::Point(30,40)
|
|
$p2 += $p1; # $p2 devient (40,50)</pre>
|
|
</dd>
|
|
<dd>
|
|
<p>ex-2: surcharge de '<<'</p>
|
|
</dd>
|
|
<dd>
|
|
<pre>
|
|
$f = TQt::File("example");
|
|
$f->open( IO_WriteOnly ); # voir l'entrée 'Constantes' plus bas
|
|
$s = TQt::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>
|
|
TQt 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>TQt::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 TQt::constants;</pre>
|
|
</dd>
|
|
<dd>
|
|
<p>Et pour importer quelques symboles seulement :</p>
|
|
</dd>
|
|
<dd>
|
|
<pre>
|
|
use TQt::constants qw( IO_ReadOnly IO_WriteOnly );</pre>
|
|
</dd>
|
|
<p></p>
|
|
<dt><strong><a name="item_fonctions_globales">Fonctions globales</a></strong><br />
|
|
</dt>
|
|
<dd>
|
|
TQt dispose de fonctions utilitaires, telles bitBlt, tqCompress, etc.
|
|
</dd>
|
|
<dd>
|
|
<p>Ces fonctions ont été rassemblées dans un espace de nom commun:
|
|
<code>TQt::GlobalSpace</code>.</p>
|
|
</dd>
|
|
<dd>
|
|
<p>Vous pourrez donc y accéder soit par un appel pleinement qualifié :</p>
|
|
</dd>
|
|
<dd>
|
|
<pre>
|
|
TQt::GlobalSpace::tqUncompress( $buffer )</pre>
|
|
</dd>
|
|
<dd>
|
|
<p>Soit en important préalablement ces fonctions dans l'espace de nom courant :</p>
|
|
</dd>
|
|
<dd>
|
|
<pre>
|
|
use TQt::GlobalSpace;
|
|
tqUncompress( $buffer )</pre>
|
|
</dd>
|
|
<dd>
|
|
<p>Bien entendu, vous pouvez aussi n'importer que les fonctions souhaitées :</p>
|
|
</dd>
|
|
<dd>
|
|
<pre>
|
|
use TQt::GlobalSpace qw( tqUncompress 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 TQt::Point(). Ces opérateurs seront appelés
|
|
automatiquement.</p>
|
|
</dd>
|
|
<dd>
|
|
<p>ex:</p>
|
|
</dd>
|
|
<dd>
|
|
<pre>
|
|
$p1 = TQt::Point(10, 10) + TQt::Point(20, 20)</pre>
|
|
</dd>
|
|
<p></p></dl>
|
|
<p>
|
|
</p>
|
|
<hr />
|
|
<h1><a name="annexe_2_:_internationalisation">Annexe 2 : Internationalisation</a></h1>
|
|
<p>PerlTQt résout les problèmes d'internationalisation en convertissant systématiquement les <strong>TQString</strong>
|
|
de TQt en <strong>utf8</strong> côté Perl.</p>
|
|
<p>Les conversions en sens inverse, depuis Perl vers TQt 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 TQString 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 TQString 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 TQString 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 TQt :</p>
|
|
<pre>
|
|
$tr1=TQt::TextCodec::codecForLocale(); # ceci utilisera la locale en vigueur
|
|
$tr2=TQt::TextCodec::codecForName("KOI8-R"); # ceci force l'emploi d'une locale spécifique (Russe)</pre>
|
|
<pre>
|
|
print $tr1->fromUnicode(TQt::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 TQString 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>TQt::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 TQt::debug;</pre>
|
|
<pre>
|
|
use TQt::debug qw|calls autoload verbose|;</pre>
|
|
<p>Avec le pragma <code>use TQt::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 TQt;
|
|
use TQt::debug;
|
|
$a= TQt::Application(\@ARGV);
|
|
$a->libraryPath("chose");</pre>
|
|
<pre>
|
|
--- No method to call for :
|
|
TQApplication::libraryPath('chose')
|
|
Closer candidates are :
|
|
static void TQApplication::addLibraryPath(const TQString&)
|
|
static TQStringList TQApplication::libraryPaths()
|
|
static void TQApplication::removeLibraryPath(const TQString&)
|
|
static void TQApplication::setLibraryPaths(const TQStringList&)</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 TQt 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 TQt.
|
|
<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 TQt.
|
|
<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 PerlTQt, la plupart des objets TQt 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 TQt::StringList, qui serait délicat à manipuler,
|
|
PerlTQt 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 TQt::StringList.</p>
|
|
<pre>
|
|
Liste des marshalleurs (PerlTQt-3.008)
|
|
-----------------------------------------------------------------
|
|
float, double <=> réel Perl (NV)
|
|
char, uchar, int, uint, enum
|
|
long, ulong, short, ushort <=> entier Perl (IV)
|
|
TQString, -&, -* => chaîne Perl (utf8)
|
|
TQString, -&, -* <= chaîne Perl (utf8 ou iso-latin1 ou locale)
|
|
TQCString, -&, -* <=> chaîne Perl (utf8 ou octets, suivant contenu ou pragma "bytes")
|
|
TQStringList, -&, -* => référence à une liste de chaînes Perl (utf8)
|
|
TQByteArray, -&, -* <=> 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)
|
|
TQRgb* <= référence à une liste d'entiers Perl (IV)
|
|
TQCOORD* <= référence à une liste d'entiers Perl (IV)
|
|
void* <=> référence à un entier Perl (IV)
|
|
TQValueList<int>, - *, - & <=> référence à une liste d'entiers Perl (IV)
|
|
TQCanvasItemList, - *, - & => réference à une liste de TQt::CanvasItem
|
|
TQWidgetList, - *, - & <=> réference à une liste de TQt::Widget
|
|
TQObjectList, - *, - & <=> réference à une liste de TQt::Object
|
|
TQFileInfoList, - *, - & <=> réference à une liste de TQt::FileInfo
|
|
TQPtrList<TQTab>, - *, - & <=> réference à une liste de TQt::Tab
|
|
TQPtrList<TQToolBar>, - *, - & <=> réference à une liste de TQt::ToolBar
|
|
TQPtrList<TQNetworkOperation>, - *, - & <=> réference à une liste de TQt::NetworkOperation
|
|
TQPtrList<TQDockWindow>, - *, - & <=> réference à une liste de TQt::DockWindow
|
|
(TQUObject*)</pre>
|
|
|
|
</body>
|
|
|
|
</html>
|