1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
|
<!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>Programming 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="#programming_perlqt">Programming PerlQt</a></li>
<li><a href="#introduction">Introduction</a></li>
<li><a href="#installation">Installation</a></li>
<ul>
<li><a href="#requirements">Requirements</a></li>
<li><a href="#compilation">Compilation</a></li>
<li><a href="#troubleshooting_and_configure_options">Troubleshooting and Configure Options</a></li>
<li><a href="#how_to_install_perlqt_with_user_rights">How to install PerlQt with user rights</a></li>
</ul>
<li><a href="#anatomy_of_perlqt">Anatomy of PerlQt</a></li>
<ul>
<li><a href="#hello_world">Hello World</a></li>
<li><a href="#inheritance_and_objects">Inheritance and Objects</a></li>
<ul>
<li><a href="#a_custom_widget">A Custom Widget</a></li>
<li><a href="#using_attributes">Using Attributes</a></li>
</ul>
<li><a href="#signals_and_slots">Signals and Slots</a></li>
</ul>
<li><a href="#rad_prototyping_with_qt_designer_and_puic">RAD prototyping with Qt Designer and Puic</a></li>
<ul>
<li><a href="#introduction">Introduction</a></li>
<li><a href="#embedding_images">Embedding Images</a></li>
<li><a href="#working_with_.ui_files">Working With <strong>.ui</strong> Files</a></li>
</ul>
<li><a href="#more_development_tools">More development tools</a></li>
<ul>
<li><a href="#pqtapi">pqtapi</a></li>
<li><a href="#pqtsh">pqtsh</a></li>
</ul>
<li><a href="#known_limitations">Known Limitations</a></li>
<li><a href="#credits">Credits</a></li>
<li><a href="#appendix_1_:_c++_conventions_and_their_perl_counterpart">Appendix 1 : C++ conventions and their Perl counterpart</a></li>
<li><a href="#appendix_2_:_internationalization">Appendix 2 : Internationalization</a></li>
<ul>
<ul>
<li><a href="#disabling_utf8">disabling utf-8</a></li>
</ul>
</ul>
<li><a href="#appendix_3_:_debugging_channels">Appendix 3 : Debugging Channels</a></li>
<li><a href="#appendix_4_:_marshallers">Appendix 4 : Marshallers</a></li>
</ul>
<!-- INDEX END -->
<hr />
<p>
</p>
<h1><a name="programming_perlqt">Programming PerlQt</a></h1>
<p><strong>Germain Garand</strong></p>
<p>This document describes a set of Perl bindings for the Qt toolkit. Contact
the author at <<a href="mailto:germain@ebooksfrance.com">germain@ebooksfrance.com</a>></p>
<p>
</p>
<hr />
<h1><a name="introduction">Introduction</a></h1>
<p>PerlQt-3 is Ashley Winters' full featured object oriented interface to
<a href="http://www.trolltech.com">Trolltech</a>'s C++ Qt toolkit v3.0.</p>
<p>It is based on the
<a href="http://webcvs.kde.org/cgi-bin/cvsweb.cgi/kdebindings/smoke">SMOKE</a>
library, a language independent low-level wrapper generated from Qt headers by
Richard Dale's
<a href="http://webcvs.kde.org/cgi-bin/cvsweb.cgi/kdebindings/kalyptus">kalyptus</a>
thanks to David Faure's module.</p>
<p>This document describes the principles of PerlQt programming.
It assumes you have some basic Perl Object Oriented programming knowledge.</p>
<p>Some C++ knowledge is recommended but not required.
It would mostly help you to find your way through <a href="http://doc.trolltech.com">Qt's excellent documentation</a> which is our
ultimate and only reference.
If Qt is installed on your system, then you most probably
also have its documentation. Try the <code>$QTDIR/bin/assistant</code> program.</p>
<p>
</p>
<hr />
<h1><a name="installation">Installation</a></h1>
<p>
</p>
<h2><a name="requirements">Requirements</a></h2>
<p>To compile and use PerlQt, you'll need :</p>
<ul>
<li></li>
a POSIX system
<p></p>
<li></li>
GNU tools : automake(>=1.5), autoconf (>=2.13), aclocal...
<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>
The SMOKE library (Scripting Meta Object Kompiler) is part of <a href="http://www.kde.org">KDE</a>'s <strong>kdebindings</strong> module.
You may want to check if a precompiled version of this module exists for your
system.
PerlQt is packaged with its own copy, so you don't need to check it out.
<p></p></ul>
<p>Perl and Qt's installation is out of the scope of this document. Please refer
to those projects' documentation.</p>
<p>
</p>
<h2><a name="compilation">Compilation</a></h2>
<p>PerlQt uses GNU's Autoconf framework. However, the standard ./configure script is preferably driven
by the Makefile.PL wrapper. All options are forwarded to ./configure :</p>
<pre>
perl Makefile.PL</pre>
<p>If SMOKE is missing, <code>configure</code> will generate its sources.
Then :</p>
<pre>
make</pre>
<pre>
make install</pre>
<p>This will install PerlQt, Puic and Smoke (if needed), as well as the pqtsh and pqtapi utilities.</p>
<p>The preferred install location for SMOKE and Puic is in the KDE3 file system.
If you don't have KDE3 installed, specify a location with <code>configure</code>'s
<code>--prefix</code> option. e.g:</p>
<pre>
perl Makefile.PL --prefix=/usr</pre>
<p>
</p>
<h2><a name="troubleshooting_and_configure_options">Troubleshooting and Configure Options</a></h2>
<p>If Smoke's linking fails or your Qt library was built with very specific
options, run Makefile.PL again with:</p>
<pre>
perl Makefile.PL --with-threshold=0</pre>
<p>When building smoke, configure will check for OpenGL and try to compile
support for it if it is properly installed and supported by Qt.</p>
<p>You may disable this checking with:</p>
<pre>
--disable-GL</pre>
<p>Also, default behaviour is to prefer the Mesa GL library over a proprietary
implementation.
If your system features a proprietary OpenGL library, and you'd like to use
it, specify:</p>
<pre>
--without-Mesa</pre>
<p>
</p>
<h2><a name="how_to_install_perlqt_with_user_rights">How to install PerlQt with user rights</a></h2>
<p>To install PerlQt without super-user rights, simply follow this procedure:</p>
<ul>
<li></li>
Perform a normal configuration, specifying as prefix a directory where you have write permissions :
<pre>
perl Makefile.PL --prefix=~</pre>
<p>The above would install the Smoke library in ~/lib and the puic binary in ~/bin</p>
<p></p>
<li></li>
Reconfigure the Perl module so that it doesn't target the standard perl hierarchy:
<pre>
cd PerlQt
perl Makefile.PL PREFIX=~
cd ..</pre>
<p>Beware : this is not the same Makefile.PL as above, but the one located in the ./PerlQt
subdirectory</p>
<p></p>
<li></li>
Compile and Install
<pre>
make && make install</pre>
<p>In order to use such an installation, you must tell to Perl where to find this extern hierarchy.
This can be done either on the command line:</p>
<pre>
perl -Mlib="~/local/lib/perl/5.x.x" program.pl</pre>
<p>or at the top of your program:</p>
<pre>
use lib qw( ~/local/lib/perl/5.x.x );</pre>
<p>``5.x.x'' should be changed to whatever Perl version your system is running.</p>
<p></p></ul>
<p>
</p>
<hr />
<h1><a name="anatomy_of_perlqt">Anatomy of PerlQt</a></h1>
<p>A typical Qt program using GUI components is based on an event loop.</p>
<p>This basically means that such a program is no more envisioned as a straight
flow where you would need to handle yourself every single events (such as a
mouse click or a key press).</p>
<p>Instead, you just create an <strong>Application</strong> object, create the GUI components it
uses,
define what objects methods need to be called when an event occurs,
and then start the main event loop.</p>
<p>That's all!
Qt will handle all events and dispatch them to the correct subroutine.</p>
<p>Lets see how this process is implemented in a minimal PerlQt program.</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>This program first loads the Qt interface [line 1] and creates the application
object, passing it a reference to the command line arguments array <code>@ARGV</code>
[l.2].
This application object is unique, and may later be accessed from
anywhere through the <strong>Qt::app()</strong> pointer.</p>
<p>At line 3, we create a PushButton, which has no parent (i.e : it won't be
contained nor owned by another widget).
Therefore, we pass to the constructor an <strong>undef</strong> value for the parent argument,
which is PerlQt's way of passing a Null pointer.</p>
<p>After some layouting at [l.4], we tell the application object that our main
widget is this PushButton [l.5]... that way, it will know that closing the
window associated with this widget means : <em>quit the application</em>.</p>
<p>Now the last steps are to make this widget visible (as opposed to
hidden, which is the default) by calling the <strong>show</strong> method on it [l.6] and
to start the application loop [l.7].</p>
<p><strong>Syntax elements summary :</strong></p>
<ol>
<li></li>
All Qt classes are accessed through the prefix <strong>Qt::</strong>, which replaces the
initial <strong>Q</strong> of Qt classes.
When browsing the <a href="http://doc.trolltech.com">Qt documentation</a>, you simply need to change the
name of classes so that <strong>QFoo</strong> reads <strong>Qt::Foo</strong>.
<p></p>
<li></li>
An object is created by calling the <strong>constructor</strong> of the class. It has the
same name as the class itself.
<p>You don't need to say <code>new Qt::Foo</code> or <code>Qt::Foo->new()</code> as most Perl
programmers would have expected.</p>
<p>Instead, you just say :</p>
<pre>
my $object = Qt::<classname>(arg_1, ..., arg_n);</pre>
<p>If you don't need to pass any argument to the constructor, simply say :</p>
<pre>
my $object = Qt::<classname>;</pre>
<p></p>
<li></li>
Whenever you need to pass a Null pointer as an argument, use Perl's <strong>undef</strong>
keyword. Do not pass zero.
Beware: this is by far the most common error in PerlQt programs.
<p>Pointers are arguments preceded by an <strong>*</strong>
character in Qt's documentation (e.g: ``<code>QWidget * widget</code>'').</p>
<p></p></ol>
<p>
</p>
<h2><a name="inheritance_and_objects">Inheritance and Objects</a></h2>
<p>Before we can discuss how Perl subroutines can be called back from Qt, we need
to introduce PerlQt's inheritance mechanism.</p>
<p>PerlQt was designed to couple as tightly as possible Qt's simplicity and Perl's
power and flexibility.</p>
<p>In order to achieve that goal, the classical Object Oriented Perl paradigm had
to be extended, much in the same way than Qt itself
had to extend C++'s paradigm with <strong>metaobjects</strong>.</p>
<p>
</p>
<h3><a name="a_custom_widget">A Custom Widget</a></h3>
<p>Lets rewrite the ``Hello World!'' program, this time using a custom version
of 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>Here, we want to create our own version of the PushButton widget.
Therefore, we create a new package for it [l.3] and import Qt [l.4].</p>
<p>We now want to declare our widget as subclassing PushButton.
This is done through the use of the <code>Qt::isa</code> pragma [l.5], which accepts a
list of one or more parent Qt classes.</p>
<p>It is now time to create a <strong>constructor</strong> for our new widget.
This is done by creating a subroutine called <strong>NEW</strong> <em>(note the capitalized
form, which differentate it from the usual ``new'' constructor. PerlQt's NEW
constructor is called </em><strong>implicitly</strong><em> as can be seen on line 21)</em>.</p>
<p>Since we want our widget to call its parent's constructor first, we call the
<strong>superclass's constructor</strong> (here: Qt::PushButton) on line 9, passing it all
arguments we received.</p>
<p>At this time, a class instance has been created and stored into a special
object holder named <strong>this</strong> (not <code>$this</code> but really just <code>this</code>).</p>
<p>Each time you invoke a method from within your package, you may now
indifferently say <code>method()</code> or <code>this->method()</code>;</p>
<p>
</p>
<h3><a name="using_attributes">Using Attributes</a></h3>
<p>When building a new composite widget, you may just create its different
parts inside <strong>my</strong> variables, since widgets are only deleted by their parents
and not necessarily when their container goes out of scope.</p>
<p>In other words, PerlQt performs clever reference counting to prevent
indesirable deletion of objects.</p>
<p>Now, you'll often want to keep an access to those parts from anywhere inside
your package.
For this purpose, you may use the <strong>this</strong> object's blessed hash, as is usual in Perl,
but that isn't really convenient and you don't have any compile time
checking...</p>
<p>Here come <strong>Attributes</strong>. Attributes are data holders where you can
store any kind of properties for your object.</p>
<p>Declaring new attributes is done through the <code>use Qt::attributes</code> pragma, as is
demonstrated in the following package implementation :</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 = " Foo ";
17: }
18:
19: sub resizeEvent
20: {
21: setText( "w: ". width() ." h: ". height() .
22: "\nt: ". itsTime->elapsed . pData );
23: }
24:
25: 1;</pre>
<br/>
<div class='image'><img src="../images/ex2.png"/></div><p>An attribute itsTime is declared at line 7, and loaded with a <code>Qt::Time</code> object
at line 14.</p>
<p>Since we reimplement the virtual function ``resizeEvent'' [l.19].
each time the main widget is resized, this function will be triggered and
our Button's text updated with values coming from the object [l.21] and from the
attributes we defined [l.22].</p>
<p><strong>Recapitulation</strong></p>
<ul>
<li></li>
In order to inherit a Qt class, a package must contain a
<code>use Qt::isa</code> pragma.
e.g:
<pre>
use Qt::isa "Qt::widget";</pre>
<p></p>
<li></li>
The object constructor is named <strong>NEW</strong> and is implicitly called.
Thus you should not say :
<pre>
my $o = MyButton->NEW("Hello");</pre>
<p>But say :</p>
<pre>
my $o = MyButton("Hello");</pre>
<p></p>
<li></li>
Within a package, the current instance can be accessed through the <strong>this</strong>
variable.
<p>When a member function is called, arguments are loaded as usual in the <strong>@_</strong>
array, but <strong>without</strong> the object pointer itself.</p>
<p>Hence, you shouldn't say :</p>
<pre>
sub myMember
{
my $self = shift;
my $arg = shift;
$arg->doThat($self);
$self->doIt;
}
But :</pre>
<pre>
sub myMember
{
my $arg = shift;
$arg->doThat(this);
doIt;
}</pre>
<p>Furthermore, if you want to call a base class method from a derived class,
you'd use the specal attribute SUPER :</p>
<pre>
sub example
{
print "Now calling the base class\n";
SUPER->example(@_)
}</pre>
<p>Note that the :</p>
<pre>
this->SUPER::Example(@_);</pre>
<p>construct is also available, but will pass the object as first argument.</p>
<p></p>
<li></li>
Whenever you need to store a contained object in your package, you may define it
as an <strong>Attribute</strong> :
<pre>
use Qt::attributes qw(
firstAttribute
...
lastAttribute);</pre>
<p>and then use it as a convenient accessor :</p>
<pre>
firstAttribute = myContainedWidget( this );
firstAttribute->resize( 100, 100 );</pre>
<p></p>
<li></li>
To reimplement a <strong>virtual function</strong>, simply create a <strong>sub</strong> with the
same name in your object.
<p>Existing virtual functions are marked as such in Qt's documentation
(they are prefixed with the ``virtual'' keyword).</p>
<p>You can inspect what virtual function names are being called by Qt at runtime by
putting a <code>use Qt::debug qw( virtual )</code> statement at the top of your program.</p>
<p></p></ul>
<p>
</p>
<h2><a name="signals_and_slots">Signals and Slots</a></h2>
<p>We'll now learn how Qt objects can communicate with each other,
allowing an event occuring, for instance, in a given widget to trigger the
execution of one or several subroutines anywhere inside your program.</p>
<p>Most other toolkits use callbacks for that purpose, but Qt has a much more
powerful and flexible mechanism called <strong>Signals and Slots</strong>.</p>
<p>Signals and slots are used for communication between objects.</p>
<p>This can be thought off as something similar to the wiring between several Hi-fI
components : an amplificator, for instance, has a set of output signals, wich are
emitted wether a listening device is connected to them or not. Also, a tape
recorder deck can start to record when it receives a signal wired to it's input
slot, and it doesn't need to know that this signal is also received by a CD
recorder device, or listened through headphones.</p>
<p>A Qt component behaves just like that. It has several output <strong>Signals</strong> and
several input <strong>Slots</strong> - and each signal can be connected to an unlimited number
of listening slots of the same type, wether they are inside or outside the
component.</p>
<p>The general syntax of this connection process is either :</p>
<p>Qt::Object::connect( sender, SIGNAL 'mysignal(arg_type)',
receiver, SLOT 'myslot(arg_type)');</p>
<p>or</p>
<p>myObject->connect( sender, SIGNAL 'mysignal(arg_type)', SLOT
'myslot(arg_type)');</p>
<p>This mechanism can be extended at will by the declaration of custom Signals and
Slots, through the <code>use Qt::signals</code> and <code>use Qt::slots</code> pragma
(see also the other syntax, later on).</p>
<p>Each declared slot will call the corresponding subroutine in your object,
each declared signal can be raised through the <strong>emit</strong> keyword.</p>
<p><strong>As an example, lets rewrite again our Button package :</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: wasClicked => [],
9: change => ['int', 'int'];
10: use Qt::signals
11: changeIt => ['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 'wasClicked()');
19: this->connect(this, SIGNAL 'changeIt(int,int)', SLOT 'change(int,int)');
20: }
21:
22: sub wasClicked
23: {
24: my $w = width();
25: my $h = height();
26: setText( "w: $w h: $h\nt: ". itsTime->elapsed );
27: emit changeIt($w, $h);
28: }
29:
30: sub change
31: {
32: my ($w, $h) = @_;
33: print STDERR "w: $w h: $h \n";
34: }
35:
36: 1;</pre>
<p>In this package, we define two extra slots and one extra signal.</p>
<p>We know from the Qt Documentation that a clicked PushButton emits a <code>clicked()</code>
signal, so we connect it to our new slot at line 18.</p>
<p>We also connect our signal <code>changeIt</code> to our own <code>change</code> slot- which is
quite stupid, but as an example.</p>
<p>Now, whenever our Button is clicked, the <code>clicked()</code> signal is raised and
triggers the <code>wasClicked()</code> slot. <code>wasClicked</code> then proceeds to emit
the <code>changeIt(int,int)</code> signal [l.27], hence triggering the <code>change(int,int)</code>
slot with two arguments.</p>
<p>Finally, since PerlQt-3.008, an alternative syntax can be used to declare Signals and Slots:</p>
<pre>
sub a_slot : SLOT(int, QString)
{
$int = shift;
$string = shift;
# do something
}</pre>
<p>and</p>
<pre>
sub a_signal : SIGNAL(QString);</pre>
<p>This syntax is perfectly compatible with the traditional
<code>use Qt::signals</code> and <code>use Qt::slots</code> declarations.</p>
<p>Eventually, it can prove good programming practice to mix both syntaxes, by first declaring
Signals/Slots with <code>use Qt::slots/signals</code>, then repeat this declaration
in the actual implementation with the second syntax.</p>
<p>Declarations will be checked for consistency at compile time, and any mismatch
in arguments would trigger a warning.</p>
<p>
</p>
<hr />
<h1><a name="rad_prototyping_with_qt_designer_and_puic">RAD prototyping with Qt Designer and Puic</a></h1>
<p>
</p>
<h2><a name="introduction">Introduction</a></h2>
<ul>
<li><strong><a name="item_note%3a">Note:</a></strong><br />
</li>
As of PerlQt-3.008, a separate PerlQt plugin for Qt Designer is available,
bringing full integration, syntax highlighting, code completion and allowing to run/debug your PerlQt project
entirely from the Designer GUI.
Nevertheless, the below is still accurate with regard to puic command line interaction
and with regard to using Qt Designer <em>without</em> the specific plugin.
<p></p></ul>
<p>As efficient and intuitive as Qt can be, building a complete GUI from scratch
is often a tedious task.</p>
<p>Hopefully, Qt comes with a very sophisticated GUI Builder named Qt
Designer, which is close to a complete integrated development environment.
It features Project management, drag'n drop GUI building, a complete object
browser, graphical interconnection of signals and slots, and much much more.</p>
<p>Qt Designer's output is XML which can be parsed by several command line tools,
among whose is <strong>puic</strong> (the PerlQt User Interface Compiler).</p>
<p>Assuming you have already built an interface file with the Designer,
translating it to a PerlQt program is simply a matter of issuing
one command :</p>
<pre>
puic -x -o program.pl program.ui</pre>
<p>This will generate the package defined in your ui file and a basic main package
for testing purposes.</p>
<p>You may prefer :</p>
<pre>
puic -o package.pm program.ui</pre>
<p>This will only generate the package, which can then be used by a separate
program.</p>
<p>
</p>
<h2><a name="embedding_images">Embedding Images</a></h2>
<p>If you need to <strong>embed images or icons</strong>, it can be done in two ways
:</p>
<ul>
<li><strong><a name="item_inline_embedding">Inline embedding</a></strong><br />
</li>
For this, you need to check the ``Edit->Form Settings->Pixmaps->Save inline''
checkbox inside Qt Designer.
Then : puic -x -o <em>program.pl</em> <em>program.ui</em>
<p></p>
<li><strong><a name="item_image_collection">Image Collection</a></strong><br />
</li>
This option is more complex but also far more powerful and clean.
<p>puic -o <em>Collection.pm</em> -embed <em>unique_identifier</em> <em>image-1</em> ... <em>image-n</em></p>
<p>Then add a <code>use Collection.pm</code> statement to your program's main package.</p>
<p>If you've created a project file in Qt Designer, and added all images
you want to group (through ``Project->Image Collection''), you'll find all those
images inside the directory where your project file (*.pro) is stored, under
/images.
You can then generate the corresponding image collection by issuing :</p>
<p>puic -o <em>Collection.pm</em> -embed <em>identifier</em> ../images/*</p>
<p>You can use as many image collections as you want in a program. Simply add a
<strong>use</strong> statement for each collection.</p>
<p></p></ul>
<p>
</p>
<h2><a name="working_with_.ui_files">Working With <strong>.ui</strong> Files</a></h2>
<p>It will often happen that you need to regenerate your user interface -either
because you changed your initial design, or you want to extend it.
Thus writing your program's code straight in the auto-generated Perl file is
quite a bad idea.
You'd run constantly the risk of overwriting your handcrafted code, or end
up doing lot of copy-paste.</p>
<p>Instead, you may :</p>
<ul>
<li><strong><a name="item_write_slots_implementation_in_the_designer">Write slots implementation in the Designer</a></strong><br />
</li>
In Qt Designer, select the <em>Source</em> tab of the <strong>Object Explorer</strong>.
There you can see a tree-like representation of your classes.
Now if you double-click on the <em>Slots/public</em> entry,
you are prompted with a dialog where you can create a new custom slot for
your module.
Once this is done, the new slot appear inside the <strong>Object Explorer</strong> tree and
clicking on it will bring you to a <strong><Your Class>.ui.h</strong> file where you can write
the actual implementation of your slot.
<p>Keeping all the defaults, it should look like this :</p>
<pre>
void Form1::newSlot()
{
}</pre>
<p>The slot declaration is actually C++ code, but simply ignore it and write
your Perl code straight between the two braces, paying special attention to
indent it at least by one space.</p>
<pre>
void Form1::newSlot()
{
print STDERR "Hello world from Form1::newSlot();
if(this->foo())
{
# do something
}
}</pre>
<p>All Perl code written this way will be saved to the ui.h file, and <strong>puic</strong> will take care of
placing it back in the final program.</p>
<p>Here, after running <strong>puic</strong> on the Form1.ui file, you'd have:</p>
<pre>
sub newSlot
{
print STDERR "Hello world from Form1::newSlot();
if(this->foo())
{
# do something
}
}</pre>
<p></p>
<li><strong><a name="item_subclassing_your_gui">Subclassing your GUI</a></strong><br />
</li>
By using <strong>puic</strong>'s <em>-subimpl</em> option, you may generate a derived module
inheriting your original user interface.
<p>You'd typically generate the derived module once, and write any handcrafted
code in this child.
Then, whenever you need to modify your GUI module, simply regenerate the
parent module, and your child will inherit those changes.</p>
<p>To generate the base module :</p>
<pre>
puic -o Form1.pm form1.ui</pre>
<p>(do this as often as needed, never edit by hand)</p>
<p>To generate the child :</p>
<pre>
puic -o Form2.pm -subimpl Form2 form1.ui</pre>
<p>or</p>
<pre>
puic -o program.pl -x -subimpl Form2 form1.ui</pre>
<p>(do this once and work on the resulting file)</p>
<p></p></ul>
<p>
</p>
<hr />
<h1><a name="more_development_tools">More development tools</a></h1>
<p>PerlQt comes bundled with two simple programs that can help you to find your way through
the Qt API:</p>
<p>
</p>
<h2><a name="pqtapi">pqtapi</a></h2>
<p>pqtapi is a commandline driven introspection tool.</p>
<pre>
usage: pqtapi [-r <re>] [<class>]</pre>
<pre>
options:
-r <re> : find all functions matching regular expression/keyword <re>
-i : together with -r, performs a case insensitive search
-v : print PerlQt and Qt versions
-h : print this help message</pre>
<p>e.g:</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> is a graphical shell that can be used to test the API interactively.
It is fairly self explanatory and includes an interactive example (<code>Help->Example</code>)</p>
<br/>
<div class='image'><img src="../images/pqtsh.png"/></div><p>
</p>
<hr />
<h1><a name="known_limitations">Known Limitations</a></h1>
<p>Templated classes aren't available yet (classes derived from templated classes are).</p>
<p>
</p>
<hr />
<h1><a name="credits">Credits</a></h1>
<p>PerlQt-3 is (c) 2002 Ashley Winters (and (c) 2003 Germain Garand)</p>
<p>Kalyptus and the Smoke generation engine are (c) David Faure and Richard Dale</p>
<p>Puic is (c) TrollTech AS., Phil Thompson and Germain Garand,</p>
<p>The mentioned software is released under the GNU Public Licence v.2 or later.</p>
<p>
</p>
<hr />
<h1><a name="appendix_1_:_c++_conventions_and_their_perl_counterpart">Appendix 1 : C++ conventions and their Perl counterpart</a></h1>
<p>Whenever you want to use a class/method described in Qt's
<a href="http://doc.trolltech.com">documentation</a> (see also the 'assistant' program bundled with Qt)
from PerlQt, you need to follow some simple translation rules.</p>
<dl>
<dt><strong><a name="item_classnames">Classnames</a></strong><br />
</dt>
<ul>
<li></li>
All classnames are changed from a <strong>Q</strong> prefix in Qt to a <strong>Qt::</strong> prefix
in Perl.
e.g: QComboBox is named Qt::ComboBox within PerlQt.
<p></p></ul>
<dt><strong><a name="item_functions">Functions</a></strong><br />
</dt>
<ul>
<li></li>
Functions referenced as <strong>static</strong> are accessed directly, and not through
an object. Thus the static function Foo in class QBar would be accessed from
PerlQt as
<pre>
Qt::Bar::Foo( arg-1,...,arg-n);</pre>
<p>The only notable exceptions are :</p>
<pre>
qApp() will map to Qt::app()
qVersion() will map to Qt::version() # not really needed anymore: we have qVersion(). See Global Functions below.</pre>
<p></p>
<li></li>
Functions referenced as <strong>members</strong> or <strong>Signals</strong> are accessed through an object
with the <strong>-></strong> operator.
e.g:
<pre>
$widget->show;</pre>
<p>There are no fundamental differences between methods and signals, however PerlQt
provides the <strong>emit</strong> keyword as a convenient mnemonic, so that it is clear you
are emitting a 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_by_value">By value</a></strong><br />
</li>
When an argument isn't preceded by the <strong>&</strong> or <strong>*</strong> character, it is passed by
value. For all basic types such as int, char, float and double, PerlQt will
automatically convert litteral and scalar values to the corresponding C++ type.
<p>Thus for a constructor prototype written as follow in the documentation :</p>
<pre>
QSize ( int w, int h )</pre>
<p>You'd say :</p>
<pre>
Qt::Size(8, 12);</pre>
<p></p>
<li><strong><a name="item_by_reference">By reference</a></strong><br />
</li>
When an argument is preceded by the <strong>&</strong> character, it means a reference to an
object or to a type is expected. You may either provide a variable name or a
temporary object :
<pre>
$keyseq = Qt::keySequence( &Qt::CTRL + &Qt::F3 );
$widget->setAccel( $keyseq );
or</pre>
<pre>
$widget->setAccel(Qt::keySequence( &Qt::CTRL + &Qt::F3 );</pre>
<p>If the argument isn't qualified as <strong>const</strong> (constant), it means the passed
object may be altered during the process - you must then provide a variable.</p>
<p></p>
<li><strong><a name="item_by_pointer">By pointer</a></strong><br />
</li>
When an argument is preceded by the <strong>*</strong> character, it means a
pointer to an object or to a type is expected. You may provide a variable
name or the Perl <strong>undef</strong> keyword for a Null pointer.
<p>Similarly, if the argument isn't <strong>const</strong>, the passed object may be altered by
the method call.</p>
<p></p></ul>
<dt><strong><a name="item_enumerations">Enumerations</a></strong><br />
</dt>
<dd>
Enumerations are sort of named aliases for numeric values that would be hard to
remember otherwise.
</dd>
<dd>
<p>A C++ example would be :</p>
</dd>
<dd>
<pre>
enum Strange { Apple, Orange, Lemon }</pre>
</dd>
<dd>
<p>where <code>Strange</code> is the generic enumeration name, and <code>Apple</code>, <code>Orange</code>,
<code>Lemon</code> its possible values, which are only aliases for numbers (here 0, 1
and 2).</p>
</dd>
<dd>
<p>Access to enumerations values in Perl Qt is very similar to a static function
call. In fact, it <strong>is</strong> a static function call.</p>
</dd>
<dd>
<p>Therefore, since you probably want to avoid some readability problems, we
recommend the use of the alternate function call syntax : <code>&function</code>.</p>
</dd>
<dd>
<p>Lets now go back to our <code>Strange</code> example.</p>
</dd>
<dd>
<p>If its definition was encountered in the class <code>QFruits</code>, you'd write from
PerlQt :</p>
</dd>
<dd>
<pre>
$apple_plus_orange = &Qt::Fruit::Apple + &Qt::Fruit::Orange;</pre>
</dd>
<p></p>
<dt><strong><a name="item_operators">Operators</a></strong><br />
</dt>
<dd>
Within PerlQt, <strong>operators overloading</strong> works transparently.
If a given operator is overloaded in a Qt class (which means using it triggers a custom method)
it will behave identically in PerlQt.
Beware though that due to limitations of the Smoke binding library, not all overloaded operators are
available in PerlQt.
You can check the availability of a given operator by using the pqtapi program.
Also, due to outstanding differences between C++'s and Perl's object paradigm, the copy constructor operator (a.k.a '=')
has been disabled.
</dd>
<dd>
<p>e.g-1: '+=' overload</p>
</dd>
<dd>
<pre>
$p1 = Qt::Point(10, 10)
$p2 = Qt::Point(30,40)
$p2 += $p1; # $p2 becomes (40,50)
e.g-2: '<<' overload</pre>
</dd>
<dd>
<pre>
$f = Qt::File("example");
$f->open( IO_WriteOnly ); # see 'Constants' below
$s = Qt::TextStream( $f );
$s << "What can I do with " << 12 << " apples?";</pre>
</dd>
<p></p>
<dt><strong><a name="item_constants">Constants</a></strong><br />
</dt>
<dd>
Qt doesn't use many constants, but there is at least one place where they are used : for setting
Input/Output flags on files.
In order to avoid the namespace pollution induced by global constants, PerlQt group them in the <strong>Qt::constants</strong> module.
For instance, requesting the importation of all IO constants into the current namespace would be done with:
</dd>
<dd>
<pre>
use Qt::constants;</pre>
</dd>
<dd>
<p>You may also import specific symbols:</p>
</dd>
<dd>
<pre>
use Qt::constants qw( IO_ReadOnly IO_WriteOnly );</pre>
</dd>
<p></p>
<dt><strong><a name="item_global_functions">Global Functions</a></strong><br />
</dt>
<dd>
Qt has also some utilitarian functions such as bitBlt, qCompress, etc.
</dd>
<dd>
<p>Those were global scope functions and have been grouped in a common namespace:
<code>Qt::GlobalSpace</code>.</p>
</dd>
<dd>
<p>Hence, you shall access this namespace either with a fully qualified call:</p>
</dd>
<dd>
<pre>
Qt::GlobalSpace::qUncompress( $buffer )</pre>
</dd>
<dd>
<p>Or directly, after importation in the current namespace:</p>
</dd>
<dd>
<pre>
use Qt::GlobalSpace;
qUncompress( $buffer )</pre>
</dd>
<dd>
<p>Of course, you may selectively import a few functions:</p>
</dd>
<dd>
<pre>
use Qt::GlobalSpace qw( qUncompress bitBlt )</pre>
</dd>
<dd>
<p><strong>Note:</strong> GlobalSpace has also operators, such has the one performing an addition on two
Qt::Point(). Those operators are called automatically.</p>
</dd>
<dd>
<p>e.g:</p>
</dd>
<dd>
<pre>
$p1 = Qt::Point(10, 10) + Qt::Point(20, 20)</pre>
</dd>
<p></p></dl>
<p>
</p>
<hr />
<h1><a name="appendix_2_:_internationalization">Appendix 2 : Internationalization</a></h1>
<p>PerlQt handles internationalization by always converting <strong>QString</strong> back to <strong>utf8</strong> in Perl.</p>
<p>Conversions from Perl strings to QStrings are made according to context :</p>
<ul>
<li><strong><a name="item_if_the_perl_string_is_already_utf8%2dencoded">If the Perl string is already utf8-encoded</a></strong><br />
</li>
then the string will be converted straight to QString.
<p>This is the most convenient and seemless way of internationalizing your application. Typically, one would just enable
the use of utf8 in source code with the <code>use utf8</code> pragma and write its application with an utf8 aware editor.</p>
<p></p>
<li><strong><a name="item_if_the_string_isn%27t_tagged_as_utf8%2c_and_the_us">If the string isn't tagged as utf8, and the <strong>use locale</strong> pragma is not set</a></strong><br />
</li>
then the string will be converted to QString's utf8 from <strong>ISO-Latin-1</strong>.
<p></p>
<li><strong><a name="item_if_the_string_isn%27t_tagged_as_utf8_and_the_use_l">If the string isn't tagged as utf8 and the <strong>use locale</strong> pragma is set</a></strong><br />
</li>
then the string will be converted to QString's utf8 according to the currently set <strong>locale</strong>.
<p></p></ul>
<p>Once a string contains utf8, you can convert it back to any locale by setting up <strong>converters</strong> :</p>
<pre>
$tr1=Qt::TextCodec::codecForLocale(); # this one will use current locale
$tr2=Qt::TextCodec::codecForName("KOI8-R"); # that one forces a specific locale (Russian)</pre>
<pre>
print $tr1->fromUnicode(Qt::DateTime::currentDateTime()->toString)."\n\n";
print $tr2->fromUnicode($my_utf8_string);</pre>
<p>Or, with Perl >= 5.8.0, you may use Perl's <strong>Encode</strong> modules (see <code>perldoc Encode</code>).</p>
<p>
</p>
<h3><a name="disabling_utf8">disabling utf-8</a></h3>
<p>Developers who don't want to use UTF-8 or want to temporarily disable UTF-8 marshalling
for handling legacy programs may use the <strong>use bytes</strong> pragma (and the corresponding <strong>no bytes</strong>).</p>
<p>Within the scope of this pragma, QStrings are marshalled back to ISO-Latin1 (default) or to your locale
(if <strong>use locale</strong> has been set).</p>
<p>Frivole use of this pragma is strongly discouraged as it ruins worldwide standardization efforts.</p>
<p>
</p>
<hr />
<h1><a name="appendix_3_:_debugging_channels">Appendix 3 : Debugging Channels</a></h1>
<p>The <strong>Qt::debug</strong> module offers various debugging channels/features.</p>
<pre>
use Qt::debug;</pre>
<pre>
use Qt::debug qw|calls autoload verbose|;</pre>
<p>With the simple <code>use Qt::debug</code> statement, the <strong>verbose</strong> and <strong>ambiguous</strong> channels are activated.
If you specify a list of channels within the use statement, then only the specified channels will be enabled.</p>
<p><strong>Available channels :</strong></p>
<ul>
<li><strong><a name="item_ambiguous">ambiguous</a></strong><br />
</li>
Check if method and function calls are ambiguous, and tell which of the alternatives
was finally elected.
<p></p>
<li><strong><a name="item_verbose">verbose</a></strong><br />
</li>
Enable more verbose debugging.
<p>Together with <strong>ambiguous</strong>, tell you the nearest matches in case
a method or function call fails.
e.g:</p>
<pre>
use Qt;
use Qt::debug;
$a= Qt::Application(\@ARGV);
$a->libraryPath("foo");</pre>
<pre>
--- No method to call for :
QApplication::libraryPath('foo')
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>
For every call, tell what corresponding Qt method is called
(detailing the arguments if <strong>verbose</strong> is on).
<p></p>
<li><strong><a name="item_autoload">autoload</a></strong><br />
</li>
Track the intermediate code between a method invocation in Perl
and its resolution to either a Qt or Perl call.
<p></p>
<li><strong><a name="item_gc">gc</a></strong><br />
</li>
Give informations about garbage collection
whenever a Qt object is deleted and/or a Perl object is destroyed
<p></p>
<li><strong><a name="item_virtual">virtual</a></strong><br />
</li>
Report whenever a virtual function tries to access its Perl
reimplementation (wether it exists or not).
<p></p>
<li><strong><a name="item_all">all</a></strong><br />
</li>
Enable all channels
<p></p></ul>
<p>
</p>
<hr />
<h1><a name="appendix_4_:_marshallers">Appendix 4 : Marshallers</a></h1>
<p>A marshaller is a piece of ``glue code'' translating a given datatype to another.</p>
<p>Within PerlQt, most Qt objects keep their object nature, so that one may invoke methods on them.
However, some classes and datatypes map so naturally to some Perl types that keeping their object nature would
would feel unnatural and clumsy.</p>
<p>For instance, instead of returning a Qt::StringList object, which would require an iterator to retrieve its content,
PerlQt will translate it to an array reference containing all the object's strings.</p>
<p>In the other way, instead of providing a Qt::StringList object as an argument of a method, one would simply
provide the reference to an array of Perl strings.</p>
<p>Here is the list of Marshallers as of PerlQt-3.008 :</p>
<pre>
-----------------------------------------------------------------
float, double <=> Perl real (NV)
char, uchar, int, uint, enum
long, ulong, short, ushort <=> Perl integer (IV)
QString, -&, -* => Perl string (utf8)
QString, -&, -* <= Perl string (utf8 or iso-latin1 or locale)
QCString, -&, -* <=> Perl string (utf8 or bytes, according to content or "bytes" pragma)
QByteArray, -&, -* <=> Perl string (bytes)
QStringList, -&, -* => Reference to an array of Perl strings (utf8)
QString, -&, -* => Perl string (utf8 or iso-latin1 or locale)
int&, -* <=> Perl integer (IV)
bool&, -* <=> Perl boolean
char* <=> Perl string (bytes)
char** <= Reference to an array of Perl strings (bytes)
uchar* <= Perl string (bytes)
QRgb* <= Reference to an array of Perl integers (IV)
QCOORD* <= Reference to an array of Perl integers (IV)
void* <=> Reference to a Perl integer (IV)
QValueList<int>, - *, - & <=> Reference to an array of Perl integers (IV)
QCanvasItemList, - *, - & => Reference to an array of Qt::CanvasItem
QWidgetList, - *, - & <=> Reference to an array of Qt::Widget
QObjectList, - *, - & <=> Reference to an array of Qt::Object
QFileInfoList, - *, - & <=> Reference to an array of Qt::FileInfo
QPtrList<QTab>, - *, - & <=> Reference to an array of Qt::Tab
QPtrList<QToolBar>, - *, - & <=> Reference to an array of Qt::ToolBar
QPtrList<QNetworkOperation>, - *, - & <=> Reference to an array of Qt::NetworkOperation
QPtrList<QDockWindow>, - *, - & <=> Reference to an array of Qt::DockWindow
(QUObject*)
</pre>
</body>
</html>
|
