This repository was archived by the owner on Apr 2, 2023. It is now read-only.
-
-
Notifications
You must be signed in to change notification settings - Fork 17
/
Copy pathabout.html
2836 lines (2371 loc) · 767 KB
/
about.html
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
<!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <meta charset="utf-8"> <title>Qtools</title> <meta name="viewport" content="width=device-width"> <meta name="description" content="A collection of tools to aid in development with CommonQt."> <meta name="author" content="Nicolas Hafner <[email protected]>"> <style type="text/css"> body{
max-width: 1024px;
margin: 0 auto 0 auto;
font-family: sans-serif;
color: #333333;
font-size: 14pt;
padding: 5px;
}
body>header{
display:flex;
align-items: center;
justify-content: center;
flex-direction: column;
max-width: 100%;
text-align: center;
}
body>header img{
max-width: 50%;
}
img{
max-width: 100%;
max-height: 100%;
}
code{
font-family: Consolas, Inconsolata, monospace;
}
a{
text-decoration: none;
color: #0055AA;
}
a img{
border: none;
}
#documentation{
text-align: justify;
}
#documentation pre{
margin-left: 20px;
overflow: auto;
}
#documentation img{
margin: 5px;
}
#symbol-index>ul{
list-style: none;
padding: 0;
}
#symbol-index .package>ul{
list-style: none;
padding: 0 0 0 10px;
}
#symbol-index .package .nicknames{
font-weight: normal;
}
#symbol-index .package h4{
display: inline-block;
margin: 0;
}
#symbol-index .package article{
margin: 0 0 15px 0;
}
#symbol-index .package article header{
font-size: 1.2em;
font-weight: normal;
}
#symbol-index .package .name{
margin-right: 5px;
}
#symbol-index .package .docstring{
margin: 0 0 0 15px;
white-space: pre-wrap;
font-size: 12pt;
}
@media (max-width: 800px){
body{font-size: 12pt;}
} </style> </head> <body> <header> <h1><img alt="qtools" src="qtools-logo.png"></h1> <span class="version">1.0.0</span> <p class="description">A collection of tools to aid in development with CommonQt.</p> </header> <main> <article id="documentation"> <div><h2 id="about_qtools_">About Qtools <a href="https://travis-ci.org/Shinmera/qtools"><img src="https://travis-ci.org/Shinmera/qtools.svg?branch=master" alt="Build Status" align="right"></a></h2> <p>Qtools is a collection of utilities to help development with CommonQt. There are a lot of things in there, from name mapping over garbage handling to widget class definition. Some tools are straightforward, others are quite complex. I'll try to explain everything as best I can.</p> <h2 id="fundamentals">Fundamentals</h2> <p>There are three layers working beneath Qtools, of which you need to know about in order to understand how to use the various facilities Qtools offers.</p> <h3 id="qt"><a href="http://qt-project.org/doc/qt-4.8/">Qt</a></h3> <p>Qt is a gigantic toolkit that mainly concerns itself with GUI creation. It is cross-platform and written in C++. While its size and large user-base means that it is very mature and usable for pretty much any kind of GUI, the fact that it's written in C++ makes things complicated. The usual way to interoperate with C++ libraries and projects is to create a C API wrapper.</p> <h3 id="smoke"><a href="https://techbase.kde.org/Development/Languages/Smoke">Smoke</a></h3> <p>And this is what Smoke does. It generates a C wrapper so that other languages can make use of Qt through C-FFI. Smoke is divided up into a bunch of modules, each being associated with a part of Qt, such as qtcore, qtgui, qtopengl, phonon, etc.</p> <h3 id="commonqt"><a href="http://common-lisp.net/project/commonqt/">CommonQt</a></h3> <p>The heavy lifting and ground-work that is required to interface with Smoke (and thus with Qt) is done by CommonQt. By itself, CommonQt offers a complete framework to create Qt GUIs from Common Lisp out.</p> <h3 id="qtools"><a href="https://shinmera.github.io/qtools/">Qtools</a></h3> <p>Unfortunately, working with CommonQt itself is a bit awkward. While it offers everything you need, the way you have to make use of it is sub-par. Qtools attempts to help with this by offering another layer over CommonQt to smooth everything out. However, since you might not like certain parts of the Qtools ecosystem, it should be possible for you to only use the features you like, rather than being forced to use everything. So, you can always mix and match "plain" CommonQt and Qtools extensions.</p> <h2 id="getting_started">Getting Started</h2> <h3 id="qt">Qt</h3> <p>In case you already know Qt, you may skip this part and go straight to the next section. I'll briefly explain some of the core Qt concepts and how they fit together. However, you should still read the <a href="http://doc.qt.io/qt-4.8/">official Qt documentation</a> for anything that's left unclear.</p> <p>Since Qt is a C++ library it is heavily focused around classes and methods. At the top of the class hierarchy sits <a href="http://doc.qt.io/qt-4.8/qobject.html">QObject</a>. Almost all classes in Qt inherit from this. The more important one for us however is the <a href="http://doc.qt.io/qt-4.8/qwidget.html">QWidget</a> class, which already gives you everything you need to get started. It can act as a window or be contained in other widgets. It has all the sizing mechanics and is properly hooked into the event system that allows you to catch when keys are pressed, the window is resized, and so forth.</p> <p>Usually you create your new widgets by subclassing something like QWidget and then overriding methods to do what you want or simply attach other widgets to it and connect them up so that they can communicate to each other via the signal system. Classes have slots and signals. Signals are a form of method signature that describe a list of arguments and their type. Slots are the corresponding methods that perform actions when a signal reaches them. Wiring things up functions by connecting a signal and a source instance to a slot and a target instance. When then a signal is signalled onto the source instance, the target instance's slot method is called.</p> <p>And that's pretty much all of the core mechanics that you need to know about. For everything else, you usually refer to the documentation page for the specific class involved and see what kind of methods or signals you can use to do what you want. Seriously, the docs are good. I use them constantly while developing.</p> <h3 id="qtools">Qtools</h3> <p>Before getting started with explaining the details on the various parts of Qtools, I'll go through a basic project setup of a project using it.</p> <p>First you will want an ASDF system to define your project. In its dependencies it should contain <code>:qtools</code> and the smoke modules you require, usually just <code>:qtcore</code> and <code>:qtgui</code>.</p> <pre><code>(asdf:defsystem qtools-intro
...
:depends-on (:qtools :qtcore :qtgui))
</code></pre> <p>If you want to just try things out on the REPL real quick, just <code>(ql:quickload '(qtools qtcore qtgui))</code> should suffice.</p> <p>Then of course you'll usually want a package to put all your stuff in. Instead of <code>:use #:cl</code> you will most likely want to <code>:use #:cl+qt</code>. This package combines the symbols of the common-lisp base package, the commonqt package, and qtools. Thus all the symbols and functions you usually need for development are already included.</p> <pre><code>(<a href="#CL+QT:DEFPACKAGE">defpackage</a> #:qtools-intro
(:use #:cl+qt)
(:export #:main))
</code></pre> <p>CommonQt, and Qtools itself, require a few extensions to the standard reader syntax. For this reason you will want to change the readtable using <code><a href="#CL+QT:IN-READTABLE">named-readtables:in-readtable</a></code>, which <code>cl+qt</code> includes. Readtable changes are on a <em>per-file</em> basis, so you need both an <code><a href="#CL+QT:IN-PACKAGE">in-package</a></code> and an <code><a href="#CL+QT:IN-READTABLE">in-readtable</a></code> call on every file.</p> <pre><code>(<a href="#CL+QT:IN-PACKAGE">in-package</a> #:qtools-intro)
(<a href="#CL+QT:IN-READTABLE">in-readtable</a> :qtools)
</code></pre> <p>This sets up everything you need to get started writing an actual GUI. So let's do that as well. In Qt things are organised as widgets. Windows are widgets, buttons are widgets, text fields are widgets, etc. Qtools mirrors this.</p> <pre><code>(<a href="#QTOOLS:DEFINE-WIDGET">define-widget</a> main-window (QWidget)
())
</code></pre> <p>This <code><a href="#QTOOLS:DEFINE-WIDGET">define-widget</a></code> form is syntactically equivalent to <code><a href="#CL+QT:DEFCLASS">defclass</a></code>. The only change is that the first argument in the superclass list is the Qt class to inherit from. Now we'll want to add some things to display in the widget.</p> <pre><code>(<a href="#QTOOLS:DEFINE-SUBWIDGET">define-subwidget</a> (main-window name) (<a href="#Q+:MAKE-QLINEEDIT">q+:make-qlineedit</a> main-window)
(<a href="#CL+QT:SETF">setf</a> (<a href="#Q+:PLACEHOLDER-TEXT">q+:placeholder-text</a> name) "Your name please."))
(<a href="#QTOOLS:DEFINE-SUBWIDGET">define-subwidget</a> (main-window go) (<a href="#Q+:MAKE-QPUSHBUTTON">q+:make-qpushbutton</a> "Go!" main-window))
</code></pre> <p>This adds a QLineEdit widget called <code>name</code> to the <code>main-window</code> and sets its placeholder text to <code>"Your name please."</code>. The second form adds a button called <code><a href="#CL+QT:GO">go</a></code> with a label of <code>"Go!"</code>. Simple stuff. The body of the <code><a href="#QTOOLS:DEFINE-SUBWIDGET">define-subwidget</a></code> form can contain any number of statements. By default, the symbols of all the other subwidgets and slots defined prior to the <code><a href="#QTOOLS:DEFINE-SUBWIDGET">define-subwidget</a></code> form are bound to their corresponding values. This is useful if you for example need to define a layout, as we will do now.</p> <pre><code>(<a href="#QTOOLS:DEFINE-SUBWIDGET">define-subwidget</a> (main-window layout) (<a href="#Q+:MAKE-QHBOXLAYOUT">q+:make-qhboxlayout</a> main-window)
(<a href="#Q+:ADD-WIDGET">q+:add-widget</a> layout name)
(<a href="#Q+:ADD-WIDGET">q+:add-widget</a> layout go))
</code></pre> <p>This sets up the displaying part of our GUI, but so far we haven't made it react to anything yet. Reacting to events in Qt happens through signals and slots. Slots are functions that receive signals, and signals are event carriers.</p> <pre><code>(<a href="#QTOOLS:DEFINE-SIGNAL">define-signal</a> (main-window name-set) (<a href="#CL+QT:STRING">string</a>))
(<a href="#QTOOLS:DEFINE-SLOT">define-slot</a> (main-window go) ()
(<a href="#CL+QT:DECLARE">declare</a> (<a href="#QTOOLS:CONNECTED">connected</a> go (pressed)))
(<a href="#CL+QT:DECLARE">declare</a> (<a href="#QTOOLS:CONNECTED">connected</a> name (return-pressed)))
(<a href="#QTOOLS:SIGNAL!">signal!</a> main-window (name-set string) (<a href="#Q+:TEXT">q+:text</a> name)))
(<a href="#QTOOLS:DEFINE-SLOT">define-slot</a> (main-window name-set) ((new-name string))
(<a href="#CL+QT:DECLARE">declare</a> (<a href="#QTOOLS:CONNECTED">connected</a> main-window (name-set string)))
(<a href="#Q+:QMESSAGEBOX-INFORMATION">q+:qmessagebox-information</a> main-window "Greetings" (<a href="#CL+QT:FORMAT">format</a> NIL "Good day to you, ~a!" new-name)))
</code></pre> <p>We're doing things a bit roundabout here to illustrate creating signals. <code><a href="#QTOOLS:DEFINE-SIGNAL">define-signal</a></code> introduces a new signal called <code>name-set</code> that takes a single <code><a href="#CL+QT:STRING">string</a></code> as argument. We then define a new slot that is connected to the <code><a href="#CL+QT:GO">go</a></code> button's <code>pressed</code> signal (which has no arguments) as well as the <code>name</code> field's <code>return-pressed</code>. We then simply fetch the current text of our <code>name</code> field and send it out again with our custom signal. The second slot catches this signal again and uses it to display a message box.</p> <p>You can now try and see what kind of magical wonders you have created by using <code><a href="#QTOOLS:WITH-MAIN-WINDOW">with-main-window</a></code> to launch everything: <code>(<a href="#QTOOLS:WITH-MAIN-WINDOW">with-main-window</a> (window 'main-window))</code>. This will block until your window is closed, as Qt needs to capture the thread to handle events.</p> <p>And that's that. The only thing we didn't take a look at here is <code><a href="#QTOOLS:DEFINE-OVERRIDE">define-override</a></code>, which allows you to define override functions for your Qt classes. So, if you for example want to manually draw onto a widget you can override its <code>paintEvent</code> method using this.</p> <pre><code>(<a href="#QTOOLS:DEFINE-OVERRIDE">define-override</a> (main-window paint-event) (event)
(<a href="#CL+QT:DECLARE">declare</a> (<a href="#CL+QT:IGNORE">ignore</a> event))
(<a href="#QTOOLS:WITH-FINALIZING">with-finalizing</a> ((painter (<a href="#Q+:MAKE-QPAINTER">q+:make-qpainter</a> main-window)))
(<a href="#Q+:FILL-RECT">q+:fill-rect</a> painter (<a href="#Q+:RECT">q+:rect</a> main-window) (<a href="#Q+:QT.WHITE">q+:qt.white</a>))))
</code></pre> <p>This'll make the background of our window completely white. The important thing to note here is the <code><a href="#QTOOLS:WITH-FINALIZING">with-finalizing</a></code>. What has been rather well hidden from you so far, is that as Qt is a C++ framework, you will have to do manual memory management. Qtools makes this a lot easier by offering macros and automations to take most of it off of your hands. For example, all the sub widgets we defined are automatically deleted once the main window is.</p> <p>A general note about developing with Qtools/CommonQt: While custom function bodies such as from qt-slots, overrides, initializers, and finalizers reside on the CL side and can thus be redefined at any time and take effect immediately, adding or removing qt-slots and overrides will not affect already created instances. This is to say, if you run your application and recompile your override, the effect will be visible immediately. But if you add a new slot, override, or signal, the existing instance will not have them. This is due to the fact that these things need to be tied to the C++ class, which will not update existing instances when it is changed, like CLOS usually does. This means that if you change a running widget by adding new components, you need to recreate or restart it to see the effects.</p> <h2 id="deployment">Deployment</h2> <p>So, you've built a neat little Qt application and you would like to deploy it and ship it to people that aren't developers. For this, you will want to dump a binary and bundle it together with the necessary shared libraries. Qtools will take care of this for you, to the point where it becomes very trivial to do.</p> <p>You will need an ASDF system that compiles your program and add the following options to your system definition:</p> <pre><code>:defsystem-depends-on (:qtools)
:build-operation "qt-program-op"
:build-pathname "executable-name"
:entry-point "my-package:my-launch-function"
</code></pre> <p>You can change the string of <code>:build-pathname</code> to whatever pathname-name you'd like your executable to have. You should change the stirng of <code>:entry-point</code> to be a designator for an external symbol that is either your main window class name, or a function that handles the launching of your GUI.</p> <p>Once you have updated your ASD, you should launch a clean instance of your implementation from the command line -- make sure not to load slime or anything else that creates threads. Then simply invoke <code>(asdf:operate :build-op :system-name :force T)</code>. For sbcl, that would be:</p> <pre><code>sbcl --eval "(asdf:operate :build-op :system-name :force T)"
</code></pre> <p>This will compile your system, gather some info on it, copy the necessary shared libraries to the deployment folder, and finally dump an image with your system ready to go. It should put it all into a new <code>bin</code> folder within your project's root. If everything went right, you should be able to just launch the executable within and be greeted with your nice GUI. You can then just ZIP up the build folder and ship that-- it should contain all of the necessary shared library dependencies to run outside of your development environment.</p> <p>As an example for a working system that can be deployed, have a look at <a href="https://github.com/shinmera/halftone">halftone</a> or <a href="https://github.com/shirakumo/cl-gamepad">cl-gamepad-visualizer</a>.</p> <p>For more customisation and other details of the deployment system, see the underlying library <a href="https://shinmera.github.io/deploy/">Deploy</a>.</p> <p>If you need to debug the built binary on Windows, the default behaviour is a bit annoying, as it causes Windows to completely prevent all terminal output. To circumvent this, you must either run it under mintty, or deploy it with the feature <code>:qtools-deploy-console</code> set before the build-op.</p> <h2 id="qtools_components">Qtools Components</h2> <h3 id="name_conversion">Name Conversion</h3> <p>Common Lisp and C++ follow different naming conventions for classes, variables, methods, and types. Qtools offers a couple of functions to attempt to translate between the two. Finding a Qt class can be done with <code><a href="#QTOOLS:FIND-QT-CLASS-NAME">find-qt-class-name</a></code>. It searches a static table of known Qt classes (<code><a href="#QTOOLS:*QT-CLASS-MAP*">*qt-class-map*</a></code>) by first stripping all dashes from the name, and then case-insensitively finding a matching name.</p> <p>Translating method names can be done through <code><a href="#QTOOLS:TO-METHOD-NAME">to-method-name</a></code>, which translates dashes to mean that the next character should be in uppercase. So <code>foo-bar</code> is <code>fooBar</code>. In case you pass it a string instead of a symbol however, it will not do any translation. This is important to take care of edge-cases, where this primitive translation would prohibit using a certain name. If you need a method signature instead of just a name, there are <code><a href="#QTOOLS:SPECIFIED-TYPE-METHOD-NAME">specified-type-method-name</a></code> that takes a name and a list of type specifiers, and <code><a href="#QTOOLS:DETERMINED-TYPE-METHOD-NAME">determined-type-method-name</a></code>, which attempts to determine the type of the arguments, rather than requiring type specifiers directly.</p> <p>Types are translated using <code><a href="#QTOOLS:QT-TYPE-OF">qt-type-of</a></code>, <code><a href="#QTOOLS:EQT-TYPE-OF">eqt-type-of</a></code>, <code><a href="#QTOOLS:QT-TYPE-FOR">qt-type-for</a></code>, and <code><a href="#QTOOLS:TO-TYPE-NAME">to-type-name</a></code>. Where <code><a href="#QTOOLS:QT-TYPE-FOR">qt-type-for</a></code> translates a type specifier and <code><a href="#QTOOLS:QT-TYPE-OF">qt-type-of</a></code> tries to determine the type through a value. Reversing from a Qt type specifier to a CL type is possible with <code><a href="#QTOOLS:CL-TYPE-FOR">cl-type-for</a></code> and <code><a href="#QTOOLS:ECL-TYPE-FOR">ecl-type-for</a></code>.</p> <h3 id="object_handling">Object Handling</h3> <p>In C++ there usually is no garbage collector, so you need to carefully clean up yourself or you'll create a memory leak. In Common Lisp we're used to the luxury of not having to worry about this, thanks to garbage collection. Sadly, we cannot use the garbage collector to also take care of C++ objects, as they live in a different world not governed by us. So, garbage collection of Qt objects is still our own worry.</p> <p>To make this all just a smidgeon easier, Qtools introduces a system of <em>finalizables</em>, the central point of which is the <code><a href="#QTOOLS:FINALIZE">finalize</a></code> generic function. This function should take care of all necessary cleanup when an object is no longer needed. For <code><a href="#CL+QT:QOBJECT">qobject</a></code>s, this means running eventual cleanup (through <code>finalize-using-class</code>) and then being <code><a href="#CL+QT:DELETE">delete</a></code>d, thus properly removed from memory. However, <code><a href="#QTOOLS:FINALIZE">finalize</a></code> can not only be used for Qt objects, but for anything else as well. Especially interesting here are <code><a href="#QTOOLS:FINALIZABLE">finalizable</a></code> objects, whose slots can specify an additional argument <code>:finalized</code>, which dictates whether <code><a href="#QTOOLS:FINALIZE">finalize</a></code> is run on the slot's value when the class instance is <code><a href="#QTOOLS:FINALIZE">finalize</a></code>d.</p> <p>Often times we only need Qt instances for a certain lexical context of code. For this case, <code><a href="#QTOOLS:WITH-FINALIZING">with-finalizing</a></code> (and <code><a href="#QTOOLS:WITH-FINALIZING*">with-finalizing*</a></code>) can be used, which is a counterpart to <code><a href="#CL+QT:LET">let</a></code> that calls <code><a href="#QTOOLS:FINALIZE">finalize</a></code> on all its bindings once the form exits. This will take care of most cases. For cases where the instance may escape, or has to stay bound in a closure, there's <code><a href="#QTOOLS:WITH-GC-FINALIZED">with-gc-finalized</a></code>. This wraps the value of each binding in a <code><a href="#QTOOLS:GC-FINALIZED">gc-finalized</a></code> object. Using such a container, we can use Common Lisp's garbage collector to keep track of the references and, once the object is garbage collected it calls <code><a href="#QTOOLS:FINALIZE">finalize</a></code> on its inner value, ensuring proper removal. The <code><a href="#QTOOLS:WITH-GC-FINALIZED">with-gc-finalized</a></code> uses a <code><a href="#CL+QT:SYMBOL-MACROLET">symbol-macrolet</a></code> to ensure that you don't have to worry about the boxing. However, if you manually use <code><a href="#QTOOLS:GC-FINALIZED">gc-finalized</a></code> objects, there's the <code><a href="#QTOOLS:MAKE-GC-FINALIZED">make-gc-finalized</a></code> and <code><a href="#QTOOLS:UNBOX">unbox</a></code> functions (with corresponding reader macros <code>#></code> and <code>#<</code> in the <code>:qtools</code> read-table).</p> <p>While this kind of system takes care of a lot of cases, it's still not perfect and it may happen that you accidentally create a memory leak somewhere. I wish there was an easier way, but alas, life is difficult. You can try to solve this kind of situation by debugging Qtools and keeping track of which objects get finalized and which don't.</p> <p>Another occasional task is to copy an object instance. Qtools offers a <code><a href="#QTOOLS:COPY">copy</a></code> and <code>copy-using-class</code> methods which handle proper copying for a couple of Qt objects, but sadly by far not all. If you want to use the copying system for a class that isn't handled by Qtools by default, you can define your own using <code><a href="#QTOOLS:DEFINE-COPY-METHOD">define-copy-method</a></code>.</p> <p>Qtools will handle the printing of QObject instances as well and provides you with a mechanism of defining print methods for a qclass, just like you normally would for CL classes by <code><a href="#CL+QT:PRINT-OBJECT">print-object</a></code>. Simply use <code><a href="#QTOOLS:DEFINE-PRINT-METHOD">define-print-method</a></code>.</p> <h3 id="widgets">Widgets</h3> <p>Qt deals with widgets. As such, making everything associated with them simple and easy to use should be a primary objective. Qtools' widget system attempts to do exactly that. The central part to this is the <code><a href="#QTOOLS:DEFINE-WIDGET">define-widget</a></code> macro. This expands to a <code><a href="#CL+QT:DEFCLASS">defclass</a></code> with the following effects: It sets <code><a href="#QTOOLS:WIDGET-CLASS">widget-class</a></code> as the metaclass, sets the first item of the superclass list as the qt-superclass, and injects <code><a href="#QTOOLS:WIDGET">widget</a></code> as a superclass, if it isn't one already. This means that essentially you can use anything you could in a standard <code><a href="#CL+QT:DEFCLASS">defclass</a></code> without having to worry about the necessary default options.</p> <p>However, just with a single <code><a href="#QTOOLS:DEFINE-WIDGET">define-widget</a></code> you won't get far ahead. You still need to use CommonQt's way of declaring slots, signals, and overrides, which is quite cumbersome. You can do that of course, but there is a more convenient method, which is to use <code><a href="#QTOOLS:DEFINE-SLOT">define-slot</a></code>, <code><a href="#QTOOLS:DEFINE-SIGNAL">define-signal</a></code>, and <code><a href="#QTOOLS:DEFINE-OVERRIDE">define-override</a></code>. These essentially translate to class options, albeit in a detached way. Each of these define statements is of the following syntax:</p> <pre><code>(define-* (<a href="#QTOOLS:WIDGET-CLASS">widget-class</a> name) arglist &body body)
</code></pre> <p>Some of them take optional extra arguments in the name-list, such as a method-name in the case of <code><a href="#QTOOLS:DEFINE-SLOT">define-slot</a></code> and <code><a href="#QTOOLS:DEFINE-OVERRIDE">define-override</a></code>. In the case of <code><a href="#QTOOLS:DEFINE-SIGNAL">define-signal</a></code> the body is discarded. However, even with these extensions things are rather cumbersome: You need to manually define slots for each of the widgets you want to use inside your widget class, and define their behaviour in an <code><a href="#CL+QT:INITIALIZE-INSTANCE">initialize-instance</a></code> function. This is unwieldy, which is why Qtools also adds <code><a href="#QTOOLS:DEFINE-INITIALIZER">define-initializer</a></code>, <code><a href="#QTOOLS:DEFINE-FINALIZER">define-finalizer</a></code>, and <code><a href="#QTOOLS:DEFINE-SUBWIDGET">define-subwidget</a></code>. The first two follow in signature to the above minus the <code>arglist</code> and do what you might expect them to do: handle initialization and finalization. The initializer and finalizer forms take an optional priority argument in their name-list. The higher, the sooner. <code><a href="#QTOOLS:DEFINE-SUBWIDGET">define-subwidget</a></code> on the other hand looks like this:</p> <pre><code>(<a href="#QTOOLS:DEFINE-SUBWIDGET">define-subwidget</a> (<a href="#QTOOLS:WIDGET-CLASS">widget-class</a> name) initform &body body)
</code></pre> <p>And its effects are two-fold. First, it adds a finalized slot to the widget-class called name. Then, it adds an initializer (with priority 10) that sets the slot-value to the value of <code>initform</code> and then evaluates the <code>body</code> forms. This by itself takes care of the repetitive slot and initializer definition, but without an extra helper called <code><a href="#QTOOLS:WITH-SLOTS-BOUND">with-slots-bound</a></code>, it would still be annoying to write functions, as you would have to reference widgets using <code><a href="#CL+QT:SLOT-VALUE">slot-value</a></code> everywhere. <code><a href="#QTOOLS:WITH-SLOTS-BOUND">with-slots-bound</a></code> is like <code><a href="#CL+QT:WITH-SLOTS">with-slots</a></code>, but it binds <em>all</em> direct class-slot values to their respective slot names. Every <code>define-*</code> function's body is automatically wrapped in a <code><a href="#QTOOLS:WITH-SLOTS-BOUND">with-slots-bound</a></code>, to make this convenience possible.</p> <p>If you do not like this behaviour, due to potential symbol clashes and general confusion that might arise from the implicit action, you can instead use <code><a href="#CL+QT:DEFMETHOD">cl+qt:defmethod</a></code> and <code><a href="#CL+QT:DECLARE">declare</a></code> statements. This is actually what all the <code>define-*</code> (with the exception of <code><a href="#QTOOLS:DEFINE-SIGNAL">define-signal</a></code>) expand to: A <code><a href="#CL+QT:DEFMETHOD">cl+qt:defmethod</a></code> with an appropriate declaration inserted into the body. The <code><a href="#CL+QT:DEFMETHOD">cl+qt:defmethod</a></code> behaves exaclty like <code><a href="http://l1sp.org/cl/defmethod">cl:defmethod</a></code> with the exception of allowing the handling of custom declaration forms. Qtools defines the following declarations: <code><a href="#QTOOLS:SLOT">slot</a></code>, <code><a href="#QTOOLS:OVERRIDE">override</a></code>, <code><a href="#QTOOLS:INITIALIZER">initializer</a></code>, and <code><a href="#QTOOLS:FINALIZER">finalizer</a></code>. In the case of a <code><a href="#QTOOLS:SLOT">slot</a></code> definition, an extra declaration called <code><a href="#QTOOLS:CONNECTED">connected</a></code> is also available. The effects of the declarations are as you might expect, and have the following signatures:</p> <pre><code>(<a href="#QTOOLS:SLOT">slot</a> slot-name args)
(<a href="#QTOOLS:CONNECTED">connected</a> slot-name (signal-name &rest args))
(<a href="#QTOOLS:OVERRIDE">override</a> &optional method-name)
(<a href="#QTOOLS:INITIALIZER">initializer</a> &optional (priority 0))
(<a href="#QTOOLS:FINALIZER">finalizer</a> &optional (priority 0))
</code></pre> <p>The user may define additional declarations using <code><a href="#QTOOLS:DEFINE-METHOD-DECLARATION">define-method-declaration</a></code>.</p> <p>At this point it is useful to note about the general startup sequence of a widget. Once <code><a href="#CL+QT:MAKE-INSTANCE">make-instance</a></code> is called, it calls to <code><a href="#CL+QT:INITIALIZE-INSTANCE">initialize-instance</a></code>. Qtools defines a primary method on this specialized on the widget class. It then immediately calls the next method (<code><a href="#CL+QT:CALL-NEXT-METHOD">call-next-method</a></code>), followed by <code><a href="#QTOOLS:CONSTRUCT">construct</a></code> which should call <code><a href="#CL+QT:NEW">qt:new</a></code>, instantiating the C++ parts. Following that are the initializers in the order of their priority (highest goes first). This means that if you (for some reason) define an <code>:after</code> method on <code><a href="#CL+QT:INITIALIZE-INSTANCE">initialize-instance</a></code> for your own widget, it will be run after all initializers have completed. For finalization it is the same: all finalizers are run before your own <code><a href="#QTOOLS:FINALIZE">finalize</a></code> method is run. However, if you define a <code>:before</code> method on <code><a href="#QTOOLS:FINALIZE">finalize</a></code> for your class, it will be run before the <code>:finalized</code> slots are finalized, otherwise all primary and <code>:after</code> methods should not access <code>:finalized</code> slots anymore. If you absolutely do need to do things before normal initialization or finalization, you can define an <code>:around</code> method.</p> <p>One last widget-related definition form is <code><a href="#QTOOLS:DEFINE-MENU">define-menu</a></code>, which is a very convenient way of specifying menus:</p> <pre><code>(<a href="#QTOOLS:DEFINE-MENU">define-menu</a> (my-widget File)
(:item ("Open..." (ctrl o))
(open-file))
(:menu recent-files)
(:separator)
(:item ("Save" (ctrl s))
(save-file))
(:item ("Save As..." (ctrl alt s))
(save-file NIL))
(:menu "Export"
(:item "PNG" (save-file NIL "png")))
(:separator)
(:item ("Quit" (ctrl q))
(#_close widget)))
</code></pre> <p>Out of the box, it supports <code>:item</code>, <code>:menu</code>, and <code>:separator</code> components. The item takes a name, which can be either a string for a label, a list of string and keyboard mnemonic, or a symbol indicating the class slot that contains the item widget, and it takes a body of forms to execute if the item is triggered. Menus take a name as a string and a body of components to contain, or a symbol indicating the slot that contains the menu widget. New components can be added with <code><a href="#QTOOLS:DEFINE-MENU-CONTENT-TYPE">define-menu-content-type</a></code>.</p> <p>If your widget has a Qt superclass to whose constructor you would like to pass certain arguments, you can do so by adding a method on <code><a href="#QTOOLS:CONSTRUCT">construct</a></code> that calls <code><a href="#CL+QT:NEW">qt:new</a></code> with the arguments you need. You can also use a shorthand to do the same by adding a <code>(:constructor ..)</code> option to your widget definition form. This expands to a <code><a href="#CL+QT:DEFMETHOD">defmethod</a></code> form that binds all slots (<code><a href="#QTOOLS:WITH-ALL-SLOTS-BOUND">with-all-slots-bound</a></code>) and otherwise just contains a call to <code><a href="#CL+QT:NEW">qt:new</a></code> supplying the arguments of the option form verbatim. In effect this means that any unquoted symbol in the option denotes a slot reference. Note that the call to <code><a href="#QTOOLS:CONSTRUCT">construct</a></code> happens before the widget initializers are run. Thus you will not be able to use slot values that are set by subwidgets or initializers.</p> <p>As a final touch, Qtools offers macros for connecting slots and emitting signals. These translate to CommonQt's <code><a href="#CL+QT:EMIT-SIGNAL">emit-signal</a></code> and <code><a href="#CL+QT:CONNECT">connect</a></code> functions, and thus just offer a bit of syntactic sugar. They're called <code><a href="#QTOOLS:SIGNAL!">signal!</a></code> and <code><a href="#QTOOLS:CONNECT!">connect!</a></code>. Their use is simple enough:</p> <pre><code> (<a href="#QTOOLS:CONNECT!">connect!</a> input (text-edited string) widget (text-changed string))
(<a href="#QTOOLS:SIGNAL!">signal!</a> input (text-edited string) "Eyyyy")
</code></pre> <p>An experimental variant for the adventurous is <code><a href="#QTOOLS:GENERIC-SIGNAL">generic-signal</a></code>, which attempts to determine the argument types by their values at run-time. It does therefore not require specifying the type explicitly, but might instead screw up and choose a wrong type for the signal and thus fail to emit.</p> <h3 id="q+">Q+</h3> <p>By default with CommonQt, calling Qt methods happens with the <code>#_</code> reader macro. This requires you to follow the proper case of the class and method names. Having this kind of mixture of conventions in the code is a bit jarring. While Qtools offers solutions to deal with the discrepancies of defining your own classes and widgets using the various <code>define-*</code> macros, Q+ fixes the method calling discrepancy. In order to use Q+ you have a choice of either using the <code><a href="#QTOOLS:Q+">q+</a></code> macro, or using the <code>:qtools</code> read-table. Using the <code><a href="#QTOOLS:Q+">q+</a></code> macro directly an example translates like this:</p> <pre><code>(<a href="#CL+QT:LET">let</a> ((widget (#_new QWidget)))
(#_setWindowTitle widget "Hello!")
(#_show widget)
(#_exec *qapplication*))
(<a href="#CL+QT:LET">let</a> ((widget (<a href="#QTOOLS:Q+">q+</a> make-qwidget)))
(<a href="#QTOOLS:Q+">q+</a> set-window-title widget "Hello!")
(<a href="#QTOOLS:Q+">q+</a> show widget)
(<a href="#QTOOLS:Q+">q+</a> exec *qapplication*))
</code></pre> <p>And the same using the readtable:</p> <pre><code>(<a href="#CL+QT:LET">let</a> ((widget (<a href="#Q+:MAKE-QWIDGET">q+:make-qwidget</a>)))
(<a href="#Q+:SET-WINDOW-TITLE">q+:set-window-title</a> widget "Hello!")
(<a href="#Q+:SHOW">q+:show</a> widget)
(<a href="#Q+:EXEC">q+:exec</a> *qapplication*))
</code></pre> <p>The difference is minimal in the typed code. However, the second approach will give you the convenience of letting the editor display the possible arguments and a docstring linking to the Qt methods. The second example is read by the Common Lisp reader to the first example. There is therefore no code difference in how the two work. If you use the <code>cl+qt</code> package, you can also take advantage of an extended <code><a href="#CL+QT:SETF">setf</a></code> macro. Using it, the second line would look like so:</p> <pre><code>(<a href="#CL+QT:SETF">setf</a> (<a href="#QTOOLS:Q+">q+</a> window-title widget) "Hello!")
</code></pre> <p>Some of the setter functions require multiple values to be set at once. The updated <code><a href="#CL+QT:SETF">setf</a></code> can also deal with that:</p> <pre><code>(<a href="#CL+QT:SETF">setf</a> (<a href="#QTOOLS:Q+">q+</a> window painter) (<a href="#CL+QT:VALUES">values</a> 0 0 100 100))
</code></pre> <p>The <code><a href="#CL+QT:SETF">setf</a></code> has extra support for <code><a href="#QTOOLS:Q+">q+</a></code>, but is otherwise identical to <code><a href="http://l1sp.org/cl/setf">cl:setf</a></code> and actually expands to that for all other places.</p> <p>In order to access enum values, you simply use the class name followed by a dot and the enum name. Constructors are the class name prefixed with "make". Static functions are the class name, a dash, and the method name in the standard translation scheme.</p> <pre><code>(<a href="#Q+:QT.BLUE">q+:qt.blue</a>)
(<a href="#Q+:MAKE-QPUSHBUTTON">q+:make-qpushbutton</a> "Foo!")
(<a href="#Q+:QMESSAGEBOX-INFORMATION">q+:qmessagebox-information</a> parent "!" "hello!")
</code></pre> <p>For the specific arguments, names, and everything else, refer to the <a href="http://qt-project.org/doc/qt-4.8/">Qt4.8</a> documentation. It's very good, trust me. The only thing you need to be aware of is the name conversion rules that Q+ uses to determine the proper Lisp symbol to use:</p> <ul> <li>Method <code>QImage::constScanLine</code> => <code><a href="#Q+:CONST-SCAN-LINE">q+:const-scan-line</a></code></li> <li>Method <code>Foo::set_widget</code> => <code><a href="#Q+:SET_WIDGET">q+:set_widget</a></code></li> <li>Constant <code>QImage::InvertRgb</code> => <code><a href="#Q+:QIMAGE.INVERT-RGB">q+:qimage.invert-rgb</a></code></li> <li>Constant <code>QImage::Format_ARGB32_Premultiplied</code> => <code><a href="#Q+:QIMAGE.FORMAT_ARGB32_PREMULTIPLIED">q+:qimage.format_argb32_premultiplied</a></code></li> <li>Static Method <code>QFileDialog::getExistingDirectory</code> => <code><a href="#Q+:QFILEDIALOG-GET-EXISTING-DIRECTORY">q+:qfiledialog-get-existing-directory</a></code></li> <li>Constructor <code>QImage::QImage</code> => <code><a href="#Q+:MAKE-QIMAGE">q+:make-qimage</a></code></li> </ul> <p>For Q+ to work seamlessly in conjunction with ASDF systems and compiling/loading code, you have to make sure that the smoke modules are set up correctly.</p> <p><code><a href="#QTOOLS:Q+">q+</a></code> and the reader extension dynamically compile wrapper functions for the Qt methods you access. You can, however, also precompile all possible methods for the currently active set of smoke modules. To do this, you can either <code>:depends-on (:q+)</code> or compile a source file using <code><a href="#QTOOLS:WRITE-EVERYTHING-TO-FILE">write-everything-to-file</a></code> and include it in your ASDF system. If you choose this approach, you will not need to switch the readtable or use the <code><a href="#QTOOLS:Q+">q+</a></code> macro, as the package will be available fully populated.</p> <h3 id="smoke_modules">Smoke Modules</h3> <p>In order to be able to use the various parts of Qt, the corresponding smoke modules need to be loaded. By default CommonQt loads <code>qtcore</code> and <code>qtgui</code> when <code><a href="#CL+QT:MAKE-QAPPLICATION">make-qapplication</a></code> is called. However, if you want to use, say, the OpenGL parts you'll also need <code>qtopengl</code>.</p> <p>Qtools provides ASDF systems for all the different smoke modules. That way, you can simply push the modules you want into your project's ASDF system dependencies and it'll ensure that the modules are available at compile and load time. Having the modules loaded at both times is especially important for Q+ to work properly. An example system making use of this would look like</p> <pre><code>(asdf:defsystem foo
...
:depends-on (:qtcore :qtgui))
</code></pre> <p>For a list of available smoke modules, see <code><a href="#QTOOLS:*SMOKE-MODULES*">*smoke-modules*</a></code>.</p> <h3 id="fast_calling">Fast Calling</h3> <p>In some cases it is vital to minimise overhead to a method call. Since usually dispatch is dynamic at run-time and un/marshalling of arguments and return values is involved, the standard way of calling methods might be too slow. In that case, you can use Qtools' fast-call mechanism to perform a method call as quickly as possible. At a cost, naturally.</p> <pre><code>(<a href="#CL+QT:LET">let</a> ((size (<a href="#Q+:MAKE-QSIZE">q+:make-qsize</a> 100 100)))
(<a href="#QTOOLS:FAST-CALL">fast-call</a> (set-height QSize int) size 200)
size)
</code></pre> <p>Fast-calling is possible if you know the exact method signature to call and are willing to translate the arguments to their proper required CFFI types. In the case of passing QObjects, you must pass their pointer. You can get that pointer by <code>qt::qobject-pointer</code>.</p> <h2 id="examples">Examples</h2> <p>A couple of example applications using Qtools can be found in the <a href="https://github.com/Shinmera/qtools/tree/master/examples/">examples/</a> folder: <code>qtools-evaluator</code>, <code>qtools-titter</code>, <code>qtools-melody</code>, and <code>qtools-opengl</code>. Each of them can be loaded by their name, and launched using the <code>main</code> function from their package.</p> <h2 id="extending_qtools">Extending Qtools</h2> <h3 id="copying_and_finalizing">Copying and Finalizing</h3> <p>In order to account for your own objects and operations you can extend the <code><a href="#QTOOLS:COPY">copy</a></code> and <code><a href="#QTOOLS:FINALIZE">finalize</a></code> functions by using <code><a href="#QTOOLS:DEFINE-COPY-METHOD">define-copy-method</a></code> and <code><a href="#QTOOLS:DEFINE-FINALIZE-METHOD">define-finalize-method</a></code> or <code><a href="#CL+QT:DEFMETHOD">defmethod</a></code> directly. The two define macros bring the convenience of automatically resolving to a Qt class (and thus using <code>copy/finalize-using-class</code>) if possible, making it all look a bit cleaner.</p> <pre><code>(<a href="#QTOOLS:DEFINE-COPY-METHOD">define-copy-method</a> (instance QPixmap)
"Creates a new QPixmap using QPixmap::copy (deep copy)."
(#_copy instance (#_rect instance)))
</code></pre> <p>Since copying and finalizing are operations associated with a certain amount of ambiguity, it is advisable to always write documentation strings for your <code><a href="#QTOOLS:COPY">copy</a></code>/<code><a href="#QTOOLS:FINALIZE">finalize</a></code> methods. That way users can get a better idea of what will happen by reading about it using <code><a href="#QTOOLS:DESCRIBE-COPY-METHOD">describe-copy-method</a></code> and <code><a href="#QTOOLS:DESCRIBE-FINALIZE-METHOD">describe-finalize-method</a></code> respectively.</p> <h3 id="adding_defmethod_declarations">Adding <code><a href="#CL+QT:DEFMETHOD">defmethod</a></code> declarations</h3> <p>Using <code><a href="#QTOOLS:DEFINE-METHOD-DECLARATION">define-method-declaration</a></code> you can add your own processing to method declarations. Your function should extract the necessary information from its declaration arguments and the <code><a href="#QTOOLS:*METHOD*">*method*</a></code> form. Each method declaration processing function should return a single form (like a macro) to be put before the resulting <code><a href="#CL+QT:DEFMETHOD">defmethod</a></code>. The existing declaration processors are really short:</p> <pre><code>(<a href="#QTOOLS:DEFINE-METHOD-DECLARATION">define-method-declaration</a> override (<a href="#CL+QT:&OPTIONAL">&optional</a> name)
(<a href="#CL+QT:LET">let</a> ((slot (<a href="#QTOOLS:TO-METHOD-NAME">qtools:to-method-name</a> (<a href="#CL+QT:OR">or</a> name (form-fiddle:lambda-name *method*)))))
(<a href="#QTOOLS:WITH-WIDGET-CLASS">with-widget-class</a> (<a href="#QTOOLS:WIDGET-CLASS">widget-class</a>)
`(<a href="#QTOOLS:SET-WIDGET-CLASS-OPTION">set-widget-class-option</a> ',widget-class :override '(,slot ,name)))))
</code></pre> <p>In this example we're using <a href="http://github.com/Shinmera/form-fiddle">form-fiddle</a> to parse the method form. Using a library like that to ensure proper destructuring is important, as otherwise it's easy to accidentally butcher the method form, or get the wrong information.</p> <h3 id="extending_the_menu_definition">Extending the menu definition</h3> <p>The menu definition form allows for arbitrary content types, so you may add new ones yourself by using <code><a href="#QTOOLS:DEFINE-MENU-CONTENT-TYPE">define-menu-content-type</a></code>. Each content type definition can return two values: an initform and a side-form. The initform will be put into the initialization function for the menu and thus evaluated when the widget is created. The side-form is put alongside the initializer definition and thus evaluated during compilation. If your menu type needs to modify the widget class in some way, that should be done through the side-forms. If it needs to connect signals, add items, or perform similar actions that involve Qt, that should go into the initform. You can call the expansion of other component types using <code><a href="#QTOOLS:BUILD-MENU-CONTENT">build-menu-content</a></code>. During the time your content-type function is run, <code><a href="#QTOOLS:*WIDGET*">*widget*</a></code> is bound to the class-name of the widget and during initialization it is bound to the actual widget instance.</p> <h2 id="qtools_concepts">Qtools Concepts</h2> <p>Qtools has grown to be a large library with a lot of rather complicated concepts. I will try to describe them here, in order to retain some information in non-code form and make things clearer to the average user. It is not necessary to read and understand this section to use Qtools, but it may be useful to be aware of the underlying ideas and functionality that make Qtools work.</p> <h3 id="finalizables">Finalizables</h3> <p>A finalizable is implemented using two classes, one serving as the metaclass and the other as a superclass. The metaclass is required in order to allow a custom slot type that supports the <code>:finalized</code> argument. The superclass is necessary in order to allow methods such as <code><a href="#QTOOLS:FINALIZE">finalize</a></code> to operate on instances of the finalizable classes. The handling of the finalized slots is done through a general method on <code><a href="#QTOOLS:FINALIZE">finalize</a></code> that scans through the slots of the class instance and then calls <code><a href="#QTOOLS:FINALIZE">finalize</a></code> on each slot for which the definition is set to be <code>:finalized</code>. This makes finalization of class slots automatic and convenient.</p> <p>Since finalizables don't add any metaclass properties, there is no need to manually calculate inheritance order. However, as with all custom slot definitions, the slot properties must be copied over from the direct-slot instance to the effective slot. In the case of <code><a href="#QTOOLS:FINALIZABLE-CLASS">finalizable-class</a></code> this happens in <code>compute-effective-slot-definition</code>.</p> <p>In order to support finalizing of Qt class instances that don't have a CL class equivalent, the <code><a href="#QTOOLS:FINALIZE">finalize</a></code> method is extended wit ha <code>finalize-using-class</code> that is dispatched to using the Qt class and the instance of a <code><a href="#CL+QT:QOBJECT">qobject</a></code> instance is passed to <code><a href="#QTOOLS:FINALIZE">finalize</a></code>.</p> <h3 id="widgets">Widgets</h3> <p>As with finalizables, the widget is implemented using two classes, the <code><a href="#QTOOLS:WIDGET-CLASS">widget-class</a></code> metaclass and the <code><a href="#QTOOLS:WIDGET">widget</a></code> superclass. These both inherit from the finalizable equivalents. The main crux of the <code><a href="#QTOOLS:WIDGET-CLASS">widget-class</a></code> lies in its <code><a href="#QTOOLS:WIDGET-CLASS-DIRECT-OPTIONS">widget-class-direct-options</a></code> and <code><a href="#QTOOLS:WIDGET-CLASS-EXTERN-OPTIONS">widget-class-extern-options</a></code>. The direct options are the options that are passed to a <code>re/</code> <code><a href="#CL+QT:INITIALIZE-INSTANCE">initialize-instance</a></code> (and thus also to <code><a href="#CL+QT:DEFCLASS">defclass</a></code>). They're caught in the appropriately specialised methods and then stored on the class. The effect of this is that we can fully recompute the class definition at any time, and potentially add or remove options without influencing the original <code><a href="#CL+QT:DEFCLASS">defclass</a></code> statement. This is where the extern-options come in.</p> <p>Using <code><a href="#QTOOLS:SET-WIDGET-CLASS-OPTION">set-widget-class-option</a></code> options can be added to the class definition dynamically at any point in the program. This function then adds the option to the class' extern-options and then calls <code><a href="#CL+QT:REINITIALIZE-INSTANCE">reinitialize-instance</a></code>, which in turn causes the class to get effectively redefined outside of its <code><a href="#CL+QT:DEFCLASS">defclass</a></code> form. This redefinition also allows us to change CommonQt class options. Using this we can create forms outside of the original <code><a href="#CL+QT:DEFCLASS">defclass</a></code> that act as if they were actually options in the <code><a href="#CL+QT:DEFCLASS">defclass</a></code> form.</p> <p>Qtools effectively only provides two forms that do this: <code><a href="#QTOOLS:DEFINE-SIGNAL">define-signal</a></code> and <code><a href="#CL+QT:DEFMETHOD">defmethod</a></code>. The <code><a href="#QTOOLS:DEFINE-SIGNAL">define-signal</a></code> is relatively straightforward and simply expands to a class option set to add a new signal option. The <code><a href="#CL+QT:DEFMETHOD">defmethod</a></code> is an extensible machine in itself.</p> <p>What's special about the <code><a href="#CL+QT:DEFMETHOD">cl+qt:defmethod</a></code> is that it inspects the declaration forms in the method body. It then checks for each declaration form whether a handler function exist and if so, calls that function. Such a <code><a href="#QTOOLS:METHOD-DECLARATION">method-declaration</a></code> function can then return forms to be put into the macroexpansion of the <code><a href="#CL+QT:DEFMETHOD">cl+qt:defmethod</a></code>, before the resulting <code><a href="http://l1sp.org/cl/defmethod">cl:defmethod</a></code>. The processed declaration is then left out of the <code><a href="http://l1sp.org/cl/defmethod">cl:defmethod</a></code>form as it is assumed that it isn't a standard common lisp declaration. However, the declaration function also has the ability to change the contents of the <code><a href="http://l1sp.org/cl/defmethod">cl:defmethod</a></code> form itself, by manipulating <code><a href="#QTOOLS:*METHOD*">*method*</a></code>. This allows the declaration to output special handling for the method body, for example.</p> <p>This kind of extensible declaration mechanism is necessary both to allow further evolving of Qtools in the future as well as adaptation by users. It also offers a very "native-like" way of specifying external effects of a method. Qtools uses this construct then to allow definition of slots, overrides, finalizers, and initializers.</p> <p>In case the user doesn't appreciate the <code><a href="#CL+QT:DEFMETHOD">defmethod</a></code> way, Qtools then provides <code>define-*</code> alternative functions that simply wrap over <code><a href="#CL+QT:DEFMETHOD">defmethod</a></code>, establish some default bindings, and take care of naming and specialising the method.</p> <p>The <code><a href="#QTOOLS:DEFINE-SUBWIDGET">define-subwidget</a></code> deserves special attention here, as it does more work than the rest. A large part of defining widgets is adding sub-components to it, which is a task that usually involves a lot of repetition or awkward function sharing: Setting up a slot to hold the instance, defining or using an initializer to set it up. <code><a href="#QTOOLS:DEFINE-SUBWIDGET">define-subwidget</a></code> makes this both distributed and simple by both taking care of setting up an appropriate initializer function, and automatically adding the slot to the class using, again, <code><a href="#QTOOLS:SET-WIDGET-CLASS-OPTION">set-widget-class-option</a></code>. This slot is also always automatically set to be <code><a href="#QTOOLS:FINALIZED">finalized</a></code> in order to ensure that all widgets are properly cleaned up when the GUI is no longer needed.</p> <p>A minor problem regarding this approach is the same problem that appears with all of CL's definition forms. While developing incrementally, merely removing the definition form from the source file, will not actually remove it from the image. This can trip developers up, as definitions will still be active later. In this case it means having widgets still sticking around, or initializers running, etc. For this purpose there are corresponding <code>remove-*</code> functions to all the <code>define-*</code> functions to allow easy removal. This part cannot possibly be automated due to the nature of Common Lisp, but it is at least simple to correct should the need arise.</p> <h3 id="q+">Q+</h3> <p>CommonQt's way of dealing with method calls is the simple and most direct way of doing it. The first possible alternative to remove the need for typing method names in their corresponding case would be to simply introduce a different reader macro that automatically translates a <code>example-function</code>-like name into <code>exampleFunction</code> as is done already in other parts of Qtools. However, this has two downsides, the first being that there does not exist a 1:1 mapping of methods anywhere. The dynamic computation of the function name means that there isn't a full correspondence table anywhere. The second downside is that methods are still not passable as first-class objects.</p> <p>The way to solve this is to generate actual CL wrapper functions to the method calls. This allows us to use them as first-class objects, have at least compile-time argument number checking, and have a linkage of wrapper name to Qt method by listing it in the docstring.</p> <p>In order to achieve this, there are two possible choices. First, the entirety of all possible wrappers can be computed once, and then subsequently loaded into the image and used directly. However, this creates two new problems. Computing all wrappers, compiling them, and loading them, takes a long time and subsequently litters the image with thousands of functions and symbols that won't ever be used in the program. Then, we have a problem with the smoke modules, as we need to know which modules will be used in a potential application ahead of time, load them all, and then generate the wrappers. We cannot generate wrappers for each module separately, as the methods from different classes share the same wrapper functions. This means that whenever a different set of modules is needed, the wrappers need to be regenerated, recompiled, and reloaded. A lot of time and space goes to waste with this. However, this approach also has an advantage: As all functions are always available, it is easy to develop with. Arguments and docstrings will be readily available through the editor. Qtools offers this approach through <code><a href="#QTOOLS:Q+-COMPILE-AND-LOAD">q+-compile-and-load</a></code>.</p> <p>The second approach is to dynamically only compile what is needed. That way, the image only ever contains wrappers for function that are actually called (at some point). However, this complicates things a lot. When a function is compiled that calls such a function, it doesn't exist yet. Even worse, when the form is read, the symbol for the function does not exist yet and isn't external! In order to catch this problem, a modified reader macro is necessary. This reader macro will detect when a call to a wrapper function is made, and instead transform it into a macro call that then sees to it that the wrapper will be created. Modifying the reader in such a way is a heavy change, and should only be used sparingly, however there is no alternative here. Qtools does not force you to use this reader extension, you can always just use the macro directly.</p> <p>However, dynamic compilation complications don't end there. Since we never dump the function to a file, it only ever exists in the environment it was compiled in. That means, if you compile a function that then dynamically generates the wrapper function, the wrapper won't be available anymore at load time. Qtools solves this issue with a trick. The <code><a href="#QTOOLS:Q+">q+</a></code> macro expands to a <code><a href="#CL+QT:LOAD-TIME-VALUE">load-time-value</a></code> form that then generates the wrapper function. That way, the wrapper will always be available at load- and execution time, while posing no overhead to the execution time, as it will return a value to that won't impact anything.</p> <p>Function referencing gets the same problems as function calling, so the Qtools readtable also contains an overridden <code>#'</code> reader macro to handle that. In the case of a wrapper call, it expands to <code><a href="#QTOOLS:Q+FUN">Q+FUN</a></code> which in turn expands to a <code><a href="#CL+QT:LOAD-TIME-VALUE">load-time-value</a></code> form that generates and returns the function object.</p> <p>As is probably obvious by now, Qtools also implements the second approach. Therefore, the choice as a user is yours: You can statically precompile everything and use it directly, or you an use the dynamic on the fly compilation using either a readtable expansion, or a simple macro. The concepts to make this all possible are rather complex, but the actual function wrapper compilations are quite straight-forward. The system is currently not suited for extension, but I see no need to allow that as the kind of Qt methods that can exist are fixed and Q+ should handle all that are relevant.</p> <p>Q+ does one last thing to fix the "issue" of having setters instead of being able to use <code><a href="#CL+QT:SETF">setf</a></code>. For this purpose it has an extended <code><a href="#CL+QT:SETF">setf</a></code> macro that checks if a place is a function in the Q+ package. if so, this place/value pair is instead expanded to a call to the appropriate wrapper function with the function name transformed. However, that's not the only reason to do this. The second is that some setters require multiple arguments to be set at once. Usually, <code><a href="http://l1sp.org/cl/setf">cl:setf</a></code> allows for cases like these by permitting setf expanders to accept multiple values. However, the number of values is fixed, and there's no way to dynamically know how many values where passed. Since Q+ needs to dispatch based on the number of values, this is not a viable approach. Therefore, with <code><a href="#CL+QT:SETF">cl+qt:setf</a></code> a <code>(<a href="#CL+QT:VALUES">values</a> ..)</code> value form is specially treated and its arguments are inlined into the wrapper call. This also means that it isn't possible to use multiple values of a returning function as the values to a setter call, however while that is an inconsistency, I don't think it will be a big issue. If it turns out to be problematic in the later run, this will have to be changed to a dynamic analysis at run-time, which is an overhead I wanted to avoid.</p> <h2 id="support">Support</h2> <p>Currently the following implementations are tested and supported by Qtools:</p> <ul> <li><a href="http://www.sbcl.org/">SBCL</a></li> <li><a href="http://ccl.clozure.com/">CCL</a></li> <li><a href="https://common-lisp.net/project/ecl/">ECL</a></li> </ul> <p>You can run it on x86_64 Linux, OS X, and Windows, where SBCL on Linux is the recommended platform.</p> <p>It may or may not work more or less smoothly on other implementations and platforms depending on MOP and CommonQt support and general implementation quirks.</p> </div> </article> <article id="copyright"> <h2>Copyright</h2> <span>qtools</span> is licensed under the <span><a href="https://tldrlegal.com/search?q=Artistic">Artistic</a></span> license. © <span>Nicolas Hafner <[email protected]></span> . This library can be obtained on <a href="https://github.com/Shinmera/qtools">https://github.com/Shinmera/qtools</a>. </article> <article id="symbol-index"> <h2>Package Index</h2> <ul><li class="package"> <h3> <a name="QTOOLS" href="#QTOOLS">QTOOLS</a> <span class="nicknames">(ORG.SHIRAKUMO.QTOOLS)</span> </h3> <ul><li> <a name="QTOOLS:*BOOT-HOOKS*"> </a> <article id="SPECIAL QTOOLS:*BOOT-HOOKS*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20QTOOLS%3A%2ABOOT-HOOKS%2A">*BOOT-HOOKS*</a></code></h4> </header> <div class="docstring"><pre>A list of functions to invoke (in sequence) during the warm-boot.
Use this to run customised startup, prepare, or load functions.</pre></div> </article> </li><li> <a name="QTOOLS:*BUILD-HOOKS*"> </a> <article id="SPECIAL QTOOLS:*BUILD-HOOKS*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20QTOOLS%3A%2ABUILD-HOOKS%2A">*BUILD-HOOKS*</a></code></h4> </header> <div class="docstring"><pre>A list of functions to invoke (in sequence) during the build.
Use this to run customised cleanup, compile, or deployment functions.</pre></div> </article> </li><li> <a name="QTOOLS:*DEPLOYMENT-LOCATION*"> </a> <article id="SPECIAL QTOOLS:*DEPLOYMENT-LOCATION*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20QTOOLS%3A%2ADEPLOYMENT-LOCATION%2A">*DEPLOYMENT-LOCATION*</a></code></h4> </header> <div class="docstring"><pre>Variable containing the path to the directory that is being deployed to.
This is bound when *BOOT-HOOKS* functions are called.</pre></div> </article> </li><li> <a name="QTOOLS:*GENERATED-MODULES*"> </a> <article id="SPECIAL QTOOLS:*GENERATED-MODULES*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20QTOOLS%3A%2AGENERATED-MODULES%2A">*GENERATED-MODULES*</a></code></h4> </header> <div class="docstring"><pre>A list of loaded smoke modules when PROCESS-ALL-METHODS is called.
This is useful to keep track over environments which modules are
actually available for compilation.</pre></div> </article> </li><li> <a name="QTOOLS:*METHOD*"> </a> <article id="SPECIAL QTOOLS:*METHOD*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20QTOOLS%3A%2AMETHOD%2A">*METHOD*</a></code></h4> </header> <div class="docstring"><pre>Contains the whole DEFMETHOD form that is currently being processed.
If you modify the contents of this variable, the changes will be reflected
in the outputted method definition form. However, no declaration that is
processed by method-declarations will ever appear in the output.</pre></div> </article> </li><li> <a name="QTOOLS:*OPERATOR-MAP*"> </a> <article id="SPECIAL QTOOLS:*OPERATOR-MAP*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20QTOOLS%3A%2AOPERATOR-MAP%2A">*OPERATOR-MAP*</a></code></h4> </header> <div class="docstring"><pre>A hash-table of C++ operators to CL function names.</pre></div> </article> </li><li> <a name="QTOOLS:*QMETHODS*"> </a> <article id="SPECIAL QTOOLS:*QMETHODS*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20QTOOLS%3A%2AQMETHODS%2A">*QMETHODS*</a></code></h4> </header> <div class="docstring"><pre>Table mapping a *TARGET-PACKAGE* symbol to a list of
associated Qt methods. This table should only be changed
by PROCESS-METHOD. If you modify yourself without knowing
exactly what you're doing you'll most likely run into problems.
Methods/functions contained in this table are available
for compilation.
See <a href="#QTOOLS:PROCESS-METHOD">QTOOLS:PROCESS-METHOD</a>
See <a href="#QTOOLS:COMPILE-WRAPPER">QTOOLS:COMPILE-WRAPPER</a></pre></div> </article> </li><li> <a name="QTOOLS:*QT-CLASS-MAP*"> </a> <article id="SPECIAL QTOOLS:*QT-CLASS-MAP*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20QTOOLS%3A%2AQT-CLASS-MAP%2A">*QT-CLASS-MAP*</a></code></h4> </header> <div class="docstring"><pre>An EQUALP hash-table of all Qt4.8 class names to themselves as strings.</pre></div> </article> </li><li> <a name="QTOOLS:*QT-CLASS-VECTOR*"> </a> <article id="SPECIAL QTOOLS:*QT-CLASS-VECTOR*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20QTOOLS%3A%2AQT-CLASS-VECTOR%2A">*QT-CLASS-VECTOR*</a></code></h4> </header> <div class="docstring"><pre>A vector of all Qt4.8 class names as strings.</pre></div> </article> </li><li> <a name="QTOOLS:*QUIT-HOOKS*"> </a> <article id="SPECIAL QTOOLS:*QUIT-HOOKS*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20QTOOLS%3A%2AQUIT-HOOKS%2A">*QUIT-HOOKS*</a></code></h4> </header> <div class="docstring"><pre>A list of functions to invoke (in sequence) when the program quits.
Use this to run customised saving or cleanup functions.</pre></div> </article> </li><li> <a name="QTOOLS:*SMOKE-MODULES*"> </a> <article id="SPECIAL QTOOLS:*SMOKE-MODULES*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20QTOOLS%3A%2ASMOKE-MODULES%2A">*SMOKE-MODULES*</a></code></h4> </header> <div class="docstring"><pre>A list of all possible smoke modules.
These modules provide the C wrappers required to work with
the respective Qt parts. Usually you will only need
QTCORE and QTGUI, but for example if you need OpenGL support
you'll want QTOPENGL, or if you need phonon, you'll want
the PHONON module.</pre></div> </article> </li><li> <a name="QTOOLS:*SMOKE-MODULES-TO-RELOAD*"> </a> <article id="SPECIAL QTOOLS:*SMOKE-MODULES-TO-RELOAD*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20QTOOLS%3A%2ASMOKE-MODULES-TO-RELOAD%2A">*SMOKE-MODULES-TO-RELOAD*</a></code></h4> </header> <div class="docstring"><pre>A list of smoke modules that need to be reloaded on boot.
The system sets this variable itself during the build.</pre></div> </article> </li><li> <a name="QTOOLS:*TARGET-PACKAGE*"> </a> <article id="SPECIAL QTOOLS:*TARGET-PACKAGE*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20QTOOLS%3A%2ATARGET-PACKAGE%2A">*TARGET-PACKAGE*</a></code></h4> </header> <div class="docstring"><pre>The package used to store Qt wrapper functions that the Q+ system uses.
By default this package is called "Q+". The package should not contain
any systems except for those generated by Qtools.</pre></div> </article> </li><li> <a name="QTOOLS:*WIDGET*"> </a> <article id="SPECIAL QTOOLS:*WIDGET*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20QTOOLS%3A%2AWIDGET%2A">*WIDGET*</a></code></h4> </header> <div class="docstring"><pre>Bound to the class-name of the widget during component expansion and
bound to the class instance during initialization.</pre></div> </article> </li><li> <a name="QTOOLS:CLASS"> </a> <article id="CLASS QTOOLS:CLASS"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20QTOOLS%3ACLASS">CLASS</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="QTOOLS:FINALIZABLE"> </a> <article id="CLASS QTOOLS:FINALIZABLE"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20QTOOLS%3AFINALIZABLE">FINALIZABLE</a></code></h4> </header> <div class="docstring"><pre>A class for finalizable objects.</pre></div> </article> </li><li> <a name="QTOOLS:FINALIZABLE-CLASS"> </a> <article id="CLASS QTOOLS:FINALIZABLE-CLASS"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20QTOOLS%3AFINALIZABLE-CLASS">FINALIZABLE-CLASS</a></code></h4> </header> <div class="docstring"><pre>Metaclass for classes with finalizable slots.</pre></div> </article> </li><li> <a name="QTOOLS:FINALIZABLE-SLOT"> </a> <article id="CLASS QTOOLS:FINALIZABLE-SLOT"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20QTOOLS%3AFINALIZABLE-SLOT">FINALIZABLE-SLOT</a></code></h4> </header> <div class="docstring"><pre>Superclass for slots with a finalized option.</pre></div> </article> </li><li> <a name="QTOOLS:GC-FINALIZED"> </a> <article id="CLASS QTOOLS:GC-FINALIZED"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20QTOOLS%3AGC-FINALIZED">GC-FINALIZED</a></code></h4> </header> <div class="docstring"><pre>Wrapper object to allow automatic calling of FINALIZE by the GC.
Since you cannot finalize the object that is GC-ed itself, we need to wrap our to-
be-finalized object in another object that takes all the references instead.
This means that if you wish your object to remain unfinalized, you need to retain
references to the wrapper. As soon as the wrapper is hit by the GC, FINALIZE is
called on the object it contains.
In order to retrieve the contained object, use UNBOX.</pre></div> </article> </li><li> <a name="QTOOLS:QT-PROGRAM-OP"> </a> <article id="CLASS QTOOLS:QT-PROGRAM-OP"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20QTOOLS%3AQT-PROGRAM-OP">QT-PROGRAM-OP</a></code></h4> </header> <div class="docstring"><pre>A DEPLOY:DEPLOY-OP subclass to handle things for Qt deployment.
You should specify this as the BUILD-OPERATION in your ASD along with
an ENTRY-POINT and a BUILD-PATHNAME.</pre></div> </article> </li><li> <a name="QTOOLS:WIDGET"> </a> <article id="CLASS QTOOLS:WIDGET"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20QTOOLS%3AWIDGET">WIDGET</a></code></h4> </header> <div class="docstring"><pre>Common superclass for all widgets in order to allow for
general initialization and cleanup forms that are standardised across all
widgets.
See <a href="#QTOOLS:DEFINE-WIDGET.">QTOOLS:DEFINE-WIDGET.</a></pre></div> </article> </li><li> <a name="QTOOLS:WIDGET-CLASS"> </a> <article id="CLASS QTOOLS:WIDGET-CLASS"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20QTOOLS%3AWIDGET-CLASS">WIDGET-CLASS</a></code></h4> </header> <div class="docstring"><pre>Metaclass for widgets storing necessary information.
The metadata stored in this is mostly responsible for two things:
1) Providing access to a sequence of mutually independent
initializers and finalizers for convenient setup and cleanup.
2) Allowing after-the-fact out-of-form changes to the class
definition, which is necessary to have for a distributed
definition form syntax as provided by WIDGET-CONVENIENCE macros.
In order to modify the metadata, please look at SET/REMOVE-WIDGET-CLASS-OPTION.</pre></div> </article> </li><li> <a name="QTOOLS:COMPILATION-NOTE"> </a> <article id="CONDITION QTOOLS:COMPILATION-NOTE"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20QTOOLS%3ACOMPILATION-NOTE">COMPILATION-NOTE</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="QTOOLS:INVALID-QT-SUPERCLASS-HIERARCHY"> </a> <article id="CONDITION QTOOLS:INVALID-QT-SUPERCLASS-HIERARCHY"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20QTOOLS%3AINVALID-QT-SUPERCLASS-HIERARCHY">INVALID-QT-SUPERCLASS-HIERARCHY</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="QTOOLS:CLASHING-QT-SUPERCLASS"> </a> <article id="ACCESSOR QTOOLS:CLASHING-QT-SUPERCLASS"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20QTOOLS%3ACLASHING-QT-SUPERCLASS">CLASHING-QT-SUPERCLASS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CONDITION</code><code>)</code> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="QTOOLS:CLASHING-SUPERCLASS"> </a> <article id="ACCESSOR QTOOLS:CLASHING-SUPERCLASS"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20QTOOLS%3ACLASHING-SUPERCLASS">CLASHING-SUPERCLASS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CONDITION</code><code>)</code> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="QTOOLS:MENU-CONTENT-TYPE"> </a> <article id="ACCESSOR QTOOLS:MENU-CONTENT-TYPE"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20QTOOLS%3AMENU-CONTENT-TYPE">MENU-CONTENT-TYPE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME</code><code>)</code> </header> <div class="docstring"><pre>Returns the function to process a menu content type NAME, if any.</pre></div> </article> </li><li> <a name="QTOOLS:METHOD-DECLARATION"> </a> <article id="ACCESSOR QTOOLS:METHOD-DECLARATION"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20QTOOLS%3AMETHOD-DECLARATION">METHOD-DECLARATION</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME</code><code>)</code> </header> <div class="docstring"><pre>Returns a function to process the method declaration NAME, if one exists.
See <a href="NIL">(SETF</a> QTOOLS:METHOD-DECLARATION).</pre></div> </article> </li><li> <a name="QTOOLS:PARENT"> </a> <article id="ACCESSOR QTOOLS:PARENT"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20QTOOLS%3APARENT">PARENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>accesses the PARENT of the object. This usually translates to (#_parent object) unless overridden.</pre></div> </article> </li><li> <a name="QTOOLS:REQUESTED-QT-SUPERCLASS"> </a> <article id="ACCESSOR QTOOLS:REQUESTED-QT-SUPERCLASS"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20QTOOLS%3AREQUESTED-QT-SUPERCLASS">REQUESTED-QT-SUPERCLASS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CONDITION</code><code>)</code> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="QTOOLS:VALUE"> </a> <article id="ACCESSOR QTOOLS:VALUE"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20QTOOLS%3AVALUE">VALUE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Accesses the VALUE of the object. This usually translates to (#_value object) unless overridden.</pre></div> </article> </li><li> <a name="QTOOLS:WIDGET-ACTIONS"> </a> <article id="ACCESSOR QTOOLS:WIDGET-ACTIONS"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20QTOOLS%3AWIDGET-ACTIONS">WIDGET-ACTIONS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CLASS</code><code>)</code> </header> <div class="docstring"><pre>Returns a list of QAction instances that are active on the given CLASS.</pre></div> </article> </li><li> <a name="QTOOLS:WIDGET-CLASS-DIRECT-OPTIONS"> </a> <article id="ACCESSOR QTOOLS:WIDGET-CLASS-DIRECT-OPTIONS"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20QTOOLS%3AWIDGET-CLASS-DIRECT-OPTIONS">WIDGET-CLASS-DIRECT-OPTIONS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Contains all the options passed to RE/INITIALIZE-INSTANCE when
the class is re/initialized directly through a DEFCLASS form.</pre></div> </article> </li><li> <a name="QTOOLS:WIDGET-CLASS-EXTERN-OPTIONS"> </a> <article id="ACCESSOR QTOOLS:WIDGET-CLASS-EXTERN-OPTIONS"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20QTOOLS%3AWIDGET-CLASS-EXTERN-OPTIONS">WIDGET-CLASS-EXTERN-OPTIONS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Contains all the options that are added to the class definition
through external forms and thus need to be included and kept separate
from options directly specified in the class definition.</pre></div> </article> </li><li> <a name="QTOOLS:WIDGET-CLASS-FINALIZERS"> </a> <article id="ACCESSOR QTOOLS:WIDGET-CLASS-FINALIZERS"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20QTOOLS%3AWIDGET-CLASS-FINALIZERS">WIDGET-CLASS-FINALIZERS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>A sorted list of functions to be called upon finalization.
This list is overwritten completely whenever the class is re/initialized.
See <a href="#QTOOLS:CALL-FINALIZERS">QTOOLS:CALL-FINALIZERS</a></pre></div> </article> </li><li> <a name="QTOOLS:WIDGET-CLASS-INITIALIZERS"> </a> <article id="ACCESSOR QTOOLS:WIDGET-CLASS-INITIALIZERS"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20QTOOLS%3AWIDGET-CLASS-INITIALIZERS">WIDGET-CLASS-INITIALIZERS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>A sorted list of functions to be called upon initialization.
This list is overwritten completely whenever the class is re/initialized.
See <a href="#QTOOLS:CALL-INITIALIZERS">QTOOLS:CALL-INITIALIZERS</a></pre></div> </article> </li><li> <a name="QTOOLS:BUILD-MENU-CONTENT"> </a> <article id="FUNCTION QTOOLS:BUILD-MENU-CONTENT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3ABUILD-MENU-CONTENT">BUILD-MENU-CONTENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PARENT TYPE CONTENTS</code><code>)</code> </header> <div class="docstring"><pre>Calls the appropriate function to parse menu content of TYPE.
See <a href="NIL">(SETF</a> QTOOLS:MENU-CONTENT-TYPE).</pre></div> </article> </li><li> <a name="QTOOLS:CALL-FINALIZERS"> </a> <article id="FUNCTION QTOOLS:CALL-FINALIZERS"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3ACALL-FINALIZERS">CALL-FINALIZERS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CLASS</code><code>)</code> </header> <div class="docstring"><pre>Calls all the finalizers specified on CLASS in their proper sequence.
CLASS can be either an instance of a WIDGET-CLASS, a
WIDGET-CLASS itself, or a symbol naming the class.</pre></div> </article> </li><li> <a name="QTOOLS:CALL-INITIALIZERS"> </a> <article id="FUNCTION QTOOLS:CALL-INITIALIZERS"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3ACALL-INITIALIZERS">CALL-INITIALIZERS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CLASS</code><code>)</code> </header> <div class="docstring"><pre>Calls all the initializers specified on CLASS in their proper sequence.
CLASS can be either an instance of a WIDGET-CLASS, a
WIDGET-CLASS itself, or a symbol naming the class.</pre></div> </article> </li><li> <a name="QTOOLS:CAPITALIZE-ON"> </a> <article id="FUNCTION QTOOLS:CAPITALIZE-ON"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3ACAPITALIZE-ON">CAPITALIZE-ON</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHARACTER STRING &OPTIONAL (REPLACEMENT CHARACTER) START-CAPITALIZED</code><code>)</code> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="QTOOLS:CL-TYPE-FOR"> </a> <article id="FUNCTION QTOOLS:CL-TYPE-FOR"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3ACL-TYPE-FOR">CL-TYPE-FOR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">QT-TYPE</code><code>)</code> </header> <div class="docstring"><pre>Attempts to determine the CL type for the given Qt type descriptor.
Look at the source to see the mappings.</pre></div> </article> </li><li> <a name="QTOOLS:CLEAR-METHOD-INFO"> </a> <article id="FUNCTION QTOOLS:CLEAR-METHOD-INFO"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3ACLEAR-METHOD-INFO">CLEAR-METHOD-INFO</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Clears the *QMETHODS* table.
See <a href="#QTOOLS:*QMETHODS*">QTOOLS:*QMETHODS*</a></pre></div> </article> </li><li> <a name="QTOOLS:COMPILE-WRAPPER"> </a> <article id="FUNCTION QTOOLS:COMPILE-WRAPPER"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3ACOMPILE-WRAPPER">COMPILE-WRAPPER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">METHOD</code><code>)</code> </header> <div class="docstring"><pre>Compiles the wrapper function for METHOD.
This does not actually call CL:COMPILE, or change
the global environment in any way. It instead returns
a form that you can then truly compile, print, or write
to file, or whatever your intention is.
See <a href="#QTOOLS:ENSURE-METHODS">QTOOLS:ENSURE-METHODS</a>
See <a href="NIL">QT:QMETHOD-ENUM-P</a>
See <a href="#QTOOLS:COMPILE-CONSTANT">QTOOLS:COMPILE-CONSTANT</a>
See <a href="NIL">QT:QMETHOD-CTOR-P</a>
See <a href="NIL">QT:QMETHOD-COPYCTOR-P</a>
See <a href="#QTOOLS:COMPILE-CONSTRUCTOR">QTOOLS:COMPILE-CONSTRUCTOR</a>
See <a href="#QTOOLS:QMETHOD-OPERATOR-P">QTOOLS:QMETHOD-OPERATOR-P</a>
See <a href="#QTOOLS:COMPILE-OPERATOR">QTOOLS:COMPILE-OPERATOR</a>
See <a href="NIL">QT:QMETHOD-STATIC-P</a>
See <a href="#QTOOLS:COMPILE-STATIC-METHOD">QTOOLS:COMPILE-STATIC-METHOD</a>
See <a href="#QTOOLS:COMPILE-METHOD">QTOOLS:COMPILE-METHOD</a></pre></div> </article> </li><li> <a name="QTOOLS:COPY-QOBJECT"> </a> <article id="FUNCTION QTOOLS:COPY-QOBJECT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3ACOPY-QOBJECT">COPY-QOBJECT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">INSTANCE</code><code>)</code> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="QTOOLS:DEFAULT-APPLICATION-NAME"> </a> <article id="FUNCTION QTOOLS:DEFAULT-APPLICATION-NAME"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3ADEFAULT-APPLICATION-NAME">DEFAULT-APPLICATION-NAME</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Attempts to find and return a default name to use for the application.</pre></div> </article> </li><li> <a name="QTOOLS:DESCRIBE-COPY-METHOD"> </a> <article id="FUNCTION QTOOLS:DESCRIBE-COPY-METHOD"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3ADESCRIBE-COPY-METHOD">DESCRIBE-COPY-METHOD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CLASS</code><code>)</code> </header> <div class="docstring"><pre>Prints information about the copy method for the specified class if possible.</pre></div> </article> </li><li> <a name="QTOOLS:DESCRIBE-FINALIZE-METHOD"> </a> <article id="FUNCTION QTOOLS:DESCRIBE-FINALIZE-METHOD"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3ADESCRIBE-FINALIZE-METHOD">DESCRIBE-FINALIZE-METHOD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CLASS</code><code>)</code> </header> <div class="docstring"><pre>Prints information about the finalize method for the given class if possible.</pre></div> </article> </li><li> <a name="QTOOLS:DESCRIBE-PRINT-METHOD"> </a> <article id="FUNCTION QTOOLS:DESCRIBE-PRINT-METHOD"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3ADESCRIBE-PRINT-METHOD">DESCRIBE-PRINT-METHOD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CLASS</code><code>)</code> </header> <div class="docstring"><pre>Prints information about the print method for the specified class if possible.</pre></div> </article> </li><li> <a name="QTOOLS:DETERMINED-TYPE-METHOD-NAME"> </a> <article id="FUNCTION QTOOLS:DETERMINED-TYPE-METHOD-NAME"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3ADETERMINED-TYPE-METHOD-NAME">DETERMINED-TYPE-METHOD-NAME</a></code></h4> <code class="qualifiers"></code> <code class="arguments">FUNCTION ARGS</code><code>)</code> </header> <div class="docstring"><pre>Returns a method designator for the FUNCTION and ARGS.
The FUNCTION is transformed as by TO-METHOD-NAME.
Argument types are determined as follows:
If the argument is a CONS, the CAR is taken as a value (and thus discarded)
and the CDR is the literal type to take. Otherwise the type is determined
by EQT-TYPE-OF.</pre></div> </article> </li><li> <a name="QTOOLS:DIRECT-QSUBCLASS-P"> </a> <article id="FUNCTION QTOOLS:DIRECT-QSUBCLASS-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3ADIRECT-QSUBCLASS-P">DIRECT-QSUBCLASS-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">QCLASS MAYBE-SUPERCLASS</code><code>)</code> </header> <div class="docstring"><pre>Returns T if MAYBE-SUPERCLASS is a direct superclass of QCLASS.</pre></div> </article> </li><li> <a name="QTOOLS:DISPATCH-BY-QCLASS"> </a> <article id="FUNCTION QTOOLS:DISPATCH-BY-QCLASS"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3ADISPATCH-BY-QCLASS">DISPATCH-BY-QCLASS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">METHOD-LOCATOR OBJECT &REST ARGS</code><code>)</code> </header> <div class="docstring"><pre>Dispatches on the given-method locator by the object.
The METHOD-LOCATOR should be a function of a single argument-- a qclass,
which returns the appropriate method for that class or NIL if none.
If the method-locator does not return a function for all classes in the
precedence list for the object, NO-APPLICABLE-METHOD is called.
This binds *QCLASS-PRECEDENCE-LIST*.
See <a href="#QTOOLS:QCLASS-PRECEDENCE-LIST">QCLASS-PRECEDENCE-LIST</a></pre></div> </article> </li><li> <a name="QTOOLS:ECL-TYPE-FOR"> </a> <article id="FUNCTION QTOOLS:ECL-TYPE-FOR"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AECL-TYPE-FOR">ECL-TYPE-FOR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">QT-TYPE</code><code>)</code> </header> <div class="docstring"><pre>Same as CL-TYPE-FOR, but signals an error if no matching type could be found.</pre></div> </article> </li><li> <a name="QTOOLS:EMIT-COMPILATION-NOTE"> </a> <article id="FUNCTION QTOOLS:EMIT-COMPILATION-NOTE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AEMIT-COMPILATION-NOTE">EMIT-COMPILATION-NOTE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">FORMAT-STRING &REST ARGS</code><code>)</code> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="QTOOLS:ENSURE-CLASS"> </a> <article id="FUNCTION QTOOLS:ENSURE-CLASS"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AENSURE-CLASS">ENSURE-CLASS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">THING</code><code>)</code> </header> <div class="docstring"><pre>Ensures to return a CLASS.
SYMBOL -> FIND-CLASS
CLASS -> IDENTITY
STANDARD-OBJECT -> CLASS-OF</pre></div> </article> </li><li> <a name="QTOOLS:ENSURE-METHODS-PROCESSED"> </a> <article id="FUNCTION QTOOLS:ENSURE-METHODS-PROCESSED"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AENSURE-METHODS-PROCESSED">ENSURE-METHODS-PROCESSED</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Ensures that all methods have been generated for the currently loaded smoke modules.
See <a href="#QTOOLS:LOADED-SMOKE-MODULES">QTOOLS:LOADED-SMOKE-MODULES</a>
See <a href="#QTOOLS:*GENERATED-MODULES*">QTOOLS:*GENERATED-MODULES*</a>
See <a href="#QTOOLS:PROCESS-ALL-METHODS">QTOOLS:PROCESS-ALL-METHODS</a></pre></div> </article> </li><li> <a name="QTOOLS:ENSURE-Q+-METHOD"> </a> <article id="FUNCTION QTOOLS:ENSURE-Q+-METHOD"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AENSURE-Q%2B-METHOD">ENSURE-Q+-METHOD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">FUNCTION</code><code>)</code> </header> <div class="docstring"><pre>Ensures that the Q+ FUNCTION exists by compiling it on the fly.
Raises an error if no appropriate function can be found.
Returns the proper *TARGET-PACKAGE* symbol for the function.
See <a href="#QTOOLS:ENSURE-METHODS-PROCESSED">QTOOLS:ENSURE-METHODS-PROCESSED</a>
See <a href="#QTOOLS:COMPILE-WRAPPER">QTOOLS:COMPILE-WRAPPER</a>
See <a href="#QTOOLS:*TARGET-PACKAGE*">QTOOLS:*TARGET-PACKAGE*</a></pre></div> </article> </li><li> <a name="QTOOLS:ENSURE-QAPPLICATION"> </a> <article id="FUNCTION QTOOLS:ENSURE-QAPPLICATION"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AENSURE-QAPPLICATION">ENSURE-QAPPLICATION</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&KEY NAME ARGS (MAIN-THREAD T)</code><code>)</code> </header> <div class="docstring"><pre>Ensures that the QT:*QAPPLICATION* is available, potentially using NAME and ARGS to initialize it.
See <a href="#CL+QT:*QAPPLICATION*">QT:*QAPPLICATION*</a>
See <a href="#CL+QT:ENSURE-SMOKE">QT:ENSURE-SMOKE</a></pre></div> </article> </li><li> <a name="QTOOLS:ENSURE-QCLASS"> </a> <article id="FUNCTION QTOOLS:ENSURE-QCLASS"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AENSURE-QCLASS">ENSURE-QCLASS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">THING</code><code>)</code> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="QTOOLS:ENSURE-QOBJECT"> </a> <article id="FUNCTION QTOOLS:ENSURE-QOBJECT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AENSURE-QOBJECT">ENSURE-QOBJECT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">THING</code><code>)</code> </header> <div class="docstring"><pre>Makes sure that THING is a usable qobject.
THING can be of type:
FUNCTION --- ENSURE-QOBJECT is called on the return value of the function.
QT:QOBJECT --- THING is returned.
WIDGET --- THING is returned.
SYMBOL --- MAKE-INSTANCE is called on THING.
STRING --- QT:INTERPRET-NEW is called on THING.</pre></div> </article> </li><li> <a name="QTOOLS:ENUMERATE-METHOD-DESCRIPTORS"> </a> <article id="FUNCTION QTOOLS:ENUMERATE-METHOD-DESCRIPTORS"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AENUMERATE-METHOD-DESCRIPTORS">ENUMERATE-METHOD-DESCRIPTORS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME ARGS</code><code>)</code> </header> <div class="docstring"><pre>Returns a list of all possible method descriptors with NAME and ARGS.
Args may be either a list of direct types to use or a list of alternative types.
In the case of lists, the argument alternatives are taken in parallel.
Examples:
(.. foo '(a b)) => ("foo(a,b)")
(.. foo '((a b))) => ("foo(a)" "foo(b)")
(.. foo '((a b) (0 1))) => ("foo(a,0)" "foo(b,1)")</pre></div> </article> </li><li> <a name="QTOOLS:EQT-CLASS-NAME"> </a> <article id="FUNCTION QTOOLS:EQT-CLASS-NAME"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AEQT-CLASS-NAME">EQT-CLASS-NAME</a></code></h4> <code class="qualifiers"></code> <code class="arguments">DESIGNATOR</code><code>)</code> </header> <div class="docstring"><pre>Returns the string designating an equivalent Qt class, if possible.
If the designator is a string, it is returned immediately without further check.
If it is a symbol, it is resolved through FIND-QT-CLASS-NAME, and if no name can
be found through that, an error is signalled.</pre></div> </article> </li><li> <a name="QTOOLS:EQT-TYPE-OF"> </a> <article id="FUNCTION QTOOLS:EQT-TYPE-OF"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AEQT-TYPE-OF">EQT-TYPE-OF</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Same as QT-TYPE-OF, but signals an error if no matching type could be found.</pre></div> </article> </li><li> <a name="QTOOLS:FINALIZE-QOBJECT"> </a> <article id="FUNCTION QTOOLS:FINALIZE-QOBJECT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AFINALIZE-QOBJECT">FINALIZE-QOBJECT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">INSTANCE</code><code>)</code> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="QTOOLS:FIND-CHILD"> </a> <article id="FUNCTION QTOOLS:FIND-CHILD"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AFIND-CHILD">FIND-CHILD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">WIDGET CHILD-CLASS</code><code>)</code> </header> <div class="docstring"><pre>Find the first child that is an instance of CHILD-CLASS
See <a href="#QTOOLS:FIND-CHILDREN">FIND-CHILDREN</a></pre></div> </article> </li><li> <a name="QTOOLS:FIND-CHILDREN"> </a> <article id="FUNCTION QTOOLS:FIND-CHILDREN"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AFIND-CHILDREN">FIND-CHILDREN</a></code></h4> <code class="qualifiers"></code> <code class="arguments">WIDGET CHILD-CLASS &KEY FIRST-ONLY</code><code>)</code> </header> <div class="docstring"><pre>Find all children that are an instance of CHILD-CLASS
If FIRST-ONLY is non-NIL, only the first match is found, otherwise
a list is returned.
See <a href="#QTOOLS:QINSTANCEP">QINSTANCEP</a></pre></div> </article> </li><li> <a name="QTOOLS:FIND-FASTCALL-METHOD"> </a> <article id="FUNCTION QTOOLS:FIND-FASTCALL-METHOD"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AFIND-FASTCALL-METHOD">FIND-FASTCALL-METHOD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CLASS NAME &REST ARGTYPES</code><code>)</code> </header> <div class="docstring"><pre>Attempts to find a matching method on the class.
This is done by iterating over all methods that match the name and comparing
the belonging class and its argument types. If you specify an argument type
that is unknown, an error will be signalled. If no matching method can be
found, NIL is returned.
See <a href="#QTOOLS:FAST-CALL">FAST-CALL</a>
See <a href="#QTOOLS:ENSURE-Q+-METHOD">ENSURE-Q+-METHOD</a></pre></div> </article> </li><li> <a name="QTOOLS:FIND-QT-CLASS-NAME"> </a> <article id="FUNCTION QTOOLS:FIND-QT-CLASS-NAME"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AFIND-QT-CLASS-NAME">FIND-QT-CLASS-NAME</a></code></h4> <code class="qualifiers"></code> <code class="arguments">DESIGNATOR</code><code>)</code> </header> <div class="docstring"><pre>Returns the string designating an equivalent Qt class. You can use this to resolve
symbols and 'lisp-ified' names to Qt class names. Hyphens are stripped from the designator.
See <a href="#QTOOLS:*QT-CLASS-MAP*">*QT-CLASS-MAP*</a></pre></div> </article> </li><li> <a name="QTOOLS:FUSE-ALISTS"> </a> <article id="FUNCTION QTOOLS:FUSE-ALISTS"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AFUSE-ALISTS">FUSE-ALISTS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&REST ALISTS-LISTS</code><code>)</code> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="QTOOLS:FUSE-PLISTS"> </a> <article id="FUNCTION QTOOLS:FUSE-PLISTS"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AFUSE-PLISTS">FUSE-PLISTS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&REST PLISTS-LISTS</code><code>)</code> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="QTOOLS:GENERIC-SIGNAL"> </a> <article id="FUNCTION QTOOLS:GENERIC-SIGNAL"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AGENERIC-SIGNAL">GENERIC-SIGNAL</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT FUNCTION &REST ARGS</code><code>)</code> </header> <div class="docstring"><pre>Attempts to signal the function FUNCTION on OBJECT by determining the
types according to the run-time types of the values.
This is SLOW as the signal method has to be determined at run-time and it
is DANGEROUS as the type mapping are ambiguous or even unknown for certain
arguments and as such the wrong signal may be called or even one that does
not actually exist. If you want to explicitly specify the type of the
argument, wrap it in a CONS where the CAR is the value and the CDR is a
string for the according Qt type.
A compiler macro will try to statically determine types as best as possible,
so GENERIC-SIGNAL is save to use for static values.</pre></div> </article> </li><li> <a name="QTOOLS:LOAD-ALL-SMOKE-MODULES"> </a> <article id="FUNCTION QTOOLS:LOAD-ALL-SMOKE-MODULES"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3ALOAD-ALL-SMOKE-MODULES">LOAD-ALL-SMOKE-MODULES</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&REST MODS</code><code>)</code> </header> <div class="docstring"><pre>Loads all the smoke modules as passed.
See <a href="#CL+QT:ENSURE-SMOKE">QT:ENSURE-SMOKE</a></pre></div> </article> </li><li> <a name="QTOOLS:LOADED-SMOKE-MODULES"> </a> <article id="FUNCTION QTOOLS:LOADED-SMOKE-MODULES"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3ALOADED-SMOKE-MODULES">LOADED-SMOKE-MODULES</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Returns a fresh list of currently loaded smoke modules.
See <a href="#QTOOLS:*SMOKE-MODULES*">QTOOLS:*SMOKE-MODULES*</a>
See <a href="NIL">QT:NAMED-MODULE-NUMBER</a></pre></div> </article> </li><li> <a name="QTOOLS:MAKE-CHORD"> </a> <article id="FUNCTION QTOOLS:MAKE-CHORD"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AMAKE-CHORD">MAKE-CHORD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHORD</code><code>)</code> </header> <div class="docstring"><pre>Transforms CHORD into a keychord string, if possible.</pre></div> </article> </li><li> <a name="QTOOLS:MAKE-GC-FINALIZED"> </a> <article id="FUNCTION QTOOLS:MAKE-GC-FINALIZED"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AMAKE-GC-FINALIZED">MAKE-GC-FINALIZED</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Wrap the OBJECT in a GC-FINALIZED instance. Use UNBOX to retrieve the object again.</pre></div> </article> </li><li> <a name="QTOOLS:MAP-COMPILE-ALL"> </a> <article id="FUNCTION QTOOLS:MAP-COMPILE-ALL"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AMAP-COMPILE-ALL">MAP-COMPILE-ALL</a></code></h4> <code class="qualifiers"></code> <code class="arguments">FUNCTION</code><code>)</code> </header> <div class="docstring"><pre>Calls FUNCTION with the result of COMPILE-WRAPPER on all available methods.
See <a href="#QTOOLS:COMPILE-WRAPPER">QTOOLS:COMPILE-WRAPPER</a>
See <a href="#QTOOLS:*QMETHODS*">QTOOLS:*QMETHODS*</a></pre></div> </article> </li><li> <a name="QTOOLS:MAP-LAYOUT"> </a> <article id="FUNCTION QTOOLS:MAP-LAYOUT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AMAP-LAYOUT">MAP-LAYOUT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">FUNCTION LAYOUT</code><code>)</code> </header> <div class="docstring"><pre>Map all widgets and layouts on LAYOUT onto FUNCTION.</pre></div> </article> </li><li> <a name="QTOOLS:MAYBE-DELETE-QOBJECT"> </a> <article id="FUNCTION QTOOLS:MAYBE-DELETE-QOBJECT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AMAYBE-DELETE-QOBJECT">MAYBE-DELETE-QOBJECT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Deletes the object if possible.</pre></div> </article> </li><li> <a name="QTOOLS:METHOD-SYMBOL"> </a> <article id="FUNCTION QTOOLS:METHOD-SYMBOL"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AMETHOD-SYMBOL">METHOD-SYMBOL</a></code></h4> <code class="qualifiers"></code> <code class="arguments">METHOD</code><code>)</code> </header> <div class="docstring"><pre>Returns an appropriate symbol to use for the name of the wrapper function for METHOD.
See <a href="NIL">QT:QMETHOD-ENUM-P</a>
See <a href="#QTOOLS:CL-CONSTANT-NAME">QTOOLS:CL-CONSTANT-NAME</a>
See <a href="NIL">QT:QMETHOD-CTOR-P</a>
See <a href="NIL">QT:QMETHOD-COPYCTOR-P</a>
See <a href="#QTOOLS:CL-CONSTRUCTOR-NAME">QTOOLS:CL-CONSTRUCTOR-NAME</a>
See <a href="#QTOOLS:QMETHOD-OPERATOR-P">QTOOLS:QMETHOD-OPERATOR-P</a>
See <a href="#QTOOLS:CL-OPERATOR-NAME">QTOOLS:CL-OPERATOR-NAME</a>
See <a href="NIL">QT:QMETHOD-STATIC-P</a>
See <a href="#QTOOLS:CL-STATIC-METHOD-NAME">QTOOLS:CL-STATIC-METHOD-NAME</a>
See <a href="#QTOOLS:CL-METHOD-NAME">QTOOLS:CL-METHOD-NAME</a></pre></div> </article> </li><li> <a name="QTOOLS:PRINT-QOBJECT"> </a> <article id="FUNCTION QTOOLS:PRINT-QOBJECT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3APRINT-QOBJECT">PRINT-QOBJECT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">INSTANCE STREAM</code><code>)</code> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="QTOOLS:PROCESS-ALL-METHODS"> </a> <article id="FUNCTION QTOOLS:PROCESS-ALL-METHODS"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3APROCESS-ALL-METHODS">PROCESS-ALL-METHODS</a></code></h4> <code class="qualifiers"></code> <code class="arguments"></code><code>)</code> </header> <div class="docstring"><pre>Clears the method table and generates all possible data for the currently available methods.
This also sets the *GENERATED-MODULES* to the proper value.
See <a href="NIL">QT:MAP-METHODS</a>
See <a href="#QTOOLS:PROCESS-METHOD">QTOOLS:PROCESS-METHOD</a>
See <a href="#QTOOLS:CLEAR-METHOD-INFO">QTOOLS:CLEAR-METHOD-INFO</a>
See <a href="#QTOOLS:*GENERATED-MODULES*">QTOOLS:*GENERATED-MODULES*</a>
See <a href="#QTOOLS:LOADED-SMOKE-MODULES">QTOOLS:LOADED-SMOKE-MODULES</a></pre></div> </article> </li><li> <a name="QTOOLS:PROCESS-METHOD"> </a> <article id="FUNCTION QTOOLS:PROCESS-METHOD"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3APROCESS-METHOD">PROCESS-METHOD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">METHOD</code><code>)</code> </header> <div class="docstring"><pre>Push the given METHOD onto its appropriate place in the method table, if it is needed.
See <a href="#QTOOLS:METHOD-NEEDED-P">QTOOLS:METHOD-NEEDED-P</a>
See <a href="#QTOOLS:METHOD-SYMBOL">QTOOLS:METHOD-SYMBOL</a>
See <a href="#QTOOLS:*QMETHODS*">QTOOLS:*QMETHODS*</a></pre></div> </article> </li><li> <a name="QTOOLS:Q+-COMPILE-AND-LOAD"> </a> <article id="FUNCTION QTOOLS:Q+-COMPILE-AND-LOAD"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AQ%2B-COMPILE-AND-LOAD">Q+-COMPILE-AND-LOAD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&KEY MODULES (FILE (MERGE-PATHNAMES "q+.lisp" (TEMPORARY-DIRECTORY)))</code><code>)</code> </header> <div class="docstring"><pre>Writes, compiles, and loads the file for all generated Qt wrapper functions.
If MODULES is passed, CommonQt is reloaded and only the given modules are loaded.
See <a href="#QTOOLS:WRITE-EVERYTHING-TO-FILE">WRITE-EVERYTHING-TO-FILE</a></pre></div> </article> </li><li> <a name="QTOOLS:Q+APROPOS"> </a> <article id="FUNCTION QTOOLS:Q+APROPOS"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AQ%2BAPROPOS">Q+APROPOS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">TERM</code><code>)</code> </header> <div class="docstring"><pre>Searches for Q+ functions that match the term given.
This function is useful to determine the proper converted name for a method or
enum, or to generally discover methods if you cannot recall what it was called
exactly. You can separate terms by a space and only methods that match each
individual term will be shown. Matches are case-insensitive and ignore hyphens
as well as underscores and dots.
Example: (q+apropos "qimage format")
Q+::QIMAGE.FORMAT_INVALID
...
This function calls ENSURE-METHODS-PROCESSED before performing the search to
ensure the method cache is fully populated according to the currently loaded
modules.
See <a href="#QTOOLS:ENSURE-METHODS-PROCESSED">QTOOLS:ENSURE-METHODS-PROCESSED</a>
See <a href="#QTOOLS:*QMETHODS*">QTOOLS:*QMETHODS*</a></pre></div> </article> </li><li> <a name="QTOOLS:QCLASS-PRECEDENCE-LIST"> </a> <article id="FUNCTION QTOOLS:QCLASS-PRECEDENCE-LIST"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AQCLASS-PRECEDENCE-LIST">QCLASS-PRECEDENCE-LIST</a></code></h4> <code class="qualifiers"></code> <code class="arguments">QCLASS</code><code>)</code> </header> <div class="docstring"><pre>Returns the class precedence list for the given qclass.
See <a href="NIL">*QCLASS-PRECEDENCE-LISTS*</a>
See <a href="NIL">COMPUTE-QCLASS-PRECEDENCE-LIST</a></pre></div> </article> </li><li> <a name="QTOOLS:QINSTANCEP"> </a> <article id="FUNCTION QTOOLS:QINSTANCEP"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AQINSTANCEP">QINSTANCEP</a></code></h4> <code class="qualifiers"></code> <code class="arguments">INSTANCE CLASS</code><code>)</code> </header> <div class="docstring"><pre>Tests whether INSTANCE is an INSTANCE of CLASS.
This includes subclasses, so a QSlider instance is also
an instance of a QWidget and so forth.</pre></div> </article> </li><li> <a name="QTOOLS:QOBJECT-ALIVE-P"> </a> <article id="FUNCTION QTOOLS:QOBJECT-ALIVE-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AQOBJECT-ALIVE-P">QOBJECT-ALIVE-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Returns T if the object is not null and not deleted.</pre></div> </article> </li><li> <a name="QTOOLS:QT-TYPE-FOR"> </a> <article id="FUNCTION QTOOLS:QT-TYPE-FOR"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AQT-TYPE-FOR">QT-TYPE-FOR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CL-TYPE</code><code>)</code> </header> <div class="docstring"><pre>Attempts to determine the proper Qt type descriptor for the passed cl type name.
Look at the source to see the mappings.</pre></div> </article> </li><li> <a name="QTOOLS:QT-TYPE-OF"> </a> <article id="FUNCTION QTOOLS:QT-TYPE-OF"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AQT-TYPE-OF">QT-TYPE-OF</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Attempts to determine a proper Qt type descriptor for the type of the OBJECT.
Look at the source to see the mappings.</pre></div> </article> </li><li> <a name="QTOOLS:REMOVE-FINALIZER"> </a> <article id="FUNCTION QTOOLS:REMOVE-FINALIZER"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AREMOVE-FINALIZER">REMOVE-FINALIZER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">WIDGET-CLASS FINALIZER</code><code>)</code> </header> <div class="docstring"><pre>Removes the FINALIZER definition from the WIDGET-CLASS.
Note that this does not remove eventual methods associated with the slot.
See <a href="#QTOOLS:REMOVE-WIDGET-CLASS-OPTION">QTOOLS:REMOVE-WIDGET-CLASS-OPTION</a>
See <a href="#QTOOLS:ENSURE-CLASS">QTOOLS:ENSURE-CLASS</a></pre></div> </article> </li><li> <a name="QTOOLS:REMOVE-INITIALIZER"> </a> <article id="FUNCTION QTOOLS:REMOVE-INITIALIZER"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AREMOVE-INITIALIZER">REMOVE-INITIALIZER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">WIDGET-CLASS INITIALIZER</code><code>)</code> </header> <div class="docstring"><pre>Removes the INITIALIZER definition from the WIDGET-CLASS.
Note that this does not remove eventual methods associated with the slot.
See <a href="#QTOOLS:REMOVE-WIDGET-CLASS-OPTION">QTOOLS:REMOVE-WIDGET-CLASS-OPTION</a>
See <a href="#QTOOLS:ENSURE-CLASS">QTOOLS:ENSURE-CLASS</a></pre></div> </article> </li><li> <a name="QTOOLS:REMOVE-MENU-CONTENT-TYPE"> </a> <article id="FUNCTION QTOOLS:REMOVE-MENU-CONTENT-TYPE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AREMOVE-MENU-CONTENT-TYPE">REMOVE-MENU-CONTENT-TYPE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME</code><code>)</code> </header> <div class="docstring"><pre>Removes the menu content type NAME.</pre></div> </article> </li><li> <a name="QTOOLS:REMOVE-METHOD-DECLARATION"> </a> <article id="FUNCTION QTOOLS:REMOVE-METHOD-DECLARATION"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AREMOVE-METHOD-DECLARATION">REMOVE-METHOD-DECLARATION</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME</code><code>)</code> </header> <div class="docstring"><pre>Remove the method declaration processor function of NAME.</pre></div> </article> </li><li> <a name="QTOOLS:REMOVE-OVERRIDE"> </a> <article id="FUNCTION QTOOLS:REMOVE-OVERRIDE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AREMOVE-OVERRIDE">REMOVE-OVERRIDE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">WIDGET-CLASS OVERRIDE</code><code>)</code> </header> <div class="docstring"><pre>Removes the OVERRIDE definition from the WIDGET-CLASS.
Note that this does not remove eventual methods associated with the override.
See <a href="#QTOOLS:REMOVE-WIDGET-CLASS-OPTION">QTOOLS:REMOVE-WIDGET-CLASS-OPTION</a>
See <a href="#QTOOLS:ENSURE-CLASS">QTOOLS:ENSURE-CLASS</a></pre></div> </article> </li><li> <a name="QTOOLS:REMOVE-SIGNAL"> </a> <article id="FUNCTION QTOOLS:REMOVE-SIGNAL"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AREMOVE-SIGNAL">REMOVE-SIGNAL</a></code></h4> <code class="qualifiers"></code> <code class="arguments">WIDGET-CLASS SIGNAL</code><code>)</code> </header> <div class="docstring"><pre>Removes the SIGNAL definition from the WIDGET-CLASS.
Note that this does not remove eventual methods associated with the slot.
See <a href="#QTOOLS:REMOVE-WIDGET-CLASS-OPTION">QTOOLS:REMOVE-WIDGET-CLASS-OPTION</a>
See <a href="#QTOOLS:ENSURE-CLASS">QTOOLS:ENSURE-CLASS</a></pre></div> </article> </li><li> <a name="QTOOLS:REMOVE-SLOT"> </a> <article id="FUNCTION QTOOLS:REMOVE-SLOT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AREMOVE-SLOT">REMOVE-SLOT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">WIDGET-CLASS SLOT</code><code>)</code> </header> <div class="docstring"><pre>Removes the SLOT definition from the WIDGET-CLASS.
Note that this does not remove eventual methods associated with the slot.
See <a href="#QTOOLS:REMOVE-WIDGET-CLASS-OPTION">QTOOLS:REMOVE-WIDGET-CLASS-OPTION</a>
See <a href="#QTOOLS:ENSURE-CLASS">QTOOLS:ENSURE-CLASS</a></pre></div> </article> </li><li> <a name="QTOOLS:REMOVE-SUBWIDGET"> </a> <article id="FUNCTION QTOOLS:REMOVE-SUBWIDGET"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AREMOVE-SUBWIDGET">REMOVE-SUBWIDGET</a></code></h4> <code class="qualifiers"></code> <code class="arguments">WIDGET-CLASS SUBWIDGET</code><code>)</code> </header> <div class="docstring"><pre>Removes the SUBWIDGET definition from the WIDGET-CLASS.
Note that this does not remove eventual methods associated with the subwidget.
It does however remove the class-slot and initializer of the subwidget.
See <a href="#QTOOLS:REMOVE-WIDGET-CLASS-OPTION">QTOOLS:REMOVE-WIDGET-CLASS-OPTION</a>
See <a href="#QTOOLS:ENSURE-CLASS">QTOOLS:ENSURE-CLASS</a></pre></div> </article> </li><li> <a name="QTOOLS:REMOVE-WIDGET-CLASS-OPTION"> </a> <article id="FUNCTION QTOOLS:REMOVE-WIDGET-CLASS-OPTION"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AREMOVE-WIDGET-CLASS-OPTION">REMOVE-WIDGET-CLASS-OPTION</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CLASS OPTION IDENTIFIER &KEY (KEY (FUNCTION FIRST)) (TEST (FUNCTION EQUAL))</code><code>)</code> </header> <div class="docstring"><pre>Removes a CLASS OPTION value.
The value is identified and distinguished within the OPTION list
by TEST on KEY. If the first item in the sub-list is EQUAL to IDENTIFIER,
it is removed. This causes a call to SOFTLY-REDEFINE-WIDGET-CLASS.
See <a href="#QTOOLS:WIDGET-CLASS-EXTERN-OPTIONS.">QTOOLS:WIDGET-CLASS-EXTERN-OPTIONS.</a>
See <a href="#QTOOLS:SOFTLY-REDEFINE-WIDGET-CLASS.">QTOOLS:SOFTLY-REDEFINE-WIDGET-CLASS.</a></pre></div> </article> </li><li> <a name="QTOOLS:SET-WIDGET-CLASS-OPTION"> </a> <article id="FUNCTION QTOOLS:SET-WIDGET-CLASS-OPTION"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3ASET-WIDGET-CLASS-OPTION">SET-WIDGET-CLASS-OPTION</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CLASS OPTION VALUE &KEY (KEY (FUNCTION FIRST)) (TEST (FUNCTION EQUAL))</code><code>)</code> </header> <div class="docstring"><pre>Sets a CLASS OPTION VALUE.
The value is identified and distinguished within the OPTION list
by TEST on KEY. If a matching list can be found, it is replaced
at the same position. Otherwise it is appended to the end of the
list. The order here is important to preserve load-order.
See <a href="#QTOOLS:WIDGET-CLASS-EXTERN-OPTIONS.">QTOOLS:WIDGET-CLASS-EXTERN-OPTIONS.</a>
See <a href="#QTOOLS:SOFTLY-REDEFINE-WIDGET-CLASS.">QTOOLS:SOFTLY-REDEFINE-WIDGET-CLASS.</a></pre></div> </article> </li><li> <a name="QTOOLS:SOFTLY-REDEFINE-WIDGET-CLASS"> </a> <article id="FUNCTION QTOOLS:SOFTLY-REDEFINE-WIDGET-CLASS"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3ASOFTLY-REDEFINE-WIDGET-CLASS">SOFTLY-REDEFINE-WIDGET-CLASS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CLASS</code><code>)</code> </header> <div class="docstring"><pre>Cause a soft redefinition of the given CLASS.
This will in effect cause a call to REINITIALIZE-INSTANCE with the proper
class options added from WIDGET-CLASS-DIRECT-OPTIONS, followed by a
FINALIZE-INHERITANCE call on the class.</pre></div> </article> </li><li> <a name="QTOOLS:SPECIFIED-TYPE-METHOD-NAME"> </a> <article id="FUNCTION QTOOLS:SPECIFIED-TYPE-METHOD-NAME"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3ASPECIFIED-TYPE-METHOD-NAME">SPECIFIED-TYPE-METHOD-NAME</a></code></h4> <code class="qualifiers"></code> <code class="arguments">FUNCTION ARGS</code><code>)</code> </header> <div class="docstring"><pre>Returns a method designator for the FUNCTION and ARGS.
The FUNCTION is transformed as by TO-METHOD-NAME. Each argument type is
determined as by TO-TYPE-NAME.</pre></div> </article> </li><li> <a name="QTOOLS:SPLIT"> </a> <article id="FUNCTION QTOOLS:SPLIT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3ASPLIT">SPLIT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST ITEMS &KEY (KEY (FUNCTION IDENTITY)) (TEST (FUNCTION EQL))</code><code>)</code> </header> <div class="docstring"><pre>Segregates items in LIST into separate lists if they mach an item in ITEMS.
The first item in the returned list is the list of unmatched items.
Example:
(split '((0 a) (0 b) (1 a) (1 b) (2 c)) '(0 2) :key #'car)
=> '(((1 a) (1 b)) ((0 a) (0 b)) ((2 c))) </pre></div> </article> </li><li> <a name="QTOOLS:SWEEP-LAYOUT"> </a> <article id="FUNCTION QTOOLS:SWEEP-LAYOUT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3ASWEEP-LAYOUT">SWEEP-LAYOUT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LAYOUT &OPTIONAL (FINALIZE T)</code><code>)</code> </header> <div class="docstring"><pre>Removes all widgets from the layout and finalizes them if so desired.
If FINALIZE is NIL, each widget is removed, its parent set to NIL, and
it is hidden as to not show up as a window.</pre></div> </article> </li><li> <a name="QTOOLS:TO-METHOD-NAME"> </a> <article id="FUNCTION QTOOLS:TO-METHOD-NAME"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3ATO-METHOD-NAME">TO-METHOD-NAME</a></code></h4> <code class="qualifiers"></code> <code class="arguments">THING</code><code>)</code> </header> <div class="docstring"><pre>Turns THING into a Qt method name.
If THING is a STRING, it is returned directly.
If THING is a SYMBOL, it is transformed by turning each
character after a hyphen into its uppercase equivalent
and dropping the hyphen. Therefore: foo-bar fooBar</pre></div> </article> </li><li> <a name="QTOOLS:TO-QBYTE-ARRAY"> </a> <article id="FUNCTION QTOOLS:TO-QBYTE-ARRAY"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3ATO-QBYTE-ARRAY">TO-QBYTE-ARRAY</a></code></h4> <code class="qualifiers"></code> <code class="arguments">VECTOR</code><code>)</code> </header> <div class="docstring"><pre>Translates an unsigned-byte 8 vector into a QByteArray.</pre></div> </article> </li><li> <a name="QTOOLS:TO-TYPE-NAME"> </a> <article id="FUNCTION QTOOLS:TO-TYPE-NAME"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3ATO-TYPE-NAME">TO-TYPE-NAME</a></code></h4> <code class="qualifiers"></code> <code class="arguments">THING</code><code>)</code> </header> <div class="docstring"><pre>Returns the type name for THING.
If THING is a string, it is returned directly.
If it is a symbol, either QT-TYPE-FOR for THING is
returned, or the STRING-DOWNCASE of THING.</pre></div> </article> </li><li> <a name="QTOOLS:TRANSLATE-NAME"> </a> <article id="FUNCTION QTOOLS:TRANSLATE-NAME"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3ATRANSLATE-NAME">TRANSLATE-NAME</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME TYPE &OPTIONAL (ERROR-P T)</code><code>)</code> </header> <div class="docstring"><pre>Translates the given name to the requested type, if possible.
When ERROR-P is T and no translation can be found, an error is signalled.
Otherwise in that case NIL is returned.
See <a href="NIL">TRANSLATOR</a></pre></div> </article> </li><li> <a name="QTOOLS:WIDGET-CLASS-OPTION-P"> </a> <article id="FUNCTION QTOOLS:WIDGET-CLASS-OPTION-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AWIDGET-CLASS-OPTION-P">WIDGET-CLASS-OPTION-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CLASS OPTION VALUE &KEY (KEY (FUNCTION FIRST)) (TEST (FUNCTION EQUAL))</code><code>)</code> </header> <div class="docstring"><pre>Tests if OPTION VALUE is already present on CLASS.
Returns the full option value if it can be found.
See <a href="#QTOOLS:SET-WIDGET-CLASS-OPTION">QTOOLS:SET-WIDGET-CLASS-OPTION</a></pre></div> </article> </li><li> <a name="QTOOLS:WRITE-EVERYTHING-TO-FILE"> </a> <article id="FUNCTION QTOOLS:WRITE-EVERYTHING-TO-FILE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20QTOOLS%3AWRITE-EVERYTHING-TO-FILE">WRITE-EVERYTHING-TO-FILE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PATHNAME &KEY (PACKAGE *TARGET-PACKAGE*) (IF-EXISTS :SUPERSEDE)</code><code>)</code> </header> <div class="docstring"><pre>Writes all compileable Qt method wrappers to PATHNAME.
PACKAGE designates in which package the symbols will live.
This makes it possible to deviate from the standard of
*TARGET-PACKAGE*. The value of QTOOLS:*TARGET-PACKAGE*
will be automatically set to this once the resulting file
is LOADed or compiled again.
See <a href="#QTOOLS:WRITE-FORMS">QTOOLS:WRITE-FORMS</a>
See <a href="#QTOOLS:*TARGET-PACKAGE*">QTOOLS:*TARGET-PACKAGE*</a></pre></div> </article> </li><li> <a name="QTOOLS:CONSTRUCT"> </a> <article id="GENERIC QTOOLS:CONSTRUCT"> <header class="generic"> <span class="type">generic</span> <code>(</code><h4 class="name"><code><a href="#GENERIC%20QTOOLS%3ACONSTRUCT">CONSTRUCT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">WIDGET</code><code>)</code> </header> <div class="docstring"><pre>This method is called during the initialization of a widget instance.
It MUST call QT:NEW on the widget at some point. Its primary
purpose is to give the user some way to manipulate which arguments
are passed to QT:NEW. By default, no arguments are passed.</pre></div> </article> </li><li> <a name="QTOOLS:COPY"> </a> <article id="GENERIC QTOOLS:COPY"> <header class="generic"> <span class="type">generic</span> <code>(</code><h4 class="name"><code><a href="#GENERIC%20QTOOLS%3ACOPY">COPY</a></code></h4> <code class="qualifiers"></code> <code class="arguments">INSTANCE</code><code>)</code> </header> <div class="docstring"><pre>Generates a copy of the object.
The way objects are copied varies, but usually it can be assumed that the
copy is made in a way such that data immediately associated with the object
is copied (such as pixel data in an image), but data only implicitly
referenced (such as the paint device of a painter) is not.
Use DESCRIBE-COPY-METHOD for information on a specific copying mechanism.
Uses COPY-QOBJECT-USING-CLASS and determines the class by QT::QOBJECT-CLASS.</pre></div> </article> </li><li> <a name="QTOOLS:FINALIZE"> </a> <article id="GENERIC QTOOLS:FINALIZE"> <header class="generic"> <span class="type">generic</span> <code>(</code><h4 class="name"><code><a href="#GENERIC%20QTOOLS%3AFINALIZE">FINALIZE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Finalizes the object. The effects thereof may vary and even result in nothing at all.
After FINALIZE has been called on an object, it should not be attempted to be used in any fashion
whatsoever as it may have been rendered unusable or unstable.
This method should be called on any object once it is known that it can be discarded.
FINALIZE will then try to clean up objects and make sure that they don't clutter your
memory, as lingering QOBJECTs would.</pre></div> </article> </li><li> <a name="QTOOLS:FINALIZED"> </a> <article id="GENERIC QTOOLS:FINALIZED"> <header class="generic"> <span class="type">generic</span> <code>(</code><h4 class="name"><code><a href="#GENERIC%20QTOOLS%3AFINALIZED">FINALIZED</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="QTOOLS:UNBOX"> </a> <article id="GENERIC QTOOLS:UNBOX"> <header class="generic"> <span class="type">generic</span> <code>(</code><h4 class="name"><code><a href="#GENERIC%20QTOOLS%3AUNBOX">UNBOX</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="QTOOLS:CONNECT!"> </a> <article id="MACRO QTOOLS:CONNECT!"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3ACONNECT%21">CONNECT!</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ORIGIN ORIGIN-FUNCTION TARGET TARGET-FUNCTION</code><code>)</code> </header> <div class="docstring"><pre>Macro for a more lisp-y writing of CONNECT.
ORIGIN-FUNCTION and TARGET-FUNCTION should both be a list of the METHOD-NAME
followed by Qt argument types. The effective method name is computed as per
SPECIFIED-TYPE-METHOD-NAME.
ORIGIN and TARGET can both be either a single object or a list of objects
to connect with each other.</pre></div> </article> </li><li> <a name="QTOOLS:DEFINE-1->1-TRANSLATOR"> </a> <article id="MACRO QTOOLS:DEFINE-1->1-TRANSLATOR"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3ADEFINE-1-%3E1-TRANSLATOR">DEFINE-1->1-TRANSLATOR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">TYPE MATCH RESULT &KEY (TEST '(FUNCTION STRING-EQUAL)) (PRIORITY 0)</code><code>)</code> </header> <div class="docstring"><pre>Defines a translator for a one to one mapping.
The match is compared to the inputted name by STRING-EQUAL by default. A different
comparison function can be specified through the TEST keyword argument. This function
receives the given name to be translated as the first argument and the match as the
second.
The match is used as the name after being interned.
See <a href="#QTOOLS:DEFINE-SIMPLE-TRANSLATOR">DEFINE-SIMPLE-TRANSLATOR</a></pre></div> </article> </li><li> <a name="QTOOLS:DEFINE-COPY-METHOD"> </a> <article id="MACRO QTOOLS:DEFINE-COPY-METHOD"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3ADEFINE-COPY-METHOD">DEFINE-COPY-METHOD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(INSTANCE CLASS) &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Defines a method to copy an object of CLASS.
CLASS can be either a common-lisp class type or a Qt class name.
Qt class names will take precedence, meaning that if CLASS resolves
to a name using FIND-QT-CLASS-NAME a QCLASS-COPY method
is defined on the respective qt-class. Otherwise a COPY method
is defined with the CLASS directly as specializer for the instance.
In cases where you need to define a method on a same-named CL class,
directly use DEFMETHOD on COPY-QOBJECT.
See <a href="#QTOOLS:COPY-QOBJECT">COPY-QOBJECT</a></pre></div> </article> </li><li> <a name="QTOOLS:DEFINE-FINALIZABLE"> </a> <article id="MACRO QTOOLS:DEFINE-FINALIZABLE"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3ADEFINE-FINALIZABLE">DEFINE-FINALIZABLE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME DIRECT-SUPERCLASSES DIRECT-SLOTS &REST OPTIONS</code><code>)</code> </header> <div class="docstring"><pre>Shorthand around DEFCLASS to create a finalizable class.
Automatically adds FINALIZABLE as direct-superclass and
FINALIZABLE-CLASS as metaclass.</pre></div> </article> </li><li> <a name="QTOOLS:DEFINE-FINALIZE-METHOD"> </a> <article id="MACRO QTOOLS:DEFINE-FINALIZE-METHOD"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3ADEFINE-FINALIZE-METHOD">DEFINE-FINALIZE-METHOD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(INSTANCE CLASS) &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Defines a method to finalize an object of CLASS.
CLASS can be either a common-lisp class type or a Qt class name.
Qt class names will take precedence, meaning that if CLASS resolves
to a name using FIND-QT-CLASS-NAME a FINALIZE-QCLASS method
is defined on the respective qt-class. Otherwise a FINALIZE method
is defined with the CLASS directly as specializer for the instance.
In cases where you need to define a method on a same-named CL class,
directly use DEFMETHOD on FINALIZE.
See <a href="#QTOOLS:FINALIZE">FINALIZE</a></pre></div> </article> </li><li> <a name="QTOOLS:DEFINE-FINALIZER"> </a> <article id="MACRO QTOOLS:DEFINE-FINALIZER"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3ADEFINE-FINALIZER">DEFINE-FINALIZER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(WIDGET-CLASS METHOD-NAME &OPTIONAL (PRIORITY)) &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Defines a new finalizer of METHOD-NAME on WIDGET-CLASS.
Finalizers are functions that are run immediately after the widget has been
FINALIZED, but before the main FINALIZE method kicks in. This means that the
widget will still be allocated at the time. Finalizers are executed in order
of highest PRIORITY first.
This is translated to a method definition specialised (and bound) on WIDGET-CLASS
with a FINALIZER declaration. The BODY is wrapped in a WITH-SLOTS-BOUND form.
See <a href="#CL+QT:DEFMETHOD">CL+QT:DEFMETHOD</a>
See <a href="#QTOOLS:WITH-SLOTS-BOUND">QTOOLS:WITH-SLOTS-BOUND</a>
See <a href="#QTOOLS:FINALIZE">QTOOLS:FINALIZE</a></pre></div> </article> </li><li> <a name="QTOOLS:DEFINE-INITIALIZER"> </a> <article id="MACRO QTOOLS:DEFINE-INITIALIZER"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3ADEFINE-INITIALIZER">DEFINE-INITIALIZER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(WIDGET-CLASS METHOD-NAME &OPTIONAL (PRIORITY)) &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Defines a new initializer of METHOD-NAME on WIDGET-CLASS.
Initializers are functions that are run immediately after the widget has been
allocated by QT:NEW, but before any INITIALIZE-INSTANCE:AFTER methods are
executed. They are executed in order of highest PRIORITY first.
This is translated to a method definition specialised (and bound) on WIDGET-CLASS
with a INITIALIZER declaration. The BODY is wrapped in a WITH-SLOTS-BOUND form.
See <a href="#CL+QT:DEFMETHOD">CL+QT:DEFMETHOD</a>
See <a href="#QTOOLS:WITH-SLOTS-BOUND">QTOOLS:WITH-SLOTS-BOUND</a></pre></div> </article> </li><li> <a name="QTOOLS:DEFINE-MENU"> </a> <article id="MACRO QTOOLS:DEFINE-MENU"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3ADEFINE-MENU">DEFINE-MENU</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(WIDGET-CLASS NAME) &BODY CONTENTS</code><code>)</code> </header> <div class="docstring"><pre>Defines a menu on WIDGET-CLASS with NAME and CONTENTS.
By default the following content types are available:
A :MENU form is followed by a menu text string and a
body of content forms.
A :SEPARATOR simply adds a separator at its point to
the parent and takes no further arguments.
An :ITEM form is followed by an identifier, which may
be a symbol, string, or list. In the case of a symbol,
the item is taken from the according slot on the widget.
In the case of a string the string serves as the text
for the item. For a list, the first serves as the text
and the second as an input acceptable to MAKE-CHORD.
The body of the item form can be arbitrary lisp forms
to be executed when the item is triggered.
See <a href="#QTOOLS:MAKE-CHORD.">QTOOLS:MAKE-CHORD.</a></pre></div> </article> </li><li> <a name="QTOOLS:DEFINE-MENU-CONTENT-TYPE"> </a> <article id="MACRO QTOOLS:DEFINE-MENU-CONTENT-TYPE"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3ADEFINE-MENU-CONTENT-TYPE">DEFINE-MENU-CONTENT-TYPE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">TYPE (PARENT &REST ARGS) &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Defines a new menu content type processor NAME.
See <a href="NIL">(SETF</a> QTOOLS:MENU-CONTENT-TYPE).</pre></div> </article> </li><li> <a name="QTOOLS:DEFINE-METHOD-DECLARATION"> </a> <article id="MACRO QTOOLS:DEFINE-METHOD-DECLARATION"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3ADEFINE-METHOD-DECLARATION">DEFINE-METHOD-DECLARATION</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME ARGS &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Define a new method declaration function of NAME.
See <a href="NIL">(SETF</a> QTOOLS:METHOD-DECLARATION).</pre></div> </article> </li><li> <a name="QTOOLS:DEFINE-OBJECT"> </a> <article id="MACRO QTOOLS:DEFINE-OBJECT"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3ADEFINE-OBJECT">DEFINE-OBJECT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME (QT-CLASS &REST DIRECT-SUPERCLASSES) DIRECT-SLOTS &REST OPTIONS</code><code>)</code> </header> <div class="docstring"><pre>Alias for DEFINE-WIDGET.
This is merely here for clarity.
See <a href="#QTOOLS:DEFINE-WIDGET">QTOOLS:DEFINE-WIDGET</a></pre></div> </article> </li><li> <a name="QTOOLS:DEFINE-OVERRIDE"> </a> <article id="MACRO QTOOLS:DEFINE-OVERRIDE"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3ADEFINE-OVERRIDE">DEFINE-OVERRIDE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(WIDGET-CLASS OVERRIDE &OPTIONAL METHOD-NAME) ARGS &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Define a new OVERRIDE on WIDGET-CLASS with ARGS.
This is translated to a method definition with METHOD-NAME that specialises
(and binds) on WIDGET-CLASS, with ARGS appended to the list, and an OVERRIDE
declaration in the body. Additionally, the body is wrapped in a WITH-SLOTS-BOUND
to allow for convenient slot access.
See <a href="#CL+QT:DEFMETHOD">CL+QT:DEFMETHOD</a>
See <a href="#QTOOLS:WITH-SLOTS-BOUND">QTOOLS:WITH-SLOTS-BOUND</a>
See <a href="NIL">CommonQt/override</a></pre></div> </article> </li><li> <a name="QTOOLS:DEFINE-PRINT-METHOD"> </a> <article id="MACRO QTOOLS:DEFINE-PRINT-METHOD"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3ADEFINE-PRINT-METHOD">DEFINE-PRINT-METHOD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(INSTANCE CLASS STREAM) &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Defines a method to print an object of CLASS.
CLASS can be either a common-lisp class type or a Qt class name.
Qt class names will take precedence, meaning that if CLASS resolves
to a name using FIND-QT-CLASS-NAME a QCLASS-PRINT method
is defined on the respective qt-class. Otherwise a PRINT-OBJECT method
is defined with the CLASS directly as specializer for the instance.
In cases where you need to define a method on a same-named CL class,
directly use DEFMETHOD on PRINT-OBJECT.
See <a href="#CL+QT:PRINT-OBJECT">PRINT-OBJECT</a></pre></div> </article> </li><li> <a name="QTOOLS:DEFINE-QCLASS-DISPATCH-FUNCTION"> </a> <article id="MACRO QTOOLS:DEFINE-QCLASS-DISPATCH-FUNCTION"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3ADEFINE-QCLASS-DISPATCH-FUNCTION">DEFINE-QCLASS-DISPATCH-FUNCTION</a></code></h4> <code class="qualifiers"></code> <code class="arguments">BASENAME DISPATCHER ARGS</code><code>)</code> </header> <div class="docstring"><pre>Defines a sort of generic function that dispatches by qclass.
This can be used to write methods that dispatch as CLOS would, but on Qt
internal classes. In specific, it defines the following things all in one:
1. A variable *QCLASS-basename-FUNCTIONS* that contains all the methods you
define on the function.
2. An accessor function QCLASS-basename-FUNCTION that takes a qclass and
accesses the appropriate method function.
3. A function REMOVE-QCLASS-basename-FUNCTION to remove a method function.
4. A macro DEFINE-QCLASS-basename-FUNCTION to define a method on the
qclass generic function. The macro will expect a qclass, a lambda-list,
and a body as arguments.
5. A function DISPATCHER that is used as the "generic function".
Note that multiple-dispatch is not possible with this. Dispatch only ever
happens on the first argument, which must be a qclass instance. There is
also no method combination. Defining a second method on the same qclass will
simply replace the old definition.
However the local CALL-NEXT-METHOD and NEXT-METHOD-P functions are available
in a method body.
See <a href="NIL">GENERATE-QCLASS-DISPATCH-LAMBDA</a>
See <a href="#QTOOLS:DISPATCH-BY-QCLASS">DISPATCH-BY-QCLASS</a></pre></div> </article> </li><li> <a name="QTOOLS:DEFINE-SIGNAL"> </a> <article id="MACRO QTOOLS:DEFINE-SIGNAL"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3ADEFINE-SIGNAL">DEFINE-SIGNAL</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(WIDGET-CLASS SIGNAL) ARGS &BODY OPTIONS</code><code>)</code> </header> <div class="docstring"><pre>Define a new SIGNAL on WIDGET-CLASS with ARGS.
This evaluates to a simple SET-WIDGET-CLASS-OPTION that adds a new :SIGNAL
definition to the WIDGET-CLASS. The signal signature is generated using
SPECIFIED-TYPE-METHOD-NAME.
See <a href="NIL">CommonQt/signals</a></pre></div> </article> </li><li> <a name="QTOOLS:DEFINE-SIGNAL-METHOD"> </a> <article id="MACRO QTOOLS:DEFINE-SIGNAL-METHOD"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3ADEFINE-SIGNAL-METHOD">DEFINE-SIGNAL-METHOD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME ARGS</code><code>)</code> </header> <div class="docstring"><pre>Shorthand to define wrapper methods for the given signal.
NAME ::= signal | (signal method-name)
ARGS ::= ARG*
ARG ::= qt-type | (qt-type*)
A methods with name NAME are generated that takes arguments the
object to signal and the specified arguments with their according types.
You may either specify a single type on each argument, or lists of
correlating types for each argument. Each type is resolved as per
ECL-TYPE-FOR to a type to use in the method specializers. The signal
method to call is computed as per SPECIFIED-TYPE-METHOD-NAME.</pre></div> </article> </li><li> <a name="QTOOLS:DEFINE-SIMPLE-TRANSLATOR"> </a> <article id="MACRO QTOOLS:DEFINE-SIMPLE-TRANSLATOR"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3ADEFINE-SIMPLE-TRANSLATOR">DEFINE-SIMPLE-TRANSLATOR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(TYPE NAME &OPTIONAL (PRIORITY)) (SOURCE) &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Define a translator function for a singular type.
In addition to defining a standard translator, this constructs a name out of the given
type as well as its name. This makes it possible to use the same name in the definition
for multiple types of translators.
See <a href="#QTOOLS:DEFINE-TRANSLATOR">DEFINE-TRANSLATOR</a></pre></div> </article> </li><li> <a name="QTOOLS:DEFINE-SLOT"> </a> <article id="MACRO QTOOLS:DEFINE-SLOT"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3ADEFINE-SLOT">DEFINE-SLOT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(WIDGET-CLASS SLOT &OPTIONAL METHOD-NAME) ARGS &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Define a new SLOT on WIDGET-CLASS with ARGS.
ARGS is a list of arguments, where each item is a list of two values,
the first being the symbol used to bind the value within the function
body, and the second being a type specifier usable for the slot definition
and, if possible, as a specializer in the method. You may specify an
explicit type to use for the method specializer as a third item. If no
explicit type is passed, the Qt type is translated using CL-TYPE-FOR.
In effect this translates to a method definition with METHOD-NAME that
specialises (and binds) on WIDGET-CLASS, with additional required arguments
ARGS, and a SLOT declaration. Additionally, the body is wrapped in a
WITH-SLOTS-BOUND to allow for convenient slot access.
See <a href="#QTOOLS:CL-TYPE-FOR">QTOOLS:CL-TYPE-FOR</a>
See <a href="#CL+QT:DEFMETHOD">CL+QT:DEFMETHOD</a>
See <a href="#QTOOLS:WITH-SLOTS-BOUND">QTOOLS:WITH-SLOTS-BOUND</a>
See <a href="NIL">CommonQt/slots</a></pre></div> </article> </li><li> <a name="QTOOLS:DEFINE-SUBOBJECT"> </a> <article id="MACRO QTOOLS:DEFINE-SUBOBJECT"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3ADEFINE-SUBOBJECT">DEFINE-SUBOBJECT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(OBJECT-CLASS NAME) INITFORM &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Alias for DEFINE-SUBWIDGET
This is merely here for clarity.
See <a href="#QTOOLS:DEFINE-SUBOBJECT">QTOOLS:DEFINE-SUBOBJECT</a></pre></div> </article> </li><li> <a name="QTOOLS:DEFINE-SUBWIDGET"> </a> <article id="MACRO QTOOLS:DEFINE-SUBWIDGET"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3ADEFINE-SUBWIDGET">DEFINE-SUBWIDGET</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(WIDGET-CLASS NAME) INITFORM &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Defines a new sub-widget of NAME on WIDGET-CLASS.
What this means is that a finalized slot of NAME is added to WIDGET-CLASS
as well as an initializer function for the slot. The slot for the sub-widget
is set to the value returned by the INITFORM, after which BODY is run. BODY
is wrapped in a WITH-SLOTS-BOUND form, so all slots are conveniently available.
See <a href="#QTOOLS:DEFINE-INITIALIZER">QTOOLS:DEFINE-INITIALIZER</a></pre></div> </article> </li><li> <a name="QTOOLS:DEFINE-TRANSLATOR"> </a> <article id="MACRO QTOOLS:DEFINE-TRANSLATOR"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3ADEFINE-TRANSLATOR">DEFINE-TRANSLATOR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME (SOURCE TYPE &OPTIONAL (PRIORITY)) &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Define a translator function.
A translator takes a name and should translate it to the requested type of name if it can.
If it cannot, then it should simply return NIL, otherwise the translated name.
See <a href="NIL">TRANSLATOR</a></pre></div> </article> </li><li> <a name="QTOOLS:DEFINE-WIDGET"> </a> <article id="MACRO QTOOLS:DEFINE-WIDGET"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3ADEFINE-WIDGET">DEFINE-WIDGET</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME (QT-CLASS &REST DIRECT-SUPERCLASSES) DIRECT-SLOTS &REST OPTIONS</code><code>)</code> </header> <div class="docstring"><pre>Shorthand over DEFCLASS.
Adds WIDGET as direct-superclass if it does not appear as a
superclass to the specified direct-superclasses. Sets
WIDGET-CLASS as metaclass and qt-class as the qt-superclass
after resolving it through FIND-QT-CLASS-NAME.
All options are fused as per FUSE-ALISTS. You may therefore use
the same form multiple times.</pre></div> </article> </li><li> <a name="QTOOLS:DISCONNECT!"> </a> <article id="MACRO QTOOLS:DISCONNECT!"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3ADISCONNECT%21">DISCONNECT!</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ORIGIN ORIGIN-FUNCTION TARGET TARGET-FUNCTION</code><code>)</code> </header> <div class="docstring"><pre>Macro for a more lisp-y writing of DISCONNECT.
ORIGIN-FUNCTION and TARGET-FUNCTION should both be a list of the METHOD-NAME
followed by Qt argument types. The effective method name is computed as per
SPECIFIED-TYPE-METHOD-NAME.
ORIGIN and TARGET can both be either a single object or a list of objects
to connect with each other.</pre></div> </article> </li><li> <a name="QTOOLS:DO-LAYOUT"> </a> <article id="MACRO QTOOLS:DO-LAYOUT"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3ADO-LAYOUT">DO-LAYOUT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(WIDGET LAYOUT) &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Iterate over all WIDGETs on LAYOUT.</pre></div> </article> </li><li> <a name="QTOOLS:FAST-CALL"> </a> <article id="MACRO QTOOLS:FAST-CALL"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3AFAST-CALL">FAST-CALL</a></code></h4> <code class="qualifiers"></code> <code class="arguments">METHOD-DESCRIPTOR OBJECT &REST ARGS</code><code>)</code> </header> <div class="docstring"><pre>Performs a fast call on a given method.
This is useful if performance really matters and you have to minimise FFI
call overhead. In exchange it is required that you specify the exact method
signature you want to call and provide all arguments prepared in their proper
types as no marshalling will be done. FAST-CALL also will not read out the
return value.
METHOD-DESCRIPTOR ::= (name class-name arg-type*)
object --- The instance of the class to call a method on.
Must match the given class-name.
args --- The arguments to call the method with. Their types
must match the ones given in the arg-types and must
be prepared. Especially objects must be translated
to pointers manually. See QT::QOBJECT-POINTER.
name --- The Q+ name of the method being called.
class-name --- The Qt class name of the class the method belongs to.
At compile time a matching method number is searched for using
FIND-FASTCALL-METHOD. If no method can be found that matches the class,
name, and argument types, an error is signalled.
The fast call procedure creates a stack for the arguments by WITH-CALL-STACK.
It then uses FAST-DIRECT-CALL on the found method number, class, and
stack to perform the actual call to the method.
See <a href="#QTOOLS:FIND-FASTCALL-METHOD">FIND-FASTCALL-METHOD</a>
See <a href="#QTOOLS:FAST-DIRECT-CALL">FAST-DIRECT-CALL</a>
See <a href="#QTOOLS:WITH-CALL-STACK">WITH-CALL-STACK</a></pre></div> </article> </li><li> <a name="QTOOLS:FAST-DIRECT-CALL"> </a> <article id="MACRO QTOOLS:FAST-DIRECT-CALL"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3AFAST-DIRECT-CALL">FAST-DIRECT-CALL</a></code></h4> <code class="qualifiers"></code> <code class="arguments">METHOD OBJECT STACK</code><code>)</code> </header> <div class="docstring"><pre>Directly calls the given Qt class method on the given object using the
specified STACK as arguments to supply to the method.
Note that METHOD must be an existing Qt method number, OBJECT must be a
pointer to a class instance that is compatible with the method, and STACK
must be a pointer to an argument stack, preferably created through
WITH-CALL-STACK.
See <a href="#QTOOLS:WITH-CALL-STACK">WITH-CALL-STACK</a>
See <a href="#QTOOLS:FAST-CALL">FAST-CALL</a></pre></div> </article> </li><li> <a name="QTOOLS:FSETF"> </a> <article id="MACRO QTOOLS:FSETF"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3AFSETF">FSETF</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&REST PAIRS</code><code>)</code> </header> <div class="docstring"><pre>Finalizing SETF. The same as CL+QT:SETF, but performs a FINALIZE on the place first.
The finalize is performed before the place is set, but after the new value is evaluated.</pre></div> </article> </li><li> <a name="QTOOLS:Q+"> </a> <article id="MACRO QTOOLS:Q+"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3AQ%2B">Q+</a></code></h4> <code class="qualifiers"></code> <code class="arguments">FUNCTION &REST ARGS</code><code>)</code> </header> <div class="docstring"><pre>Emits a function call to the Q+ FUNCTION with ARGS.
This macro does a bit of a complicated thing:
Firstly, it calls ENSURE-Q+-METHOD on FUNCTION to
make sure that the function object exists at compile
time. Then it emits a PROGN form that contains two
forms, the first of which is a LOAD-TIME-VALUE form
with a call to ENSURE-Q+-METHOD again. This is required
since the function compiled by ENSURE-Q+-METHOD is not
dumped to file anywhere and thus must be recreated at
load time to be available. The second form in the PROGN
is the actual function call, using the proper symbol
from the *TARGET-PACKAGE*.
See <a href="#QTOOLS:ENSURE-Q+-METHOD">QTOOLS:ENSURE-Q+-METHOD</a></pre></div> </article> </li><li> <a name="QTOOLS:Q+FUN"> </a> <article id="MACRO QTOOLS:Q+FUN"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3AQ%2BFUN">Q+FUN</a></code></h4> <code class="qualifiers"></code> <code class="arguments">FUNCTION</code><code>)</code> </header> <div class="docstring"><pre>Emits a form that evaluates to the function object of FUNCTION.
Specifically, it returns a LOAD-TIME-VALUE form that evaluates to
the function object, while ensuring that the function does indeed
exist.
See <a href="#QTOOLS:ENSURE-Q+-METHOD">QTOOLS:ENSURE-Q+-METHOD</a></pre></div> </article> </li><li> <a name="QTOOLS:QCLASS=CASE"> </a> <article id="MACRO QTOOLS:QCLASS=CASE"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3AQCLASS%3DCASE">QCLASS=CASE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">INSTANCE &BODY CASES</code><code>)</code> </header> <div class="docstring"><pre>Similar to QTYPECASE, but only supports equality comparisons with classes, not subtype relations.
You should use this if you care about reasonably performant class type comparisons.</pre></div> </article> </li><li> <a name="QTOOLS:QTENUMCASE"> </a> <article id="MACRO QTOOLS:QTENUMCASE"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3AQTENUMCASE">QTENUMCASE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">KEYFORM &BODY FORMS</code><code>)</code> </header> <div class="docstring"><pre>Similar to CASE:
KEYFORM --- A form that evaluates to the key to compare against.
CASES ::= CASE*
CASE ::= (KEY form*)
KEY ::= (OR form*) | FORM | t | otherwise</pre></div> </article> </li><li> <a name="QTOOLS:QTYPECASE"> </a> <article id="MACRO QTOOLS:QTYPECASE"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3AQTYPECASE">QTYPECASE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">INSTANCE &BODY CASES</code><code>)</code> </header> <div class="docstring"><pre>Analogous to CL:TYPECASE, but for Qt classes.
See <a href="#QTOOLS:QINSTANCEP">QINSTANCEP</a></pre></div> </article> </li><li> <a name="QTOOLS:SIGNAL!"> </a> <article id="MACRO QTOOLS:SIGNAL!"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3ASIGNAL%21">SIGNAL!</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT FUNCTION &REST ARGS</code><code>)</code> </header> <div class="docstring"><pre>Macro for a more lisp-y writing of EMIT-SIGNAL.
Function should be a list of the METHOD-NAME followed by Qt argument types.
The effective method name is computed as per SPECIFIED-TYPE-METHOD-NAME.
OBJECT can be either a single object to signal to, or a list of objects.</pre></div> </article> </li><li> <a name="QTOOLS:WITH-ALL-SLOTS-BOUND"> </a> <article id="MACRO QTOOLS:WITH-ALL-SLOTS-BOUND"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3AWITH-ALL-SLOTS-BOUND">WITH-ALL-SLOTS-BOUND</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(INSTANCE CLASS) &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Turns into a WITH-SLOTS with all slots of CLASS.
Class is resolved as per ENSURE-CLASS.</pre></div> </article> </li><li> <a name="QTOOLS:WITH-CALL-STACK"> </a> <article id="MACRO QTOOLS:WITH-CALL-STACK"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3AWITH-CALL-STACK">WITH-CALL-STACK</a></code></h4> <code class="qualifiers"></code> <code class="arguments">STACK ARGS &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Binds a populated stack area to be used in a fast-call.
ARGS ::= ARG*
ARG ::= (value stack-item-type)
value --- The value to be used at the stack position.
stack-item-type --- It must be a symbol from the CommonQt StackItem union.
The stack is populated in the order of the arguments. The values must be
already of their proper types to be used for SETF CFFI:FOREIGN-SLOT-VALUE.
You may use TRANSLATE-NAME STACK-ITEM to translate a common type name to
the appropriate CommonQt StackItem union value.
See <a href="#QTOOLS:FAST-DIRECT-CALL">FAST-DIRECT-CALL</a>
See <a href="#QTOOLS:FAST-CALL">FAST-CALL</a></pre></div> </article> </li><li> <a name="QTOOLS:WITH-FINALIZING"> </a> <article id="MACRO QTOOLS:WITH-FINALIZING"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3AWITH-FINALIZING">WITH-FINALIZING</a></code></h4> <code class="qualifiers"></code> <code class="arguments">BINDINGS &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Executes the body as by LET and calls FINALIZE on all the objects introduced by
the bindings on completion of the body. If an error occurs during the binding phase,
all objects bound up until that point are still finalized. Finalizing happens in
reverse order of the bindings specified.</pre></div> </article> </li><li> <a name="QTOOLS:WITH-FINALIZING*"> </a> <article id="MACRO QTOOLS:WITH-FINALIZING*"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3AWITH-FINALIZING%2A">WITH-FINALIZING*</a></code></h4> <code class="qualifiers"></code> <code class="arguments">BINDINGS &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Executes the body as by LET* and calls FINALIZE on all the objects introduced by
the bindings on completion of the body. If an error occurs during the binding phase,
all objects bound up until that point are still finalized. Finalizing happens in
reverse order of the bindings specified.</pre></div> </article> </li><li> <a name="QTOOLS:WITH-GC-FINALIZED"> </a> <article id="MACRO QTOOLS:WITH-GC-FINALIZED"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3AWITH-GC-FINALIZED">WITH-GC-FINALIZED</a></code></h4> <code class="qualifiers"></code> <code class="arguments">BINDINGS &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Creates bindings as per LET with the special note that each value of a binding is wrapped
in a GC-FINALIZED. Each bound symbol is shadowed by a SYMBOL-MACROLET, which evaluates to
the bound value as per UNBOX.
In other words, this will look like a standard LET to you, but each value of the let is
automatically ensured to be GC-ed and FINALIZEd once the body exits.</pre></div> </article> </li><li> <a name="QTOOLS:WITH-MAIN-WINDOW"> </a> <article id="MACRO QTOOLS:WITH-MAIN-WINDOW"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3AWITH-MAIN-WINDOW">WITH-MAIN-WINDOW</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(WINDOW INSTANTIATOR &KEY NAME QAPPLICATION-ARGS (BLOCKING) (MAIN-THREAD)
(ON-ERROR) (SHOW) (FINALIZE) (BODY))
&BODY FORMS</code><code>)</code> </header> <div class="docstring"><pre>This is the main macro to start your application with.
It does the following:
1. Call ENSURE-QAPPLICATION with the provided NAME and QAPPLICATION-ARGS
2. Run the following in the main thread through TMT:WITH-BODY-IN-MAIN-THREAD
if MAIN-THREAD is non-NIL and make it non-blocking if BLOCKING is NIL.
3. Establish a handler for ERROR that calls the ON-ERROR function if hit.
4. Bind WINDOW to the result of INSTANTIATOR, passed through ENSURE-QOBJECT
(This means you can also just use the main window class' name)
5. Evaluate BODY
6. Call Q+:SHOW on WINDOW if SHOW is non-NIL
7. Call Q+:EXEC on *QAPPLICATION*
This will enter the Qt application's main loop that won't exit until your
application terminates.
8. Upon termination, call FINALIZE on WINDOW.</pre></div> </article> </li><li> <a name="QTOOLS:WITH-SLOTS-BOUND"> </a> <article id="MACRO QTOOLS:WITH-SLOTS-BOUND"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3AWITH-SLOTS-BOUND">WITH-SLOTS-BOUND</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(INSTANCE CLASS) &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Turns into a WITH-SLOTS with all direct-slots of CLASS.
Class is resolved as per ENSURE-CLASS.</pre></div> </article> </li><li> <a name="QTOOLS:WITH-WIDGET-CLASS"> </a> <article id="MACRO QTOOLS:WITH-WIDGET-CLASS"> <header class="macro"> <span class="type">macro</span> <code>(</code><h4 class="name"><code><a href="#MACRO%20QTOOLS%3AWITH-WIDGET-CLASS">WITH-WIDGET-CLASS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">(VARIABLE &OPTIONAL (METHOD)) &BODY BODY</code><code>)</code> </header> <div class="docstring"><pre>Binds VARIABLE to the current symbol name of the widget class as used as a specializer in the method arguments list.
This also signals errors if there is no such specializer or if it is invalid.</pre></div> </article> </li></ul> </li><li class="package"> <h3> <a name="CL+QT" href="#CL%2BQT">CL+QT</a> <span class="nicknames">(ORG.SHIRAKUMO.QTOOLS+COMMON-LISP)</span> </h3> <ul><li> <a name="CL+QT:ARRAY-DIMENSION-LIMIT"> </a> <article id="CONSTANT CL+QT:ARRAY-DIMENSION-LIMIT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3AARRAY-DIMENSION-LIMIT">ARRAY-DIMENSION-LIMIT</a></code></h4> </header> <div class="docstring"><pre>the exclusive upper bound on any given dimension of an array</pre></div> </article> </li><li> <a name="CL+QT:ARRAY-RANK-LIMIT"> </a> <article id="CONSTANT CL+QT:ARRAY-RANK-LIMIT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3AARRAY-RANK-LIMIT">ARRAY-RANK-LIMIT</a></code></h4> </header> <div class="docstring"><pre>the exclusive upper bound on the rank of an array</pre></div> </article> </li><li> <a name="CL+QT:ARRAY-TOTAL-SIZE-LIMIT"> </a> <article id="CONSTANT CL+QT:ARRAY-TOTAL-SIZE-LIMIT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3AARRAY-TOTAL-SIZE-LIMIT">ARRAY-TOTAL-SIZE-LIMIT</a></code></h4> </header> <div class="docstring"><pre>the exclusive upper bound on the total number of elements in an array</pre></div> </article> </li><li> <a name="CL+QT:BOOLE-1"> </a> <article id="CONSTANT CL+QT:BOOLE-1"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ABOOLE-1">BOOLE-1</a></code></h4> </header> <div class="docstring"><pre>Boole function op, makes BOOLE return integer1.</pre></div> </article> </li><li> <a name="CL+QT:BOOLE-2"> </a> <article id="CONSTANT CL+QT:BOOLE-2"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ABOOLE-2">BOOLE-2</a></code></h4> </header> <div class="docstring"><pre>Boole function op, makes BOOLE return integer2.</pre></div> </article> </li><li> <a name="CL+QT:BOOLE-AND"> </a> <article id="CONSTANT CL+QT:BOOLE-AND"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ABOOLE-AND">BOOLE-AND</a></code></h4> </header> <div class="docstring"><pre>Boole function op, makes BOOLE return logand of integer1 and integer2.</pre></div> </article> </li><li> <a name="CL+QT:BOOLE-ANDC1"> </a> <article id="CONSTANT CL+QT:BOOLE-ANDC1"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ABOOLE-ANDC1">BOOLE-ANDC1</a></code></h4> </header> <div class="docstring"><pre>Boole function op, makes BOOLE return logandc1 of integer1 and integer2.</pre></div> </article> </li><li> <a name="CL+QT:BOOLE-ANDC2"> </a> <article id="CONSTANT CL+QT:BOOLE-ANDC2"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ABOOLE-ANDC2">BOOLE-ANDC2</a></code></h4> </header> <div class="docstring"><pre>Boole function op, makes BOOLE return logandc2 of integer1 and integer2.</pre></div> </article> </li><li> <a name="CL+QT:BOOLE-C1"> </a> <article id="CONSTANT CL+QT:BOOLE-C1"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ABOOLE-C1">BOOLE-C1</a></code></h4> </header> <div class="docstring"><pre>Boole function op, makes BOOLE return complement of integer1.</pre></div> </article> </li><li> <a name="CL+QT:BOOLE-C2"> </a> <article id="CONSTANT CL+QT:BOOLE-C2"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ABOOLE-C2">BOOLE-C2</a></code></h4> </header> <div class="docstring"><pre>Boole function op, makes BOOLE return complement of integer2.</pre></div> </article> </li><li> <a name="CL+QT:BOOLE-CLR"> </a> <article id="CONSTANT CL+QT:BOOLE-CLR"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ABOOLE-CLR">BOOLE-CLR</a></code></h4> </header> <div class="docstring"><pre>Boole function op, makes BOOLE return 0.</pre></div> </article> </li><li> <a name="CL+QT:BOOLE-EQV"> </a> <article id="CONSTANT CL+QT:BOOLE-EQV"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ABOOLE-EQV">BOOLE-EQV</a></code></h4> </header> <div class="docstring"><pre>Boole function op, makes BOOLE return logeqv of integer1 and integer2.</pre></div> </article> </li><li> <a name="CL+QT:BOOLE-IOR"> </a> <article id="CONSTANT CL+QT:BOOLE-IOR"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ABOOLE-IOR">BOOLE-IOR</a></code></h4> </header> <div class="docstring"><pre>Boole function op, makes BOOLE return logior of integer1 and integer2.</pre></div> </article> </li><li> <a name="CL+QT:BOOLE-NAND"> </a> <article id="CONSTANT CL+QT:BOOLE-NAND"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ABOOLE-NAND">BOOLE-NAND</a></code></h4> </header> <div class="docstring"><pre>Boole function op, makes BOOLE return log nand of integer1 and integer2.</pre></div> </article> </li><li> <a name="CL+QT:BOOLE-NOR"> </a> <article id="CONSTANT CL+QT:BOOLE-NOR"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ABOOLE-NOR">BOOLE-NOR</a></code></h4> </header> <div class="docstring"><pre>Boole function op, makes BOOLE return lognor of integer1 and integer2.</pre></div> </article> </li><li> <a name="CL+QT:BOOLE-ORC1"> </a> <article id="CONSTANT CL+QT:BOOLE-ORC1"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ABOOLE-ORC1">BOOLE-ORC1</a></code></h4> </header> <div class="docstring"><pre>Boole function op, makes BOOLE return logorc1 of integer1 and integer2.</pre></div> </article> </li><li> <a name="CL+QT:BOOLE-ORC2"> </a> <article id="CONSTANT CL+QT:BOOLE-ORC2"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ABOOLE-ORC2">BOOLE-ORC2</a></code></h4> </header> <div class="docstring"><pre>Boole function op, makes BOOLE return logorc2 of integer1 and integer2.</pre></div> </article> </li><li> <a name="CL+QT:BOOLE-SET"> </a> <article id="CONSTANT CL+QT:BOOLE-SET"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ABOOLE-SET">BOOLE-SET</a></code></h4> </header> <div class="docstring"><pre>Boole function op, makes BOOLE return -1.</pre></div> </article> </li><li> <a name="CL+QT:BOOLE-XOR"> </a> <article id="CONSTANT CL+QT:BOOLE-XOR"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ABOOLE-XOR">BOOLE-XOR</a></code></h4> </header> <div class="docstring"><pre>Boole function op, makes BOOLE return logxor of integer1 and integer2.</pre></div> </article> </li><li> <a name="CL+QT:CALL-ARGUMENTS-LIMIT"> </a> <article id="CONSTANT CL+QT:CALL-ARGUMENTS-LIMIT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ACALL-ARGUMENTS-LIMIT">CALL-ARGUMENTS-LIMIT</a></code></h4> </header> <div class="docstring"><pre>The exclusive upper bound on the number of arguments which may be passed
to a function, including &REST args.</pre></div> </article> </li><li> <a name="CL+QT:CHAR-CODE-LIMIT"> </a> <article id="CONSTANT CL+QT:CHAR-CODE-LIMIT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ACHAR-CODE-LIMIT">CHAR-CODE-LIMIT</a></code></h4> </header> <div class="docstring"><pre>the upper exclusive bound on values produced by CHAR-CODE</pre></div> </article> </li><li> <a name="CL+QT:DOUBLE-FLOAT-EPSILON"> </a> <article id="CONSTANT CL+QT:DOUBLE-FLOAT-EPSILON"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ADOUBLE-FLOAT-EPSILON">DOUBLE-FLOAT-EPSILON</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:DOUBLE-FLOAT-NEGATIVE-EPSILON"> </a> <article id="CONSTANT CL+QT:DOUBLE-FLOAT-NEGATIVE-EPSILON"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ADOUBLE-FLOAT-NEGATIVE-EPSILON">DOUBLE-FLOAT-NEGATIVE-EPSILON</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:INTERNAL-TIME-UNITS-PER-SECOND"> </a> <article id="CONSTANT CL+QT:INTERNAL-TIME-UNITS-PER-SECOND"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3AINTERNAL-TIME-UNITS-PER-SECOND">INTERNAL-TIME-UNITS-PER-SECOND</a></code></h4> </header> <div class="docstring"><pre>The number of internal time units that fit into a second. See
GET-INTERNAL-REAL-TIME and GET-INTERNAL-RUN-TIME.</pre></div> </article> </li><li> <a name="CL+QT:LAMBDA-LIST-KEYWORDS"> </a> <article id="CONSTANT CL+QT:LAMBDA-LIST-KEYWORDS"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ALAMBDA-LIST-KEYWORDS">LAMBDA-LIST-KEYWORDS</a></code></h4> </header> <div class="docstring"><pre>A list of symbols used as lambda list keywords in SBCL.</pre></div> </article> </li><li> <a name="CL+QT:LAMBDA-PARAMETERS-LIMIT"> </a> <article id="CONSTANT CL+QT:LAMBDA-PARAMETERS-LIMIT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ALAMBDA-PARAMETERS-LIMIT">LAMBDA-PARAMETERS-LIMIT</a></code></h4> </header> <div class="docstring"><pre>The exclusive upper bound on the number of parameters which may be specified
in a given lambda list. This is actually the limit on required and &OPTIONAL
parameters. With &KEY and &AUX you can get more.</pre></div> </article> </li><li> <a name="CL+QT:LEAST-NEGATIVE-DOUBLE-FLOAT"> </a> <article id="CONSTANT CL+QT:LEAST-NEGATIVE-DOUBLE-FLOAT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ALEAST-NEGATIVE-DOUBLE-FLOAT">LEAST-NEGATIVE-DOUBLE-FLOAT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:LEAST-NEGATIVE-LONG-FLOAT"> </a> <article id="CONSTANT CL+QT:LEAST-NEGATIVE-LONG-FLOAT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ALEAST-NEGATIVE-LONG-FLOAT">LEAST-NEGATIVE-LONG-FLOAT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT"> </a> <article id="CONSTANT CL+QT:LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ALEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT">LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT"> </a> <article id="CONSTANT CL+QT:LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ALEAST-NEGATIVE-NORMALIZED-LONG-FLOAT">LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT"> </a> <article id="CONSTANT CL+QT:LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ALEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT">LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT"> </a> <article id="CONSTANT CL+QT:LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ALEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT">LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:LEAST-NEGATIVE-SHORT-FLOAT"> </a> <article id="CONSTANT CL+QT:LEAST-NEGATIVE-SHORT-FLOAT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ALEAST-NEGATIVE-SHORT-FLOAT">LEAST-NEGATIVE-SHORT-FLOAT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:LEAST-NEGATIVE-SINGLE-FLOAT"> </a> <article id="CONSTANT CL+QT:LEAST-NEGATIVE-SINGLE-FLOAT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ALEAST-NEGATIVE-SINGLE-FLOAT">LEAST-NEGATIVE-SINGLE-FLOAT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:LEAST-POSITIVE-DOUBLE-FLOAT"> </a> <article id="CONSTANT CL+QT:LEAST-POSITIVE-DOUBLE-FLOAT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ALEAST-POSITIVE-DOUBLE-FLOAT">LEAST-POSITIVE-DOUBLE-FLOAT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:LEAST-POSITIVE-LONG-FLOAT"> </a> <article id="CONSTANT CL+QT:LEAST-POSITIVE-LONG-FLOAT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ALEAST-POSITIVE-LONG-FLOAT">LEAST-POSITIVE-LONG-FLOAT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT"> </a> <article id="CONSTANT CL+QT:LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ALEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT">LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:LEAST-POSITIVE-NORMALIZED-LONG-FLOAT"> </a> <article id="CONSTANT CL+QT:LEAST-POSITIVE-NORMALIZED-LONG-FLOAT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ALEAST-POSITIVE-NORMALIZED-LONG-FLOAT">LEAST-POSITIVE-NORMALIZED-LONG-FLOAT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT"> </a> <article id="CONSTANT CL+QT:LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ALEAST-POSITIVE-NORMALIZED-SHORT-FLOAT">LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT"> </a> <article id="CONSTANT CL+QT:LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ALEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT">LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:LEAST-POSITIVE-SHORT-FLOAT"> </a> <article id="CONSTANT CL+QT:LEAST-POSITIVE-SHORT-FLOAT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ALEAST-POSITIVE-SHORT-FLOAT">LEAST-POSITIVE-SHORT-FLOAT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:LEAST-POSITIVE-SINGLE-FLOAT"> </a> <article id="CONSTANT CL+QT:LEAST-POSITIVE-SINGLE-FLOAT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ALEAST-POSITIVE-SINGLE-FLOAT">LEAST-POSITIVE-SINGLE-FLOAT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:LONG-FLOAT-EPSILON"> </a> <article id="CONSTANT CL+QT:LONG-FLOAT-EPSILON"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ALONG-FLOAT-EPSILON">LONG-FLOAT-EPSILON</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:LONG-FLOAT-NEGATIVE-EPSILON"> </a> <article id="CONSTANT CL+QT:LONG-FLOAT-NEGATIVE-EPSILON"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ALONG-FLOAT-NEGATIVE-EPSILON">LONG-FLOAT-NEGATIVE-EPSILON</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:MOST-NEGATIVE-DOUBLE-FLOAT"> </a> <article id="CONSTANT CL+QT:MOST-NEGATIVE-DOUBLE-FLOAT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3AMOST-NEGATIVE-DOUBLE-FLOAT">MOST-NEGATIVE-DOUBLE-FLOAT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:MOST-NEGATIVE-FIXNUM"> </a> <article id="CONSTANT CL+QT:MOST-NEGATIVE-FIXNUM"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3AMOST-NEGATIVE-FIXNUM">MOST-NEGATIVE-FIXNUM</a></code></h4> </header> <div class="docstring"><pre>the fixnum closest in value to negative infinity</pre></div> </article> </li><li> <a name="CL+QT:MOST-NEGATIVE-LONG-FLOAT"> </a> <article id="CONSTANT CL+QT:MOST-NEGATIVE-LONG-FLOAT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3AMOST-NEGATIVE-LONG-FLOAT">MOST-NEGATIVE-LONG-FLOAT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:MOST-NEGATIVE-SHORT-FLOAT"> </a> <article id="CONSTANT CL+QT:MOST-NEGATIVE-SHORT-FLOAT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3AMOST-NEGATIVE-SHORT-FLOAT">MOST-NEGATIVE-SHORT-FLOAT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:MOST-NEGATIVE-SINGLE-FLOAT"> </a> <article id="CONSTANT CL+QT:MOST-NEGATIVE-SINGLE-FLOAT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3AMOST-NEGATIVE-SINGLE-FLOAT">MOST-NEGATIVE-SINGLE-FLOAT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:MOST-POSITIVE-DOUBLE-FLOAT"> </a> <article id="CONSTANT CL+QT:MOST-POSITIVE-DOUBLE-FLOAT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3AMOST-POSITIVE-DOUBLE-FLOAT">MOST-POSITIVE-DOUBLE-FLOAT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:MOST-POSITIVE-FIXNUM"> </a> <article id="CONSTANT CL+QT:MOST-POSITIVE-FIXNUM"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3AMOST-POSITIVE-FIXNUM">MOST-POSITIVE-FIXNUM</a></code></h4> </header> <div class="docstring"><pre>the fixnum closest in value to positive infinity</pre></div> </article> </li><li> <a name="CL+QT:MOST-POSITIVE-LONG-FLOAT"> </a> <article id="CONSTANT CL+QT:MOST-POSITIVE-LONG-FLOAT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3AMOST-POSITIVE-LONG-FLOAT">MOST-POSITIVE-LONG-FLOAT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:MOST-POSITIVE-SHORT-FLOAT"> </a> <article id="CONSTANT CL+QT:MOST-POSITIVE-SHORT-FLOAT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3AMOST-POSITIVE-SHORT-FLOAT">MOST-POSITIVE-SHORT-FLOAT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:MOST-POSITIVE-SINGLE-FLOAT"> </a> <article id="CONSTANT CL+QT:MOST-POSITIVE-SINGLE-FLOAT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3AMOST-POSITIVE-SINGLE-FLOAT">MOST-POSITIVE-SINGLE-FLOAT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:MULTIPLE-VALUES-LIMIT"> </a> <article id="CONSTANT CL+QT:MULTIPLE-VALUES-LIMIT"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3AMULTIPLE-VALUES-LIMIT">MULTIPLE-VALUES-LIMIT</a></code></h4> </header> <div class="docstring"><pre>The exclusive upper bound on the number of multiple VALUES that you can
return.</pre></div> </article> </li><li> <a name="CL+QT:NIL"> </a> <article id="CONSTANT CL+QT:NIL"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ANIL">NIL</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:PI"> </a> <article id="CONSTANT CL+QT:PI"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3API">PI</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:SHORT-FLOAT-EPSILON"> </a> <article id="CONSTANT CL+QT:SHORT-FLOAT-EPSILON"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ASHORT-FLOAT-EPSILON">SHORT-FLOAT-EPSILON</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:SHORT-FLOAT-NEGATIVE-EPSILON"> </a> <article id="CONSTANT CL+QT:SHORT-FLOAT-NEGATIVE-EPSILON"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ASHORT-FLOAT-NEGATIVE-EPSILON">SHORT-FLOAT-NEGATIVE-EPSILON</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:SINGLE-FLOAT-EPSILON"> </a> <article id="CONSTANT CL+QT:SINGLE-FLOAT-EPSILON"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ASINGLE-FLOAT-EPSILON">SINGLE-FLOAT-EPSILON</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:SINGLE-FLOAT-NEGATIVE-EPSILON"> </a> <article id="CONSTANT CL+QT:SINGLE-FLOAT-NEGATIVE-EPSILON"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3ASINGLE-FLOAT-NEGATIVE-EPSILON">SINGLE-FLOAT-NEGATIVE-EPSILON</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:T"> </a> <article id="CONSTANT CL+QT:T"> <header class="constant"> <span class="type">constant</span> <h4 class="name"><code><a href="#CONSTANT%20CL%2BQT%3AT">T</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:*"> </a> <article id="SPECIAL CL+QT:*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2A">*</a></code></h4> </header> <div class="docstring"><pre>the value of the most recent top level EVAL</pre></div> </article> </li><li> <a name="CL+QT:**"> </a> <article id="SPECIAL CL+QT:**"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2A%2A">**</a></code></h4> </header> <div class="docstring"><pre>the previous value of *</pre></div> </article> </li><li> <a name="CL+QT:***"> </a> <article id="SPECIAL CL+QT:***"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2A%2A%2A">***</a></code></h4> </header> <div class="docstring"><pre>the previous value of **</pre></div> </article> </li><li> <a name="CL+QT:*BOOT-HOOKS*"> </a> <article id="SPECIAL CL+QT:*BOOT-HOOKS*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2ABOOT-HOOKS%2A">*BOOT-HOOKS*</a></code></h4> </header> <div class="docstring"><pre>A list of functions to invoke (in sequence) during the warm-boot.
Use this to run customised startup, prepare, or load functions.</pre></div> </article> </li><li> <a name="CL+QT:*BREAK-ON-SIGNALS*"> </a> <article id="SPECIAL CL+QT:*BREAK-ON-SIGNALS*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2ABREAK-ON-SIGNALS%2A">*BREAK-ON-SIGNALS*</a></code></h4> </header> <div class="docstring"><pre>When (TYPEP condition *BREAK-ON-SIGNALS*) is true, then calls to SIGNAL will
enter the debugger prior to signalling that condition.</pre></div> </article> </li><li> <a name="CL+QT:*BUILD-HOOKS*"> </a> <article id="SPECIAL CL+QT:*BUILD-HOOKS*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2ABUILD-HOOKS%2A">*BUILD-HOOKS*</a></code></h4> </header> <div class="docstring"><pre>A list of functions to invoke (in sequence) during the build.
Use this to run customised cleanup, compile, or deployment functions.</pre></div> </article> </li><li> <a name="CL+QT:*COMPILE-FILE-PATHNAME*"> </a> <article id="SPECIAL CL+QT:*COMPILE-FILE-PATHNAME*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2ACOMPILE-FILE-PATHNAME%2A">*COMPILE-FILE-PATHNAME*</a></code></h4> </header> <div class="docstring"><pre>The defaulted pathname of the file currently being compiled, or NIL if not
compiling.</pre></div> </article> </li><li> <a name="CL+QT:*COMPILE-FILE-TRUENAME*"> </a> <article id="SPECIAL CL+QT:*COMPILE-FILE-TRUENAME*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2ACOMPILE-FILE-TRUENAME%2A">*COMPILE-FILE-TRUENAME*</a></code></h4> </header> <div class="docstring"><pre>The TRUENAME of the file currently being compiled, or NIL if not
compiling.</pre></div> </article> </li><li> <a name="CL+QT:*COMPILE-PRINT*"> </a> <article id="SPECIAL CL+QT:*COMPILE-PRINT*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2ACOMPILE-PRINT%2A">*COMPILE-PRINT*</a></code></h4> </header> <div class="docstring"><pre>The default for the :PRINT argument to COMPILE-FILE.</pre></div> </article> </li><li> <a name="CL+QT:*COMPILE-VERBOSE*"> </a> <article id="SPECIAL CL+QT:*COMPILE-VERBOSE*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2ACOMPILE-VERBOSE%2A">*COMPILE-VERBOSE*</a></code></h4> </header> <div class="docstring"><pre>The default for the :VERBOSE argument to COMPILE-FILE.</pre></div> </article> </li><li> <a name="CL+QT:*DEBUG-IO*"> </a> <article id="SPECIAL CL+QT:*DEBUG-IO*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2ADEBUG-IO%2A">*DEBUG-IO*</a></code></h4> </header> <div class="docstring"><pre>interactive debugging stream</pre></div> </article> </li><li> <a name="CL+QT:*DEBUGGER-HOOK*"> </a> <article id="SPECIAL CL+QT:*DEBUGGER-HOOK*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2ADEBUGGER-HOOK%2A">*DEBUGGER-HOOK*</a></code></h4> </header> <div class="docstring"><pre>This is either NIL or a function of two arguments, a condition and the value
of *DEBUGGER-HOOK*. This function can either handle the condition or return
which causes the standard debugger to execute. The system passes the value
of this variable to the function because it binds *DEBUGGER-HOOK* to NIL
around the invocation.</pre></div> </article> </li><li> <a name="CL+QT:*DEFAULT-PATHNAME-DEFAULTS*"> </a> <article id="SPECIAL CL+QT:*DEFAULT-PATHNAME-DEFAULTS*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2ADEFAULT-PATHNAME-DEFAULTS%2A">*DEFAULT-PATHNAME-DEFAULTS*</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:*DEPLOYMENT-LOCATION*"> </a> <article id="SPECIAL CL+QT:*DEPLOYMENT-LOCATION*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2ADEPLOYMENT-LOCATION%2A">*DEPLOYMENT-LOCATION*</a></code></h4> </header> <div class="docstring"><pre>Variable containing the path to the directory that is being deployed to.
This is bound when *BOOT-HOOKS* functions are called.</pre></div> </article> </li><li> <a name="CL+QT:*ERROR-OUTPUT*"> </a> <article id="SPECIAL CL+QT:*ERROR-OUTPUT*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2AERROR-OUTPUT%2A">*ERROR-OUTPUT*</a></code></h4> </header> <div class="docstring"><pre>error output stream</pre></div> </article> </li><li> <a name="CL+QT:*FEATURES*"> </a> <article id="SPECIAL CL+QT:*FEATURES*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2AFEATURES%2A">*FEATURES*</a></code></h4> </header> <div class="docstring"><pre>a list of symbols that describe features provided by the
implementation</pre></div> </article> </li><li> <a name="CL+QT:*GENERATED-MODULES*"> </a> <article id="SPECIAL CL+QT:*GENERATED-MODULES*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2AGENERATED-MODULES%2A">*GENERATED-MODULES*</a></code></h4> </header> <div class="docstring"><pre>A list of loaded smoke modules when PROCESS-ALL-METHODS is called.
This is useful to keep track over environments which modules are
actually available for compilation.</pre></div> </article> </li><li> <a name="CL+QT:*GENSYM-COUNTER*"> </a> <article id="SPECIAL CL+QT:*GENSYM-COUNTER*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2AGENSYM-COUNTER%2A">*GENSYM-COUNTER*</a></code></h4> </header> <div class="docstring"><pre>counter for generating unique GENSYM symbols</pre></div> </article> </li><li> <a name="CL+QT:*LOAD-LIBRARY-FUNCTION*"> </a> <article id="SPECIAL CL+QT:*LOAD-LIBRARY-FUNCTION*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2ALOAD-LIBRARY-FUNCTION%2A">*LOAD-LIBRARY-FUNCTION*</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:*LOAD-PATHNAME*"> </a> <article id="SPECIAL CL+QT:*LOAD-PATHNAME*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2ALOAD-PATHNAME%2A">*LOAD-PATHNAME*</a></code></h4> </header> <div class="docstring"><pre>the defaulted pathname that LOAD is currently loading</pre></div> </article> </li><li> <a name="CL+QT:*LOAD-PRINT*"> </a> <article id="SPECIAL CL+QT:*LOAD-PRINT*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2ALOAD-PRINT%2A">*LOAD-PRINT*</a></code></h4> </header> <div class="docstring"><pre>the default for the :PRINT argument to LOAD</pre></div> </article> </li><li> <a name="CL+QT:*LOAD-TRUENAME*"> </a> <article id="SPECIAL CL+QT:*LOAD-TRUENAME*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2ALOAD-TRUENAME%2A">*LOAD-TRUENAME*</a></code></h4> </header> <div class="docstring"><pre>the TRUENAME of the file that LOAD is currently loading</pre></div> </article> </li><li> <a name="CL+QT:*LOAD-VERBOSE*"> </a> <article id="SPECIAL CL+QT:*LOAD-VERBOSE*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2ALOAD-VERBOSE%2A">*LOAD-VERBOSE*</a></code></h4> </header> <div class="docstring"><pre>the default for the :VERBOSE argument to LOAD</pre></div> </article> </li><li> <a name="CL+QT:*MACROEXPAND-HOOK*"> </a> <article id="SPECIAL CL+QT:*MACROEXPAND-HOOK*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2AMACROEXPAND-HOOK%2A">*MACROEXPAND-HOOK*</a></code></h4> </header> <div class="docstring"><pre>The value of this variable must be a designator for a function that can
take three arguments, a macro expander function, the macro form to be
expanded, and the lexical environment to expand in. The function should
return the expanded form. This function is called by MACROEXPAND-1
whenever a runtime expansion is needed. Initially this is set to
FUNCALL.</pre></div> </article> </li><li> <a name="CL+QT:*METHOD*"> </a> <article id="SPECIAL CL+QT:*METHOD*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2AMETHOD%2A">*METHOD*</a></code></h4> </header> <div class="docstring"><pre>Contains the whole DEFMETHOD form that is currently being processed.
If you modify the contents of this variable, the changes will be reflected
in the outputted method definition form. However, no declaration that is
processed by method-declarations will ever appear in the output.</pre></div> </article> </li><li> <a name="CL+QT:*MODULES*"> </a> <article id="SPECIAL CL+QT:*MODULES*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2AMODULES%2A">*MODULES*</a></code></h4> </header> <div class="docstring"><pre>This is a list of module names that have been loaded into Lisp so far.
It is used by PROVIDE and REQUIRE.</pre></div> </article> </li><li> <a name="CL+QT:*OPERATOR-MAP*"> </a> <article id="SPECIAL CL+QT:*OPERATOR-MAP*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2AOPERATOR-MAP%2A">*OPERATOR-MAP*</a></code></h4> </header> <div class="docstring"><pre>A hash-table of C++ operators to CL function names.</pre></div> </article> </li><li> <a name="CL+QT:*PACKAGE*"> </a> <article id="SPECIAL CL+QT:*PACKAGE*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2APACKAGE%2A">*PACKAGE*</a></code></h4> </header> <div class="docstring"><pre>the current package</pre></div> </article> </li><li> <a name="CL+QT:*PRINT-ARRAY*"> </a> <article id="SPECIAL CL+QT:*PRINT-ARRAY*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2APRINT-ARRAY%2A">*PRINT-ARRAY*</a></code></h4> </header> <div class="docstring"><pre>Should the contents of arrays be printed?</pre></div> </article> </li><li> <a name="CL+QT:*PRINT-BASE*"> </a> <article id="SPECIAL CL+QT:*PRINT-BASE*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2APRINT-BASE%2A">*PRINT-BASE*</a></code></h4> </header> <div class="docstring"><pre>The output base for RATIONALs (including integers).</pre></div> </article> </li><li> <a name="CL+QT:*PRINT-CASE*"> </a> <article id="SPECIAL CL+QT:*PRINT-CASE*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2APRINT-CASE%2A">*PRINT-CASE*</a></code></h4> </header> <div class="docstring"><pre>What case should the printer should use default?</pre></div> </article> </li><li> <a name="CL+QT:*PRINT-CIRCLE*"> </a> <article id="SPECIAL CL+QT:*PRINT-CIRCLE*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2APRINT-CIRCLE%2A">*PRINT-CIRCLE*</a></code></h4> </header> <div class="docstring"><pre>Should we use #n= and #n# notation to preserve uniqueness in general (and
circularity in particular) when printing?</pre></div> </article> </li><li> <a name="CL+QT:*PRINT-ESCAPE*"> </a> <article id="SPECIAL CL+QT:*PRINT-ESCAPE*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2APRINT-ESCAPE%2A">*PRINT-ESCAPE*</a></code></h4> </header> <div class="docstring"><pre>Should we print in a reasonably machine-readable way? (possibly
overridden by *PRINT-READABLY*)</pre></div> </article> </li><li> <a name="CL+QT:*PRINT-GENSYM*"> </a> <article id="SPECIAL CL+QT:*PRINT-GENSYM*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2APRINT-GENSYM%2A">*PRINT-GENSYM*</a></code></h4> </header> <div class="docstring"><pre>Should #: prefixes be used when printing symbols with null SYMBOL-PACKAGE?</pre></div> </article> </li><li> <a name="CL+QT:*PRINT-LENGTH*"> </a> <article id="SPECIAL CL+QT:*PRINT-LENGTH*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2APRINT-LENGTH%2A">*PRINT-LENGTH*</a></code></h4> </header> <div class="docstring"><pre>How many elements at any level should be printed before abbreviating
with "..."?</pre></div> </article> </li><li> <a name="CL+QT:*PRINT-LEVEL*"> </a> <article id="SPECIAL CL+QT:*PRINT-LEVEL*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2APRINT-LEVEL%2A">*PRINT-LEVEL*</a></code></h4> </header> <div class="docstring"><pre>How many levels should be printed before abbreviating with "#"?</pre></div> </article> </li><li> <a name="CL+QT:*PRINT-LINES*"> </a> <article id="SPECIAL CL+QT:*PRINT-LINES*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2APRINT-LINES%2A">*PRINT-LINES*</a></code></h4> </header> <div class="docstring"><pre>The maximum number of lines to print per object.</pre></div> </article> </li><li> <a name="CL+QT:*PRINT-MISER-WIDTH*"> </a> <article id="SPECIAL CL+QT:*PRINT-MISER-WIDTH*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2APRINT-MISER-WIDTH%2A">*PRINT-MISER-WIDTH*</a></code></h4> </header> <div class="docstring"><pre>If the remaining space between the current column and the right margin
is less than this, then print using ``miser-style'' output. Miser
style conditional newlines are turned on, and all indentations are
turned off. If NIL, never use miser mode.</pre></div> </article> </li><li> <a name="CL+QT:*PRINT-PPRINT-DISPATCH*"> </a> <article id="SPECIAL CL+QT:*PRINT-PPRINT-DISPATCH*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2APRINT-PPRINT-DISPATCH%2A">*PRINT-PPRINT-DISPATCH*</a></code></h4> </header> <div class="docstring"><pre>The pprint-dispatch-table that controls how to pretty-print objects.</pre></div> </article> </li><li> <a name="CL+QT:*PRINT-PRETTY*"> </a> <article id="SPECIAL CL+QT:*PRINT-PRETTY*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2APRINT-PRETTY%2A">*PRINT-PRETTY*</a></code></h4> </header> <div class="docstring"><pre>Should pretty printing be used?</pre></div> </article> </li><li> <a name="CL+QT:*PRINT-RADIX*"> </a> <article id="SPECIAL CL+QT:*PRINT-RADIX*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2APRINT-RADIX%2A">*PRINT-RADIX*</a></code></h4> </header> <div class="docstring"><pre>Should base be verified when printing RATIONALs?</pre></div> </article> </li><li> <a name="CL+QT:*PRINT-READABLY*"> </a> <article id="SPECIAL CL+QT:*PRINT-READABLY*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2APRINT-READABLY%2A">*PRINT-READABLY*</a></code></h4> </header> <div class="docstring"><pre>If true, all objects will be printed readably. If readable printing
is impossible, an error will be signalled. This overrides the value of
*PRINT-ESCAPE*.</pre></div> </article> </li><li> <a name="CL+QT:*PRINT-RIGHT-MARGIN*"> </a> <article id="SPECIAL CL+QT:*PRINT-RIGHT-MARGIN*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2APRINT-RIGHT-MARGIN%2A">*PRINT-RIGHT-MARGIN*</a></code></h4> </header> <div class="docstring"><pre>The position of the right margin in ems (for pretty-printing).</pre></div> </article> </li><li> <a name="CL+QT:*QAPPLICATION*"> </a> <article id="SPECIAL CL+QT:*QAPPLICATION*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2AQAPPLICATION%2A">*QAPPLICATION*</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:*QAPPLICATION-CREATE-HOOKS*"> </a> <article id="SPECIAL CL+QT:*QAPPLICATION-CREATE-HOOKS*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2AQAPPLICATION-CREATE-HOOKS%2A">*QAPPLICATION-CREATE-HOOKS*</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:*QMETHODS*"> </a> <article id="SPECIAL CL+QT:*QMETHODS*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2AQMETHODS%2A">*QMETHODS*</a></code></h4> </header> <div class="docstring"><pre>Table mapping a *TARGET-PACKAGE* symbol to a list of
associated Qt methods. This table should only be changed
by PROCESS-METHOD. If you modify yourself without knowing
exactly what you're doing you'll most likely run into problems.
Methods/functions contained in this table are available
for compilation.
See <a href="#QTOOLS:PROCESS-METHOD">QTOOLS:PROCESS-METHOD</a>
See <a href="#QTOOLS:COMPILE-WRAPPER">QTOOLS:COMPILE-WRAPPER</a></pre></div> </article> </li><li> <a name="CL+QT:*QT-CLASS-MAP*"> </a> <article id="SPECIAL CL+QT:*QT-CLASS-MAP*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2AQT-CLASS-MAP%2A">*QT-CLASS-MAP*</a></code></h4> </header> <div class="docstring"><pre>An EQUALP hash-table of all Qt4.8 class names to themselves as strings.</pre></div> </article> </li><li> <a name="CL+QT:*QT-CLASS-VECTOR*"> </a> <article id="SPECIAL CL+QT:*QT-CLASS-VECTOR*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2AQT-CLASS-VECTOR%2A">*QT-CLASS-VECTOR*</a></code></h4> </header> <div class="docstring"><pre>A vector of all Qt4.8 class names as strings.</pre></div> </article> </li><li> <a name="CL+QT:*QUERY-IO*"> </a> <article id="SPECIAL CL+QT:*QUERY-IO*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2AQUERY-IO%2A">*QUERY-IO*</a></code></h4> </header> <div class="docstring"><pre>query I/O stream</pre></div> </article> </li><li> <a name="CL+QT:*QUIT-HOOKS*"> </a> <article id="SPECIAL CL+QT:*QUIT-HOOKS*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2AQUIT-HOOKS%2A">*QUIT-HOOKS*</a></code></h4> </header> <div class="docstring"><pre>A list of functions to invoke (in sequence) when the program quits.
Use this to run customised saving or cleanup functions.</pre></div> </article> </li><li> <a name="CL+QT:*RANDOM-STATE*"> </a> <article id="SPECIAL CL+QT:*RANDOM-STATE*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2ARANDOM-STATE%2A">*RANDOM-STATE*</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:*READ-BASE*"> </a> <article id="SPECIAL CL+QT:*READ-BASE*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2AREAD-BASE%2A">*READ-BASE*</a></code></h4> </header> <div class="docstring"><pre>the radix that Lisp reads numbers in</pre></div> </article> </li><li> <a name="CL+QT:*READ-DEFAULT-FLOAT-FORMAT*"> </a> <article id="SPECIAL CL+QT:*READ-DEFAULT-FLOAT-FORMAT*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2AREAD-DEFAULT-FLOAT-FORMAT%2A">*READ-DEFAULT-FLOAT-FORMAT*</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:*READ-EVAL*"> </a> <article id="SPECIAL CL+QT:*READ-EVAL*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2AREAD-EVAL%2A">*READ-EVAL*</a></code></h4> </header> <div class="docstring"><pre>If false, then the #. read macro is disabled.</pre></div> </article> </li><li> <a name="CL+QT:*READ-SUPPRESS*"> </a> <article id="SPECIAL CL+QT:*READ-SUPPRESS*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2AREAD-SUPPRESS%2A">*READ-SUPPRESS*</a></code></h4> </header> <div class="docstring"><pre>Suppress most interpreting in the reader when T.</pre></div> </article> </li><li> <a name="CL+QT:*READTABLE*"> </a> <article id="SPECIAL CL+QT:*READTABLE*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2AREADTABLE%2A">*READTABLE*</a></code></h4> </header> <div class="docstring"><pre>Variable bound to current readtable.</pre></div> </article> </li><li> <a name="CL+QT:*SMOKE-MODULES*"> </a> <article id="SPECIAL CL+QT:*SMOKE-MODULES*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2ASMOKE-MODULES%2A">*SMOKE-MODULES*</a></code></h4> </header> <div class="docstring"><pre>A list of all possible smoke modules.
These modules provide the C wrappers required to work with
the respective Qt parts. Usually you will only need
QTCORE and QTGUI, but for example if you need OpenGL support
you'll want QTOPENGL, or if you need phonon, you'll want
the PHONON module.</pre></div> </article> </li><li> <a name="CL+QT:*SMOKE-MODULES-TO-RELOAD*"> </a> <article id="SPECIAL CL+QT:*SMOKE-MODULES-TO-RELOAD*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2ASMOKE-MODULES-TO-RELOAD%2A">*SMOKE-MODULES-TO-RELOAD*</a></code></h4> </header> <div class="docstring"><pre>A list of smoke modules that need to be reloaded on boot.
The system sets this variable itself during the build.</pre></div> </article> </li><li> <a name="CL+QT:*STANDARD-INPUT*"> </a> <article id="SPECIAL CL+QT:*STANDARD-INPUT*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2ASTANDARD-INPUT%2A">*STANDARD-INPUT*</a></code></h4> </header> <div class="docstring"><pre>default input stream</pre></div> </article> </li><li> <a name="CL+QT:*STANDARD-OUTPUT*"> </a> <article id="SPECIAL CL+QT:*STANDARD-OUTPUT*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2ASTANDARD-OUTPUT%2A">*STANDARD-OUTPUT*</a></code></h4> </header> <div class="docstring"><pre>default output stream</pre></div> </article> </li><li> <a name="CL+QT:*TARGET-PACKAGE*"> </a> <article id="SPECIAL CL+QT:*TARGET-PACKAGE*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2ATARGET-PACKAGE%2A">*TARGET-PACKAGE*</a></code></h4> </header> <div class="docstring"><pre>The package used to store Qt wrapper functions that the Q+ system uses.
By default this package is called "Q+". The package should not contain
any systems except for those generated by Qtools.</pre></div> </article> </li><li> <a name="CL+QT:*TERMINAL-IO*"> </a> <article id="SPECIAL CL+QT:*TERMINAL-IO*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2ATERMINAL-IO%2A">*TERMINAL-IO*</a></code></h4> </header> <div class="docstring"><pre>terminal I/O stream</pre></div> </article> </li><li> <a name="CL+QT:*TRACE-OUTPUT*"> </a> <article id="SPECIAL CL+QT:*TRACE-OUTPUT*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2ATRACE-OUTPUT%2A">*TRACE-OUTPUT*</a></code></h4> </header> <div class="docstring"><pre>trace output stream</pre></div> </article> </li><li> <a name="CL+QT:*WIDGET*"> </a> <article id="SPECIAL CL+QT:*WIDGET*"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2AWIDGET%2A">*WIDGET*</a></code></h4> </header> <div class="docstring"><pre>Bound to the class-name of the widget during component expansion and
bound to the class instance during initialization.</pre></div> </article> </li><li> <a name="CL+QT:+"> </a> <article id="SPECIAL CL+QT:+"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2B">+</a></code></h4> </header> <div class="docstring"><pre>the value of the most recent top level READ</pre></div> </article> </li><li> <a name="CL+QT:++"> </a> <article id="SPECIAL CL+QT:++"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2B%2B">++</a></code></h4> </header> <div class="docstring"><pre>the previous value of +</pre></div> </article> </li><li> <a name="CL+QT:+++"> </a> <article id="SPECIAL CL+QT:+++"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2B%2B%2B">+++</a></code></h4> </header> <div class="docstring"><pre>the previous value of ++</pre></div> </article> </li><li> <a name="CL+QT:-"> </a> <article id="SPECIAL CL+QT:-"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A-">-</a></code></h4> </header> <div class="docstring"><pre>the form currently being evaluated</pre></div> </article> </li><li> <a name="CL+QT:/"> </a> <article id="SPECIAL CL+QT:/"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2F">/</a></code></h4> </header> <div class="docstring"><pre>a list of all the values returned by the most recent top level EVAL</pre></div> </article> </li><li> <a name="CL+QT://"> </a> <article id="SPECIAL CL+QT://"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2F%2F">//</a></code></h4> </header> <div class="docstring"><pre>the previous value of /</pre></div> </article> </li><li> <a name="CL+QT:///"> </a> <article id="SPECIAL CL+QT:///"> <header class="special"> <span class="type">special</span> <h4 class="name"><code><a href="#SPECIAL%20CL%2BQT%3A%2F%2F%2F">///</a></code></h4> </header> <div class="docstring"><pre>the previous value of //</pre></div> </article> </li><li> <a name="CL+QT:ABSTRACT-QOBJECT"> </a> <article id="CLASS CL+QT:ABSTRACT-QOBJECT"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3AABSTRACT-QOBJECT">ABSTRACT-QOBJECT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:ARRAY"> </a> <article id="CLASS CL+QT:ARRAY"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3AARRAY">ARRAY</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:BASE-STRING"> </a> <article id="CLASS CL+QT:BASE-STRING"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ABASE-STRING">BASE-STRING</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:BIGNUM"> </a> <article id="CLASS CL+QT:BIGNUM"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ABIGNUM">BIGNUM</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:BIT-VECTOR"> </a> <article id="CLASS CL+QT:BIT-VECTOR"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ABIT-VECTOR">BIT-VECTOR</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:BROADCAST-STREAM"> </a> <article id="CLASS CL+QT:BROADCAST-STREAM"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ABROADCAST-STREAM">BROADCAST-STREAM</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:BUILT-IN-CLASS"> </a> <article id="CLASS CL+QT:BUILT-IN-CLASS"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ABUILT-IN-CLASS">BUILT-IN-CLASS</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:CHARACTER"> </a> <article id="CLASS CL+QT:CHARACTER"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ACHARACTER">CHARACTER</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:CLASS"> </a> <article id="CLASS CL+QT:CLASS"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ACLASS">CLASS</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:COMPLEX"> </a> <article id="CLASS CL+QT:COMPLEX"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ACOMPLEX">COMPLEX</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:CONCATENATED-STREAM"> </a> <article id="CLASS CL+QT:CONCATENATED-STREAM"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ACONCATENATED-STREAM">CONCATENATED-STREAM</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:CONS"> </a> <article id="CLASS CL+QT:CONS"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ACONS">CONS</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:DOUBLE-FLOAT"> </a> <article id="CLASS CL+QT:DOUBLE-FLOAT"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ADOUBLE-FLOAT">DOUBLE-FLOAT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:DYNAMIC-OBJECT"> </a> <article id="CLASS CL+QT:DYNAMIC-OBJECT"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ADYNAMIC-OBJECT">DYNAMIC-OBJECT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:ECHO-STREAM"> </a> <article id="CLASS CL+QT:ECHO-STREAM"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3AECHO-STREAM">ECHO-STREAM</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:FILE-STREAM"> </a> <article id="CLASS CL+QT:FILE-STREAM"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3AFILE-STREAM">FILE-STREAM</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:FINALIZABLE"> </a> <article id="CLASS CL+QT:FINALIZABLE"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3AFINALIZABLE">FINALIZABLE</a></code></h4> </header> <div class="docstring"><pre>A class for finalizable objects.</pre></div> </article> </li><li> <a name="CL+QT:FINALIZABLE-CLASS"> </a> <article id="CLASS CL+QT:FINALIZABLE-CLASS"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3AFINALIZABLE-CLASS">FINALIZABLE-CLASS</a></code></h4> </header> <div class="docstring"><pre>Metaclass for classes with finalizable slots.</pre></div> </article> </li><li> <a name="CL+QT:FINALIZABLE-SLOT"> </a> <article id="CLASS CL+QT:FINALIZABLE-SLOT"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3AFINALIZABLE-SLOT">FINALIZABLE-SLOT</a></code></h4> </header> <div class="docstring"><pre>Superclass for slots with a finalized option.</pre></div> </article> </li><li> <a name="CL+QT:FIXNUM"> </a> <article id="CLASS CL+QT:FIXNUM"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3AFIXNUM">FIXNUM</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:FLOAT"> </a> <article id="CLASS CL+QT:FLOAT"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3AFLOAT">FLOAT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:GC-FINALIZED"> </a> <article id="CLASS CL+QT:GC-FINALIZED"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3AGC-FINALIZED">GC-FINALIZED</a></code></h4> </header> <div class="docstring"><pre>Wrapper object to allow automatic calling of FINALIZE by the GC.
Since you cannot finalize the object that is GC-ed itself, we need to wrap our to-
be-finalized object in another object that takes all the references instead.
This means that if you wish your object to remain unfinalized, you need to retain
references to the wrapper. As soon as the wrapper is hit by the GC, FINALIZE is
called on the object it contains.
In order to retrieve the contained object, use UNBOX.</pre></div> </article> </li><li> <a name="CL+QT:GENERIC-FUNCTION"> </a> <article id="CLASS CL+QT:GENERIC-FUNCTION"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3AGENERIC-FUNCTION">GENERIC-FUNCTION</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:HASH-TABLE"> </a> <article id="CLASS CL+QT:HASH-TABLE"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3AHASH-TABLE">HASH-TABLE</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:INTEGER"> </a> <article id="CLASS CL+QT:INTEGER"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3AINTEGER">INTEGER</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:LIST"> </a> <article id="CLASS CL+QT:LIST"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ALIST">LIST</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:LOGICAL-PATHNAME"> </a> <article id="CLASS CL+QT:LOGICAL-PATHNAME"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ALOGICAL-PATHNAME">LOGICAL-PATHNAME</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:METHOD"> </a> <article id="CLASS CL+QT:METHOD"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3AMETHOD">METHOD</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:METHOD-COMBINATION"> </a> <article id="CLASS CL+QT:METHOD-COMBINATION"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3AMETHOD-COMBINATION">METHOD-COMBINATION</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:NULL"> </a> <article id="CLASS CL+QT:NULL"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ANULL">NULL</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:NULL-QOBJECT"> </a> <article id="CLASS CL+QT:NULL-QOBJECT"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ANULL-QOBJECT">NULL-QOBJECT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:NUMBER"> </a> <article id="CLASS CL+QT:NUMBER"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ANUMBER">NUMBER</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:PACKAGE"> </a> <article id="CLASS CL+QT:PACKAGE"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3APACKAGE">PACKAGE</a></code></h4> </header> <div class="docstring"><pre>the standard structure for the description of a package</pre></div> </article> </li><li> <a name="CL+QT:PATHNAME"> </a> <article id="CLASS CL+QT:PATHNAME"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3APATHNAME">PATHNAME</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:QOBJECT"> </a> <article id="CLASS CL+QT:QOBJECT"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3AQOBJECT">QOBJECT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:QT-CLASS"> </a> <article id="CLASS CL+QT:QT-CLASS"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3AQT-CLASS">QT-CLASS</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:QT-PROGRAM-OP"> </a> <article id="CLASS CL+QT:QT-PROGRAM-OP"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3AQT-PROGRAM-OP">QT-PROGRAM-OP</a></code></h4> </header> <div class="docstring"><pre>A DEPLOY:DEPLOY-OP subclass to handle things for Qt deployment.
You should specify this as the BUILD-OPERATION in your ASD along with
an ENTRY-POINT and a BUILD-PATHNAME.</pre></div> </article> </li><li> <a name="CL+QT:RANDOM-STATE"> </a> <article id="CLASS CL+QT:RANDOM-STATE"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ARANDOM-STATE">RANDOM-STATE</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:RATIO"> </a> <article id="CLASS CL+QT:RATIO"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ARATIO">RATIO</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:RATIONAL"> </a> <article id="CLASS CL+QT:RATIONAL"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ARATIONAL">RATIONAL</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:READTABLE"> </a> <article id="CLASS CL+QT:READTABLE"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3AREADTABLE">READTABLE</a></code></h4> </header> <div class="docstring"><pre>A READTABLE is a data structure that maps characters into syntax
types for the Common Lisp expression reader.</pre></div> </article> </li><li> <a name="CL+QT:REAL"> </a> <article id="CLASS CL+QT:REAL"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3AREAL">REAL</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:RESTART"> </a> <article id="CLASS CL+QT:RESTART"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ARESTART">RESTART</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:SEQUENCE"> </a> <article id="CLASS CL+QT:SEQUENCE"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ASEQUENCE">SEQUENCE</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:SIMPLE-ARRAY"> </a> <article id="CLASS CL+QT:SIMPLE-ARRAY"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ASIMPLE-ARRAY">SIMPLE-ARRAY</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:SIMPLE-BASE-STRING"> </a> <article id="CLASS CL+QT:SIMPLE-BASE-STRING"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ASIMPLE-BASE-STRING">SIMPLE-BASE-STRING</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:SIMPLE-BIT-VECTOR"> </a> <article id="CLASS CL+QT:SIMPLE-BIT-VECTOR"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ASIMPLE-BIT-VECTOR">SIMPLE-BIT-VECTOR</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:SIMPLE-STRING"> </a> <article id="CLASS CL+QT:SIMPLE-STRING"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ASIMPLE-STRING">SIMPLE-STRING</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:SIMPLE-VECTOR"> </a> <article id="CLASS CL+QT:SIMPLE-VECTOR"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ASIMPLE-VECTOR">SIMPLE-VECTOR</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:SINGLE-FLOAT"> </a> <article id="CLASS CL+QT:SINGLE-FLOAT"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ASINGLE-FLOAT">SINGLE-FLOAT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:STANDARD-CLASS"> </a> <article id="CLASS CL+QT:STANDARD-CLASS"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ASTANDARD-CLASS">STANDARD-CLASS</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:STANDARD-GENERIC-FUNCTION"> </a> <article id="CLASS CL+QT:STANDARD-GENERIC-FUNCTION"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ASTANDARD-GENERIC-FUNCTION">STANDARD-GENERIC-FUNCTION</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:STANDARD-METHOD"> </a> <article id="CLASS CL+QT:STANDARD-METHOD"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ASTANDARD-METHOD">STANDARD-METHOD</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:STANDARD-OBJECT"> </a> <article id="CLASS CL+QT:STANDARD-OBJECT"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ASTANDARD-OBJECT">STANDARD-OBJECT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:STREAM"> </a> <article id="CLASS CL+QT:STREAM"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ASTREAM">STREAM</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:STRING"> </a> <article id="CLASS CL+QT:STRING"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ASTRING">STRING</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:STRING-STREAM"> </a> <article id="CLASS CL+QT:STRING-STREAM"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ASTRING-STREAM">STRING-STREAM</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:STRUCTURE-OBJECT"> </a> <article id="CLASS CL+QT:STRUCTURE-OBJECT"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ASTRUCTURE-OBJECT">STRUCTURE-OBJECT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:SYMBOL"> </a> <article id="CLASS CL+QT:SYMBOL"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ASYMBOL">SYMBOL</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:SYNONYM-STREAM"> </a> <article id="CLASS CL+QT:SYNONYM-STREAM"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ASYNONYM-STREAM">SYNONYM-STREAM</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:T"> </a> <article id="CLASS CL+QT:T"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3AT">T</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:TWO-WAY-STREAM"> </a> <article id="CLASS CL+QT:TWO-WAY-STREAM"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3ATWO-WAY-STREAM">TWO-WAY-STREAM</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:VECTOR"> </a> <article id="CLASS CL+QT:VECTOR"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3AVECTOR">VECTOR</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:WIDGET"> </a> <article id="CLASS CL+QT:WIDGET"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3AWIDGET">WIDGET</a></code></h4> </header> <div class="docstring"><pre>Common superclass for all widgets in order to allow for
general initialization and cleanup forms that are standardised across all
widgets.
See <a href="#QTOOLS:DEFINE-WIDGET.">QTOOLS:DEFINE-WIDGET.</a></pre></div> </article> </li><li> <a name="CL+QT:WIDGET-CLASS"> </a> <article id="CLASS CL+QT:WIDGET-CLASS"> <header class="class"> <span class="type">class</span> <h4 class="name"><code><a href="#CLASS%20CL%2BQT%3AWIDGET-CLASS">WIDGET-CLASS</a></code></h4> </header> <div class="docstring"><pre>Metaclass for widgets storing necessary information.
The metadata stored in this is mostly responsible for two things:
1) Providing access to a sequence of mutually independent
initializers and finalizers for convenient setup and cleanup.
2) Allowing after-the-fact out-of-form changes to the class
definition, which is necessary to have for a distributed
definition form syntax as provided by WIDGET-CONVENIENCE macros.
In order to modify the metadata, please look at SET/REMOVE-WIDGET-CLASS-OPTION.</pre></div> </article> </li><li> <a name="CL+QT:ARITHMETIC-ERROR"> </a> <article id="CONDITION CL+QT:ARITHMETIC-ERROR"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3AARITHMETIC-ERROR">ARITHMETIC-ERROR</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:CELL-ERROR"> </a> <article id="CONDITION CL+QT:CELL-ERROR"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3ACELL-ERROR">CELL-ERROR</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:COMPILATION-NOTE"> </a> <article id="CONDITION CL+QT:COMPILATION-NOTE"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3ACOMPILATION-NOTE">COMPILATION-NOTE</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:CONDITION"> </a> <article id="CONDITION CL+QT:CONDITION"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3ACONDITION">CONDITION</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:CONTROL-ERROR"> </a> <article id="CONDITION CL+QT:CONTROL-ERROR"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3ACONTROL-ERROR">CONTROL-ERROR</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:DIVISION-BY-ZERO"> </a> <article id="CONDITION CL+QT:DIVISION-BY-ZERO"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3ADIVISION-BY-ZERO">DIVISION-BY-ZERO</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:END-OF-FILE"> </a> <article id="CONDITION CL+QT:END-OF-FILE"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3AEND-OF-FILE">END-OF-FILE</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:ERROR"> </a> <article id="CONDITION CL+QT:ERROR"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3AERROR">ERROR</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:FILE-ERROR"> </a> <article id="CONDITION CL+QT:FILE-ERROR"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3AFILE-ERROR">FILE-ERROR</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:FLOATING-POINT-INEXACT"> </a> <article id="CONDITION CL+QT:FLOATING-POINT-INEXACT"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3AFLOATING-POINT-INEXACT">FLOATING-POINT-INEXACT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:FLOATING-POINT-INVALID-OPERATION"> </a> <article id="CONDITION CL+QT:FLOATING-POINT-INVALID-OPERATION"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3AFLOATING-POINT-INVALID-OPERATION">FLOATING-POINT-INVALID-OPERATION</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:FLOATING-POINT-OVERFLOW"> </a> <article id="CONDITION CL+QT:FLOATING-POINT-OVERFLOW"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3AFLOATING-POINT-OVERFLOW">FLOATING-POINT-OVERFLOW</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:FLOATING-POINT-UNDERFLOW"> </a> <article id="CONDITION CL+QT:FLOATING-POINT-UNDERFLOW"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3AFLOATING-POINT-UNDERFLOW">FLOATING-POINT-UNDERFLOW</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:INVALID-QT-SUPERCLASS-HIERARCHY"> </a> <article id="CONDITION CL+QT:INVALID-QT-SUPERCLASS-HIERARCHY"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3AINVALID-QT-SUPERCLASS-HIERARCHY">INVALID-QT-SUPERCLASS-HIERARCHY</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:NIL"> </a> <article id="CONDITION CL+QT:NIL"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3ANIL">NIL</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:PACKAGE-ERROR"> </a> <article id="CONDITION CL+QT:PACKAGE-ERROR"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3APACKAGE-ERROR">PACKAGE-ERROR</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:PARSE-ERROR"> </a> <article id="CONDITION CL+QT:PARSE-ERROR"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3APARSE-ERROR">PARSE-ERROR</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:PRINT-NOT-READABLE"> </a> <article id="CONDITION CL+QT:PRINT-NOT-READABLE"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3APRINT-NOT-READABLE">PRINT-NOT-READABLE</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:PROGRAM-ERROR"> </a> <article id="CONDITION CL+QT:PROGRAM-ERROR"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3APROGRAM-ERROR">PROGRAM-ERROR</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:READER-ERROR"> </a> <article id="CONDITION CL+QT:READER-ERROR"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3AREADER-ERROR">READER-ERROR</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:SERIOUS-CONDITION"> </a> <article id="CONDITION CL+QT:SERIOUS-CONDITION"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3ASERIOUS-CONDITION">SERIOUS-CONDITION</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:SIMPLE-CONDITION"> </a> <article id="CONDITION CL+QT:SIMPLE-CONDITION"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3ASIMPLE-CONDITION">SIMPLE-CONDITION</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:SIMPLE-ERROR"> </a> <article id="CONDITION CL+QT:SIMPLE-ERROR"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3ASIMPLE-ERROR">SIMPLE-ERROR</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:SIMPLE-TYPE-ERROR"> </a> <article id="CONDITION CL+QT:SIMPLE-TYPE-ERROR"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3ASIMPLE-TYPE-ERROR">SIMPLE-TYPE-ERROR</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:SIMPLE-WARNING"> </a> <article id="CONDITION CL+QT:SIMPLE-WARNING"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3ASIMPLE-WARNING">SIMPLE-WARNING</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:STORAGE-CONDITION"> </a> <article id="CONDITION CL+QT:STORAGE-CONDITION"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3ASTORAGE-CONDITION">STORAGE-CONDITION</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:STREAM-ERROR"> </a> <article id="CONDITION CL+QT:STREAM-ERROR"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3ASTREAM-ERROR">STREAM-ERROR</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:STYLE-WARNING"> </a> <article id="CONDITION CL+QT:STYLE-WARNING"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3ASTYLE-WARNING">STYLE-WARNING</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:TYPE-ERROR"> </a> <article id="CONDITION CL+QT:TYPE-ERROR"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3ATYPE-ERROR">TYPE-ERROR</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:UNBOUND-SLOT"> </a> <article id="CONDITION CL+QT:UNBOUND-SLOT"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3AUNBOUND-SLOT">UNBOUND-SLOT</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:UNBOUND-VARIABLE"> </a> <article id="CONDITION CL+QT:UNBOUND-VARIABLE"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3AUNBOUND-VARIABLE">UNBOUND-VARIABLE</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:UNDEFINED-FUNCTION"> </a> <article id="CONDITION CL+QT:UNDEFINED-FUNCTION"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3AUNDEFINED-FUNCTION">UNDEFINED-FUNCTION</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:WARNING"> </a> <article id="CONDITION CL+QT:WARNING"> <header class="condition"> <span class="type">condition</span> <h4 class="name"><code><a href="#CONDITION%20CL%2BQT%3AWARNING">WARNING</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:NIL"> </a> <article id="STRUCTURE CL+QT:NIL"> <header class="structure"> <span class="type">structure</span> <h4 class="name"><code><a href="#STRUCTURE%20CL%2BQT%3ANIL">NIL</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:STRUCTURE-CLASS"> </a> <article id="STRUCTURE CL+QT:STRUCTURE-CLASS"> <header class="structure"> <span class="type">structure</span> <h4 class="name"><code><a href="#STRUCTURE%20CL%2BQT%3ASTRUCTURE-CLASS">STRUCTURE-CLASS</a></code></h4> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:AREF"> </a> <article id="ACCESSOR CL+QT:AREF"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3AAREF">AREF</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ARRAY &REST SUBSCRIPTS</code><code>)</code> </header> <div class="docstring"><pre>Return the element of the ARRAY specified by the SUBSCRIPTS.</pre></div> </article> </li><li> <a name="CL+QT:BIT"> </a> <article id="ACCESSOR CL+QT:BIT"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ABIT">BIT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">BIT-ARRAY &REST SUBSCRIPTS</code><code>)</code> </header> <div class="docstring"><pre>Return the bit from the BIT-ARRAY at the specified SUBSCRIPTS.</pre></div> </article> </li><li> <a name="CL+QT:CAAAAR"> </a> <article id="ACCESSOR CL+QT:CAAAAR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACAAAAR">CAAAAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the car of the caaar of a list.</pre></div> </article> </li><li> <a name="CL+QT:CAAADR"> </a> <article id="ACCESSOR CL+QT:CAAADR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACAAADR">CAAADR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the car of the caadr of a list.</pre></div> </article> </li><li> <a name="CL+QT:CAAAR"> </a> <article id="ACCESSOR CL+QT:CAAAR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACAAAR">CAAAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the 1st object in the caar of a list.</pre></div> </article> </li><li> <a name="CL+QT:CAADAR"> </a> <article id="ACCESSOR CL+QT:CAADAR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACAADAR">CAADAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the car of the cadar of a list.</pre></div> </article> </li><li> <a name="CL+QT:CAADDR"> </a> <article id="ACCESSOR CL+QT:CAADDR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACAADDR">CAADDR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the car of the caddr of a list.</pre></div> </article> </li><li> <a name="CL+QT:CAADR"> </a> <article id="ACCESSOR CL+QT:CAADR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACAADR">CAADR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the 1st object in the cadr of a list.</pre></div> </article> </li><li> <a name="CL+QT:CAAR"> </a> <article id="ACCESSOR CL+QT:CAAR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACAAR">CAAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the car of the 1st sublist.</pre></div> </article> </li><li> <a name="CL+QT:CADAAR"> </a> <article id="ACCESSOR CL+QT:CADAAR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACADAAR">CADAAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the car of the cdaar of a list.</pre></div> </article> </li><li> <a name="CL+QT:CADADR"> </a> <article id="ACCESSOR CL+QT:CADADR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACADADR">CADADR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the car of the cdadr of a list.</pre></div> </article> </li><li> <a name="CL+QT:CADAR"> </a> <article id="ACCESSOR CL+QT:CADAR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACADAR">CADAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the car of the cdar of a list.</pre></div> </article> </li><li> <a name="CL+QT:CADDAR"> </a> <article id="ACCESSOR CL+QT:CADDAR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACADDAR">CADDAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the car of the cddar of a list.</pre></div> </article> </li><li> <a name="CL+QT:CADDDR"> </a> <article id="ACCESSOR CL+QT:CADDDR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACADDDR">CADDDR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the car of the cdddr of a list.</pre></div> </article> </li><li> <a name="CL+QT:CADDR"> </a> <article id="ACCESSOR CL+QT:CADDR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACADDR">CADDR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the 1st object in the cddr of a list.</pre></div> </article> </li><li> <a name="CL+QT:CADR"> </a> <article id="ACCESSOR CL+QT:CADR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACADR">CADR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the 2nd object in a list.</pre></div> </article> </li><li> <a name="CL+QT:CAR"> </a> <article id="ACCESSOR CL+QT:CAR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACAR">CAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the 1st object in a list.</pre></div> </article> </li><li> <a name="CL+QT:CDAAAR"> </a> <article id="ACCESSOR CL+QT:CDAAAR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACDAAAR">CDAAAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the cdr of the caaar of a list.</pre></div> </article> </li><li> <a name="CL+QT:CDAADR"> </a> <article id="ACCESSOR CL+QT:CDAADR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACDAADR">CDAADR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the cdr of the caadr of a list.</pre></div> </article> </li><li> <a name="CL+QT:CDAAR"> </a> <article id="ACCESSOR CL+QT:CDAAR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACDAAR">CDAAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the cdr of the caar of a list.</pre></div> </article> </li><li> <a name="CL+QT:CDADAR"> </a> <article id="ACCESSOR CL+QT:CDADAR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACDADAR">CDADAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the cdr of the cadar of a list.</pre></div> </article> </li><li> <a name="CL+QT:CDADDR"> </a> <article id="ACCESSOR CL+QT:CDADDR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACDADDR">CDADDR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the cdr of the caddr of a list.</pre></div> </article> </li><li> <a name="CL+QT:CDADR"> </a> <article id="ACCESSOR CL+QT:CDADR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACDADR">CDADR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the cdr of the cadr of a list.</pre></div> </article> </li><li> <a name="CL+QT:CDAR"> </a> <article id="ACCESSOR CL+QT:CDAR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACDAR">CDAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the cdr of the 1st sublist.</pre></div> </article> </li><li> <a name="CL+QT:CDDAAR"> </a> <article id="ACCESSOR CL+QT:CDDAAR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACDDAAR">CDDAAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the cdr of the cdaar of a list.</pre></div> </article> </li><li> <a name="CL+QT:CDDADR"> </a> <article id="ACCESSOR CL+QT:CDDADR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACDDADR">CDDADR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the cdr of the cdadr of a list.</pre></div> </article> </li><li> <a name="CL+QT:CDDAR"> </a> <article id="ACCESSOR CL+QT:CDDAR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACDDAR">CDDAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the cdr of the cdar of a list.</pre></div> </article> </li><li> <a name="CL+QT:CDDDAR"> </a> <article id="ACCESSOR CL+QT:CDDDAR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACDDDAR">CDDDAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the cdr of the cddar of a list.</pre></div> </article> </li><li> <a name="CL+QT:CDDDDR"> </a> <article id="ACCESSOR CL+QT:CDDDDR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACDDDDR">CDDDDR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the cdr of the cdddr of a list.</pre></div> </article> </li><li> <a name="CL+QT:CDDDR"> </a> <article id="ACCESSOR CL+QT:CDDDR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACDDDR">CDDDR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the cdr of the cddr of a list.</pre></div> </article> </li><li> <a name="CL+QT:CDDR"> </a> <article id="ACCESSOR CL+QT:CDDR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACDDR">CDDR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return all but the 1st two objects of a list.</pre></div> </article> </li><li> <a name="CL+QT:CDR"> </a> <article id="ACCESSOR CL+QT:CDR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACDR">CDR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return all but the first object in a list.</pre></div> </article> </li><li> <a name="CL+QT:CHAR"> </a> <article id="ACCESSOR CL+QT:CHAR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACHAR">CHAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">STRING INDEX</code><code>)</code> </header> <div class="docstring"><pre>Given a string and a non-negative integer index less than the length of
the string, returns the character object representing the character at
that position in the string.</pre></div> </article> </li><li> <a name="CL+QT:CLASHING-QT-SUPERCLASS"> </a> <article id="ACCESSOR CL+QT:CLASHING-QT-SUPERCLASS"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACLASHING-QT-SUPERCLASS">CLASHING-QT-SUPERCLASS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CONDITION</code><code>)</code> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:CLASHING-SUPERCLASS"> </a> <article id="ACCESSOR CL+QT:CLASHING-SUPERCLASS"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACLASHING-SUPERCLASS">CLASHING-SUPERCLASS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CONDITION</code><code>)</code> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:CLASS-NAME"> </a> <article id="ACCESSOR CL+QT:CLASS-NAME"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACLASS-NAME">CLASS-NAME</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CLASS</code><code>)</code> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:COMPILER-MACRO-FUNCTION"> </a> <article id="ACCESSOR CL+QT:COMPILER-MACRO-FUNCTION"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACOMPILER-MACRO-FUNCTION">COMPILER-MACRO-FUNCTION</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME &OPTIONAL ENV</code><code>)</code> </header> <div class="docstring"><pre>If NAME names a compiler-macro in ENV, return the expansion function, else
return NIL. Can be set with SETF when ENV is NIL.</pre></div> </article> </li><li> <a name="CL+QT:CONCATENATED-STREAM-STREAMS"> </a> <article id="ACCESSOR CL+QT:CONCATENATED-STREAM-STREAMS"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ACONCATENATED-STREAM-STREAMS">CONCATENATED-STREAM-STREAMS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">INSTANCE</code><code>)</code> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:DOCUMENTATION"> </a> <article id="ACCESSOR CL+QT:DOCUMENTATION"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ADOCUMENTATION">DOCUMENTATION</a></code></h4> <code class="qualifiers"></code> <code class="arguments">SLOTD DOC-TYPE</code><code>)</code> </header> <div class="docstring"><pre>Return the documentation string of Doc-Type for X, or NIL if none
exists. System doc-types are VARIABLE, FUNCTION, STRUCTURE, TYPE, SETF, and T.
Function documentation is stored separately for function names and objects:
DEFUN, LAMBDA, &co create function objects with the specified documentation
strings.
(SETF (DOCUMENTATION NAME 'FUNCTION) STRING)
sets the documentation string stored under the specified name, and
(SETF (DOCUMENTATION FUNC T) STRING)
sets the documentation string stored in the function object.
(DOCUMENTATION NAME 'FUNCTION)
returns the documentation stored under the function name if any, and
falls back on the documentation in the function object if necessary.</pre></div> </article> </li><li> <a name="CL+QT:EIGHTH"> </a> <article id="ACCESSOR CL+QT:EIGHTH"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3AEIGHTH">EIGHTH</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the 8th object in a list or NIL if there is no 8th object.</pre></div> </article> </li><li> <a name="CL+QT:ELT"> </a> <article id="ACCESSOR CL+QT:ELT"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3AELT">ELT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">SEQUENCE INDEX</code><code>)</code> </header> <div class="docstring"><pre>Return the element of SEQUENCE specified by INDEX.</pre></div> </article> </li><li> <a name="CL+QT:ENUM-VALUE"> </a> <article id="ACCESSOR CL+QT:ENUM-VALUE"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3AENUM-VALUE">ENUM-VALUE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:FDEFINITION"> </a> <article id="ACCESSOR CL+QT:FDEFINITION"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3AFDEFINITION">FDEFINITION</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME</code><code>)</code> </header> <div class="docstring"><pre>Accesses the current global function definition named by NAME.
Identical to CL:FDEFINITION, but takes care of translating function-names
with SETF to use CL:SETF instead of CL+QT:SETF.
See <a href="http://l1sp.org/cl/fdefinition.">CL:FDEFINITION.</a></pre></div> </article> </li><li> <a name="CL+QT:FIFTH"> </a> <article id="ACCESSOR CL+QT:FIFTH"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3AFIFTH">FIFTH</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the 5th object in a list or NIL if there is no 5th object.</pre></div> </article> </li><li> <a name="CL+QT:FILL-POINTER"> </a> <article id="ACCESSOR CL+QT:FILL-POINTER"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3AFILL-POINTER">FILL-POINTER</a></code></h4> <code class="qualifiers"></code> <code class="arguments">VECTOR</code><code>)</code> </header> <div class="docstring"><pre>Return the FILL-POINTER of the given VECTOR.</pre></div> </article> </li><li> <a name="CL+QT:FIND-CLASS"> </a> <article id="ACCESSOR CL+QT:FIND-CLASS"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3AFIND-CLASS">FIND-CLASS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">SYMBOL &OPTIONAL (ERRORP T) ENVIRONMENT</code><code>)</code> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:FIRST"> </a> <article id="ACCESSOR CL+QT:FIRST"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3AFIRST">FIRST</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the 1st object in a list or NIL if the list is empty.</pre></div> </article> </li><li> <a name="CL+QT:FOURTH"> </a> <article id="ACCESSOR CL+QT:FOURTH"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3AFOURTH">FOURTH</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the 4th object in a list or NIL if there is no 4th object.</pre></div> </article> </li><li> <a name="CL+QT:GETHASH"> </a> <article id="ACCESSOR CL+QT:GETHASH"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3AGETHASH">GETHASH</a></code></h4> <code class="qualifiers"></code> <code class="arguments">KEY HASH-TABLE &OPTIONAL DEFAULT</code><code>)</code> </header> <div class="docstring"><pre>Finds the entry in HASH-TABLE whose key is KEY and returns the
associated value and T as multiple values, or returns DEFAULT and NIL
if there is no such entry. Entries can be added using SETF.</pre></div> </article> </li><li> <a name="CL+QT:LOGICAL-PATHNAME-TRANSLATIONS"> </a> <article id="ACCESSOR CL+QT:LOGICAL-PATHNAME-TRANSLATIONS"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ALOGICAL-PATHNAME-TRANSLATIONS">LOGICAL-PATHNAME-TRANSLATIONS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">HOST</code><code>)</code> </header> <div class="docstring"><pre>Return the (logical) host object argument's list of translations.</pre></div> </article> </li><li> <a name="CL+QT:MACRO-FUNCTION"> </a> <article id="ACCESSOR CL+QT:MACRO-FUNCTION"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3AMACRO-FUNCTION">MACRO-FUNCTION</a></code></h4> <code class="qualifiers"></code> <code class="arguments">SYMBOL &OPTIONAL ENV</code><code>)</code> </header> <div class="docstring"><pre>If SYMBOL names a macro in ENV, returns the expansion function,
else returns NIL. If ENV is unspecified or NIL, use the global environment
only.</pre></div> </article> </li><li> <a name="CL+QT:MENU-CONTENT-TYPE"> </a> <article id="ACCESSOR CL+QT:MENU-CONTENT-TYPE"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3AMENU-CONTENT-TYPE">MENU-CONTENT-TYPE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME</code><code>)</code> </header> <div class="docstring"><pre>Returns the function to process a menu content type NAME, if any.</pre></div> </article> </li><li> <a name="CL+QT:METHOD-DECLARATION"> </a> <article id="ACCESSOR CL+QT:METHOD-DECLARATION"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3AMETHOD-DECLARATION">METHOD-DECLARATION</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NAME</code><code>)</code> </header> <div class="docstring"><pre>Returns a function to process the method declaration NAME, if one exists.
See <a href="NIL">(SETF</a> QTOOLS:METHOD-DECLARATION).</pre></div> </article> </li><li> <a name="CL+QT:NINTH"> </a> <article id="ACCESSOR CL+QT:NINTH"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ANINTH">NINTH</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the 9th object in a list or NIL if there is no 9th object.</pre></div> </article> </li><li> <a name="CL+QT:NTH"> </a> <article id="ACCESSOR CL+QT:NTH"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ANTH">NTH</a></code></h4> <code class="qualifiers"></code> <code class="arguments">N LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the nth object in a list where the car is the zero-th element.</pre></div> </article> </li><li> <a name="CL+QT:PARENT"> </a> <article id="ACCESSOR CL+QT:PARENT"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3APARENT">PARENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>accesses the PARENT of the object. This usually translates to (#_parent object) unless overridden.</pre></div> </article> </li><li> <a name="CL+QT:PRIMITIVE-VALUE"> </a> <article id="ACCESSOR CL+QT:PRIMITIVE-VALUE"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3APRIMITIVE-VALUE">PRIMITIVE-VALUE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:READTABLE-CASE"> </a> <article id="ACCESSOR CL+QT:READTABLE-CASE"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3AREADTABLE-CASE">READTABLE-CASE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">READTABLE</code><code>)</code> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:REQUESTED-QT-SUPERCLASS"> </a> <article id="ACCESSOR CL+QT:REQUESTED-QT-SUPERCLASS"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3AREQUESTED-QT-SUPERCLASS">REQUESTED-QT-SUPERCLASS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CONDITION</code><code>)</code> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:REST"> </a> <article id="ACCESSOR CL+QT:REST"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3AREST">REST</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Means the same as the cdr of a list.</pre></div> </article> </li><li> <a name="CL+QT:ROW-MAJOR-AREF"> </a> <article id="ACCESSOR CL+QT:ROW-MAJOR-AREF"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3AROW-MAJOR-AREF">ROW-MAJOR-AREF</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ARRAY INDEX</code><code>)</code> </header> <div class="docstring"><pre>Return the element of array corresponding to the row-major index. This is
SETFable.</pre></div> </article> </li><li> <a name="CL+QT:SBIT"> </a> <article id="ACCESSOR CL+QT:SBIT"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ASBIT">SBIT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">SIMPLE-BIT-ARRAY &REST SUBSCRIPTS</code><code>)</code> </header> <div class="docstring"><pre>Return the bit from SIMPLE-BIT-ARRAY at the specified SUBSCRIPTS.</pre></div> </article> </li><li> <a name="CL+QT:SCHAR"> </a> <article id="ACCESSOR CL+QT:SCHAR"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ASCHAR">SCHAR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">STRING INDEX</code><code>)</code> </header> <div class="docstring"><pre>SCHAR returns the character object at an indexed position in a string
just as CHAR does, except the string must be a simple-string.</pre></div> </article> </li><li> <a name="CL+QT:SECOND"> </a> <article id="ACCESSOR CL+QT:SECOND"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ASECOND">SECOND</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the 2nd object in a list or NIL if there is no 2nd object.</pre></div> </article> </li><li> <a name="CL+QT:SEVENTH"> </a> <article id="ACCESSOR CL+QT:SEVENTH"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ASEVENTH">SEVENTH</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the 7th object in a list or NIL if there is no 7th object.</pre></div> </article> </li><li> <a name="CL+QT:SIXTH"> </a> <article id="ACCESSOR CL+QT:SIXTH"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ASIXTH">SIXTH</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the 6th object in a list or NIL if there is no 6th object.</pre></div> </article> </li><li> <a name="CL+QT:SLOT-VALUE"> </a> <article id="ACCESSOR CL+QT:SLOT-VALUE"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ASLOT-VALUE">SLOT-VALUE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT SLOT-NAME</code><code>)</code> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:SVREF"> </a> <article id="ACCESSOR CL+QT:SVREF"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ASVREF">SVREF</a></code></h4> <code class="qualifiers"></code> <code class="arguments">SIMPLE-VECTOR INDEX</code><code>)</code> </header> <div class="docstring"><pre>Return the INDEXth element of the given Simple-Vector.</pre></div> </article> </li><li> <a name="CL+QT:SYMBOL-FUNCTION"> </a> <article id="ACCESSOR CL+QT:SYMBOL-FUNCTION"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ASYMBOL-FUNCTION">SYMBOL-FUNCTION</a></code></h4> <code class="qualifiers"></code> <code class="arguments">SYMBOL</code><code>)</code> </header> <div class="docstring"><pre>Return SYMBOL's current function definition. Settable with SETF.</pre></div> </article> </li><li> <a name="CL+QT:SYMBOL-PLIST"> </a> <article id="ACCESSOR CL+QT:SYMBOL-PLIST"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ASYMBOL-PLIST">SYMBOL-PLIST</a></code></h4> <code class="qualifiers"></code> <code class="arguments">SYMBOL</code><code>)</code> </header> <div class="docstring"><pre>Return SYMBOL's property list.</pre></div> </article> </li><li> <a name="CL+QT:SYMBOL-VALUE"> </a> <article id="ACCESSOR CL+QT:SYMBOL-VALUE"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ASYMBOL-VALUE">SYMBOL-VALUE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">SYMBOL</code><code>)</code> </header> <div class="docstring"><pre>Return SYMBOL's current bound value.</pre></div> </article> </li><li> <a name="CL+QT:TENTH"> </a> <article id="ACCESSOR CL+QT:TENTH"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ATENTH">TENTH</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the 10th object in a list or NIL if there is no 10th object.</pre></div> </article> </li><li> <a name="CL+QT:THIRD"> </a> <article id="ACCESSOR CL+QT:THIRD"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3ATHIRD">THIRD</a></code></h4> <code class="qualifiers"></code> <code class="arguments">LIST</code><code>)</code> </header> <div class="docstring"><pre>Return the 3rd object in a list or NIL if there is no 3rd object.</pre></div> </article> </li><li> <a name="CL+QT:VALUE"> </a> <article id="ACCESSOR CL+QT:VALUE"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3AVALUE">VALUE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Accesses the VALUE of the object. This usually translates to (#_value object) unless overridden.</pre></div> </article> </li><li> <a name="CL+QT:WIDGET-ACTIONS"> </a> <article id="ACCESSOR CL+QT:WIDGET-ACTIONS"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3AWIDGET-ACTIONS">WIDGET-ACTIONS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CLASS</code><code>)</code> </header> <div class="docstring"><pre>Returns a list of QAction instances that are active on the given CLASS.</pre></div> </article> </li><li> <a name="CL+QT:WIDGET-CLASS-DIRECT-OPTIONS"> </a> <article id="ACCESSOR CL+QT:WIDGET-CLASS-DIRECT-OPTIONS"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3AWIDGET-CLASS-DIRECT-OPTIONS">WIDGET-CLASS-DIRECT-OPTIONS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Contains all the options passed to RE/INITIALIZE-INSTANCE when
the class is re/initialized directly through a DEFCLASS form.</pre></div> </article> </li><li> <a name="CL+QT:WIDGET-CLASS-EXTERN-OPTIONS"> </a> <article id="ACCESSOR CL+QT:WIDGET-CLASS-EXTERN-OPTIONS"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3AWIDGET-CLASS-EXTERN-OPTIONS">WIDGET-CLASS-EXTERN-OPTIONS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Contains all the options that are added to the class definition
through external forms and thus need to be included and kept separate
from options directly specified in the class definition.</pre></div> </article> </li><li> <a name="CL+QT:WIDGET-CLASS-FINALIZERS"> </a> <article id="ACCESSOR CL+QT:WIDGET-CLASS-FINALIZERS"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3AWIDGET-CLASS-FINALIZERS">WIDGET-CLASS-FINALIZERS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>A sorted list of functions to be called upon finalization.
This list is overwritten completely whenever the class is re/initialized.
See <a href="#QTOOLS:CALL-FINALIZERS">QTOOLS:CALL-FINALIZERS</a></pre></div> </article> </li><li> <a name="CL+QT:WIDGET-CLASS-INITIALIZERS"> </a> <article id="ACCESSOR CL+QT:WIDGET-CLASS-INITIALIZERS"> <header class="accessor"> <span class="type">accessor</span> <code>(</code><h4 class="name"><code><a href="#ACCESSOR%20CL%2BQT%3AWIDGET-CLASS-INITIALIZERS">WIDGET-CLASS-INITIALIZERS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>A sorted list of functions to be called upon initialization.
This list is overwritten completely whenever the class is re/initialized.
See <a href="#QTOOLS:CALL-INITIALIZERS">QTOOLS:CALL-INITIALIZERS</a></pre></div> </article> </li><li> <a name="CL+QT:*"> </a> <article id="FUNCTION CL+QT:*"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3A%2A">*</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&REST NUMBERS</code><code>)</code> </header> <div class="docstring"><pre>Return the product of its arguments. With no args, returns 1.</pre></div> </article> </li><li> <a name="CL+QT:+"> </a> <article id="FUNCTION CL+QT:+"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3A%2B">+</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&REST NUMBERS</code><code>)</code> </header> <div class="docstring"><pre>Return the sum of its arguments. With no args, returns 0.</pre></div> </article> </li><li> <a name="CL+QT:-"> </a> <article id="FUNCTION CL+QT:-"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3A-">-</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NUMBER &REST MORE-NUMBERS</code><code>)</code> </header> <div class="docstring"><pre>Subtract the second and all subsequent arguments from the first;
or with one argument, negate the first argument.</pre></div> </article> </li><li> <a name="CL+QT:/"> </a> <article id="FUNCTION CL+QT:/"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3A%2F">/</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NUMBER &REST MORE-NUMBERS</code><code>)</code> </header> <div class="docstring"><pre>Divide the first argument by each of the following arguments, in turn.
With one argument, return reciprocal.</pre></div> </article> </li><li> <a name="CL+QT:/="> </a> <article id="FUNCTION CL+QT:/="> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3A%2F%3D">/=</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NUMBER &REST MORE-NUMBERS</code><code>)</code> </header> <div class="docstring"><pre>Return T if no two of its arguments are numerically equal, NIL otherwise.</pre></div> </article> </li><li> <a name="CL+QT:1+"> </a> <article id="FUNCTION CL+QT:1+"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3A1%2B">1+</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NUMBER</code><code>)</code> </header> <div class="docstring"><pre>Return NUMBER + 1.</pre></div> </article> </li><li> <a name="CL+QT:1-"> </a> <article id="FUNCTION CL+QT:1-"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3A1-">1-</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NUMBER</code><code>)</code> </header> <div class="docstring"><pre>Return NUMBER - 1.</pre></div> </article> </li><li> <a name="CL+QT:<"> </a> <article id="FUNCTION CL+QT:<"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3A%3C"><</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NUMBER &REST MORE-NUMBERS</code><code>)</code> </header> <div class="docstring"><pre>Return T if its arguments are in strictly increasing order, NIL otherwise.</pre></div> </article> </li><li> <a name="CL+QT:<="> </a> <article id="FUNCTION CL+QT:<="> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3A%3C%3D"><=</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NUMBER &REST MORE-NUMBERS</code><code>)</code> </header> <div class="docstring"><pre>Return T if arguments are in strictly non-decreasing order, NIL otherwise.</pre></div> </article> </li><li> <a name="CL+QT:="> </a> <article id="FUNCTION CL+QT:="> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3A%3D">=</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NUMBER &REST MORE-NUMBERS</code><code>)</code> </header> <div class="docstring"><pre>Return T if all of its arguments are numerically equal, NIL otherwise.</pre></div> </article> </li><li> <a name="CL+QT:>"> </a> <article id="FUNCTION CL+QT:>"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3A%3E">></a></code></h4> <code class="qualifiers"></code> <code class="arguments">NUMBER &REST MORE-NUMBERS</code><code>)</code> </header> <div class="docstring"><pre>Return T if its arguments are in strictly decreasing order, NIL otherwise.</pre></div> </article> </li><li> <a name="CL+QT:>="> </a> <article id="FUNCTION CL+QT:>="> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3A%3E%3D">>=</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NUMBER &REST MORE-NUMBERS</code><code>)</code> </header> <div class="docstring"><pre>Return T if arguments are in strictly non-increasing order, NIL otherwise.</pre></div> </article> </li><li> <a name="CL+QT:ABORT"> </a> <article id="FUNCTION CL+QT:ABORT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AABORT">ABORT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&OPTIONAL CONDITION</code><code>)</code> </header> <div class="docstring"><pre>Transfer control to a restart named ABORT, signalling a CONTROL-ERROR if
none exists.</pre></div> </article> </li><li> <a name="CL+QT:ABS"> </a> <article id="FUNCTION CL+QT:ABS"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AABS">ABS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NUMBER</code><code>)</code> </header> <div class="docstring"><pre>Return the absolute value of the number.</pre></div> </article> </li><li> <a name="CL+QT:ACONS"> </a> <article id="FUNCTION CL+QT:ACONS"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AACONS">ACONS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">KEY DATUM ALIST</code><code>)</code> </header> <div class="docstring"><pre>Construct a new alist by adding the pair (KEY . DATUM) to ALIST.</pre></div> </article> </li><li> <a name="CL+QT:ACOS"> </a> <article id="FUNCTION CL+QT:ACOS"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AACOS">ACOS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NUMBER</code><code>)</code> </header> <div class="docstring"><pre>Return the arc cosine of NUMBER.</pre></div> </article> </li><li> <a name="CL+QT:ACOSH"> </a> <article id="FUNCTION CL+QT:ACOSH"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AACOSH">ACOSH</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NUMBER</code><code>)</code> </header> <div class="docstring"><pre>Return the hyperbolic arc cosine of NUMBER.</pre></div> </article> </li><li> <a name="CL+QT:ADJOIN"> </a> <article id="FUNCTION CL+QT:ADJOIN"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AADJOIN">ADJOIN</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ITEM LIST &KEY KEY (TEST (FUNCTION EQL) TESTP) (TEST-NOT NIL NOTP)</code><code>)</code> </header> <div class="docstring"><pre>Add ITEM to LIST unless it is already a member</pre></div> </article> </li><li> <a name="CL+QT:ADJUST-ARRAY"> </a> <article id="FUNCTION CL+QT:ADJUST-ARRAY"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AADJUST-ARRAY">ADJUST-ARRAY</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ARRAY DIMENSIONS &KEY (ELEMENT-TYPE (ARRAY-ELEMENT-TYPE ARRAY) ELEMENT-TYPE-P)
(INITIAL-ELEMENT NIL INITIAL-ELEMENT-P)
(INITIAL-CONTENTS NIL INITIAL-CONTENTS-P) FILL-POINTER DISPLACED-TO
DISPLACED-INDEX-OFFSET</code><code>)</code> </header> <div class="docstring"><pre>Adjust ARRAY's dimensions to the given DIMENSIONS and stuff.</pre></div> </article> </li><li> <a name="CL+QT:ADJUSTABLE-ARRAY-P"> </a> <article id="FUNCTION CL+QT:ADJUSTABLE-ARRAY-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AADJUSTABLE-ARRAY-P">ADJUSTABLE-ARRAY-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ARRAY</code><code>)</code> </header> <div class="docstring"><pre>Return T if and only if calling ADJUST-ARRAY on ARRAY will return
the identical object.</pre></div> </article> </li><li> <a name="CL+QT:ALPHA-CHAR-P"> </a> <article id="FUNCTION CL+QT:ALPHA-CHAR-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AALPHA-CHAR-P">ALPHA-CHAR-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHAR</code><code>)</code> </header> <div class="docstring"><pre>The argument must be a character object. ALPHA-CHAR-P returns T if the
argument is an alphabetic character, A-Z or a-z; otherwise NIL.</pre></div> </article> </li><li> <a name="CL+QT:ALPHANUMERICP"> </a> <article id="FUNCTION CL+QT:ALPHANUMERICP"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AALPHANUMERICP">ALPHANUMERICP</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CHAR</code><code>)</code> </header> <div class="docstring"><pre>Given a character-object argument, ALPHANUMERICP returns T if the argument
is either numeric or alphabetic.</pre></div> </article> </li><li> <a name="CL+QT:APPEND"> </a> <article id="FUNCTION CL+QT:APPEND"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AAPPEND">APPEND</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&REST LISTS</code><code>)</code> </header> <div class="docstring"><pre>Construct a new list by concatenating the list arguments</pre></div> </article> </li><li> <a name="CL+QT:APPLY"> </a> <article id="FUNCTION CL+QT:APPLY"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AAPPLY">APPLY</a></code></h4> <code class="qualifiers"></code> <code class="arguments">FUNCTION ARG &REST ARGUMENTS</code><code>)</code> </header> <div class="docstring"><pre>Apply FUNCTION to a list of arguments produced by evaluating ARGUMENTS in
the manner of LIST*. That is, a list is made of the values of all but the
last argument, appended to the value of the last argument, which must be a
list.</pre></div> </article> </li><li> <a name="CL+QT:APROPOS"> </a> <article id="FUNCTION CL+QT:APROPOS"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AAPROPOS">APROPOS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">STRING-DESIGNATOR &OPTIONAL PACKAGE EXTERNAL-ONLY</code><code>)</code> </header> <div class="docstring"><pre>Briefly describe all symbols which contain the specified STRING.
If PACKAGE is supplied then only describe symbols present in
that package. If EXTERNAL-ONLY then only describe
external symbols in the specified package.</pre></div> </article> </li><li> <a name="CL+QT:APROPOS-LIST"> </a> <article id="FUNCTION CL+QT:APROPOS-LIST"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AAPROPOS-LIST">APROPOS-LIST</a></code></h4> <code class="qualifiers"></code> <code class="arguments">STRING-DESIGNATOR &OPTIONAL PACKAGE-DESIGNATOR EXTERNAL-ONLY</code><code>)</code> </header> <div class="docstring"><pre>Like APROPOS, except that it returns a list of the symbols found instead
of describing them.</pre></div> </article> </li><li> <a name="CL+QT:ARITHMETIC-ERROR-OPERANDS"> </a> <article id="FUNCTION CL+QT:ARITHMETIC-ERROR-OPERANDS"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AARITHMETIC-ERROR-OPERANDS">ARITHMETIC-ERROR-OPERANDS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CONDITION</code><code>)</code> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:ARITHMETIC-ERROR-OPERATION"> </a> <article id="FUNCTION CL+QT:ARITHMETIC-ERROR-OPERATION"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AARITHMETIC-ERROR-OPERATION">ARITHMETIC-ERROR-OPERATION</a></code></h4> <code class="qualifiers"></code> <code class="arguments">CONDITION</code><code>)</code> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:ARRAY-DIMENSION"> </a> <article id="FUNCTION CL+QT:ARRAY-DIMENSION"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AARRAY-DIMENSION">ARRAY-DIMENSION</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ARRAY AXIS-NUMBER</code><code>)</code> </header> <div class="docstring"><pre>Return the length of dimension AXIS-NUMBER of ARRAY.</pre></div> </article> </li><li> <a name="CL+QT:ARRAY-DIMENSIONS"> </a> <article id="FUNCTION CL+QT:ARRAY-DIMENSIONS"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AARRAY-DIMENSIONS">ARRAY-DIMENSIONS</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ARRAY</code><code>)</code> </header> <div class="docstring"><pre>Return a list whose elements are the dimensions of the array</pre></div> </article> </li><li> <a name="CL+QT:ARRAY-DISPLACEMENT"> </a> <article id="FUNCTION CL+QT:ARRAY-DISPLACEMENT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AARRAY-DISPLACEMENT">ARRAY-DISPLACEMENT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ARRAY</code><code>)</code> </header> <div class="docstring"><pre>Return the values of :DISPLACED-TO and :DISPLACED-INDEX-offset
options to MAKE-ARRAY, or NIL and 0 if not a displaced array.</pre></div> </article> </li><li> <a name="CL+QT:ARRAY-ELEMENT-TYPE"> </a> <article id="FUNCTION CL+QT:ARRAY-ELEMENT-TYPE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AARRAY-ELEMENT-TYPE">ARRAY-ELEMENT-TYPE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ARRAY</code><code>)</code> </header> <div class="docstring"><pre>Return the type of the elements of the array</pre></div> </article> </li><li> <a name="CL+QT:ARRAY-HAS-FILL-POINTER-P"> </a> <article id="FUNCTION CL+QT:ARRAY-HAS-FILL-POINTER-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AARRAY-HAS-FILL-POINTER-P">ARRAY-HAS-FILL-POINTER-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ARRAY</code><code>)</code> </header> <div class="docstring"><pre>Return T if the given ARRAY has a fill pointer, or NIL otherwise.</pre></div> </article> </li><li> <a name="CL+QT:ARRAY-IN-BOUNDS-P"> </a> <article id="FUNCTION CL+QT:ARRAY-IN-BOUNDS-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AARRAY-IN-BOUNDS-P">ARRAY-IN-BOUNDS-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ARRAY &REST SUBSCRIPTS</code><code>)</code> </header> <div class="docstring"><pre>Return T if the SUBSCRIPTS are in bounds for the ARRAY, NIL otherwise.</pre></div> </article> </li><li> <a name="CL+QT:ARRAY-RANK"> </a> <article id="FUNCTION CL+QT:ARRAY-RANK"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AARRAY-RANK">ARRAY-RANK</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ARRAY</code><code>)</code> </header> <div class="docstring"><pre>Return the number of dimensions of ARRAY.</pre></div> </article> </li><li> <a name="CL+QT:ARRAY-ROW-MAJOR-INDEX"> </a> <article id="FUNCTION CL+QT:ARRAY-ROW-MAJOR-INDEX"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AARRAY-ROW-MAJOR-INDEX">ARRAY-ROW-MAJOR-INDEX</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ARRAY &REST SUBSCRIPTS</code><code>)</code> </header> <div class="docstring"><i>No docstring provided.</i></div> </article> </li><li> <a name="CL+QT:ARRAY-TOTAL-SIZE"> </a> <article id="FUNCTION CL+QT:ARRAY-TOTAL-SIZE"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AARRAY-TOTAL-SIZE">ARRAY-TOTAL-SIZE</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ARRAY</code><code>)</code> </header> <div class="docstring"><pre>Return the total number of elements in the Array.</pre></div> </article> </li><li> <a name="CL+QT:ARRAYP"> </a> <article id="FUNCTION CL+QT:ARRAYP"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AARRAYP">ARRAYP</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Return true if OBJECT is an ARRAY, and NIL otherwise.</pre></div> </article> </li><li> <a name="CL+QT:ASH"> </a> <article id="FUNCTION CL+QT:ASH"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AASH">ASH</a></code></h4> <code class="qualifiers"></code> <code class="arguments">INTEGER COUNT</code><code>)</code> </header> <div class="docstring"><pre>Shifts integer left by count places preserving sign. - count shifts right.</pre></div> </article> </li><li> <a name="CL+QT:ASIN"> </a> <article id="FUNCTION CL+QT:ASIN"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AASIN">ASIN</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NUMBER</code><code>)</code> </header> <div class="docstring"><pre>Return the arc sine of NUMBER.</pre></div> </article> </li><li> <a name="CL+QT:ASINH"> </a> <article id="FUNCTION CL+QT:ASINH"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AASINH">ASINH</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NUMBER</code><code>)</code> </header> <div class="docstring"><pre>Return the hyperbolic arc sine of NUMBER.</pre></div> </article> </li><li> <a name="CL+QT:ASSOC"> </a> <article id="FUNCTION CL+QT:ASSOC"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AASSOC">ASSOC</a></code></h4> <code class="qualifiers"></code> <code class="arguments">ITEM ALIST &KEY KEY (TEST NIL TESTP) (TEST-NOT NIL NOTP)</code><code>)</code> </header> <div class="docstring"><pre>Return the cons in ALIST whose car is equal (by a given test or EQL) to
the ITEM.</pre></div> </article> </li><li> <a name="CL+QT:ASSOC-IF"> </a> <article id="FUNCTION CL+QT:ASSOC-IF"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AASSOC-IF">ASSOC-IF</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PREDICATE ALIST &KEY KEY</code><code>)</code> </header> <div class="docstring"><pre>Return the first cons in ALIST whose CAR satisfies PREDICATE. If
KEY is supplied, apply it to the CAR of each cons before testing.</pre></div> </article> </li><li> <a name="CL+QT:ASSOC-IF-NOT"> </a> <article id="FUNCTION CL+QT:ASSOC-IF-NOT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AASSOC-IF-NOT">ASSOC-IF-NOT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">PREDICATE ALIST &KEY KEY</code><code>)</code> </header> <div class="docstring"><pre>Return the first cons in ALIST whose CAR does not satisfy PREDICATE.
If KEY is supplied, apply it to the CAR of each cons before testing.</pre></div> </article> </li><li> <a name="CL+QT:ATAN"> </a> <article id="FUNCTION CL+QT:ATAN"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AATAN">ATAN</a></code></h4> <code class="qualifiers"></code> <code class="arguments">Y &OPTIONAL (X NIL XP)</code><code>)</code> </header> <div class="docstring"><pre>Return the arc tangent of Y if X is omitted or Y/X if X is supplied.</pre></div> </article> </li><li> <a name="CL+QT:ATANH"> </a> <article id="FUNCTION CL+QT:ATANH"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AATANH">ATANH</a></code></h4> <code class="qualifiers"></code> <code class="arguments">NUMBER</code><code>)</code> </header> <div class="docstring"><pre>Return the hyperbolic arc tangent of NUMBER.</pre></div> </article> </li><li> <a name="CL+QT:ATOM"> </a> <article id="FUNCTION CL+QT:ATOM"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3AATOM">ATOM</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Return true if OBJECT is an ATOM, and NIL otherwise.</pre></div> </article> </li><li> <a name="CL+QT:BIT-AND"> </a> <article id="FUNCTION CL+QT:BIT-AND"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3ABIT-AND">BIT-AND</a></code></h4> <code class="qualifiers"></code> <code class="arguments">BIT-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY</code><code>)</code> </header> <div class="docstring"><pre>Perform a bit-wise LOGAND on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,
putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,
BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is
created. All the arrays must have the same rank and dimensions.</pre></div> </article> </li><li> <a name="CL+QT:BIT-ANDC1"> </a> <article id="FUNCTION CL+QT:BIT-ANDC1"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3ABIT-ANDC1">BIT-ANDC1</a></code></h4> <code class="qualifiers"></code> <code class="arguments">BIT-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY</code><code>)</code> </header> <div class="docstring"><pre>Perform a bit-wise LOGANDC1 on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,
putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,
BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is
created. All the arrays must have the same rank and dimensions.</pre></div> </article> </li><li> <a name="CL+QT:BIT-ANDC2"> </a> <article id="FUNCTION CL+QT:BIT-ANDC2"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3ABIT-ANDC2">BIT-ANDC2</a></code></h4> <code class="qualifiers"></code> <code class="arguments">BIT-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY</code><code>)</code> </header> <div class="docstring"><pre>Perform a bit-wise LOGANDC2 on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,
putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,
BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is
created. All the arrays must have the same rank and dimensions.</pre></div> </article> </li><li> <a name="CL+QT:BIT-EQV"> </a> <article id="FUNCTION CL+QT:BIT-EQV"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3ABIT-EQV">BIT-EQV</a></code></h4> <code class="qualifiers"></code> <code class="arguments">BIT-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY</code><code>)</code> </header> <div class="docstring"><pre>Perform a bit-wise LOGEQV on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,
putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,
BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is
created. All the arrays must have the same rank and dimensions.</pre></div> </article> </li><li> <a name="CL+QT:BIT-IOR"> </a> <article id="FUNCTION CL+QT:BIT-IOR"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3ABIT-IOR">BIT-IOR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">BIT-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY</code><code>)</code> </header> <div class="docstring"><pre>Perform a bit-wise LOGIOR on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,
putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,
BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is
created. All the arrays must have the same rank and dimensions.</pre></div> </article> </li><li> <a name="CL+QT:BIT-NAND"> </a> <article id="FUNCTION CL+QT:BIT-NAND"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3ABIT-NAND">BIT-NAND</a></code></h4> <code class="qualifiers"></code> <code class="arguments">BIT-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY</code><code>)</code> </header> <div class="docstring"><pre>Perform a bit-wise LOGNAND on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,
putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,
BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is
created. All the arrays must have the same rank and dimensions.</pre></div> </article> </li><li> <a name="CL+QT:BIT-NOR"> </a> <article id="FUNCTION CL+QT:BIT-NOR"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3ABIT-NOR">BIT-NOR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">BIT-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY</code><code>)</code> </header> <div class="docstring"><pre>Perform a bit-wise LOGNOR on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,
putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,
BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is
created. All the arrays must have the same rank and dimensions.</pre></div> </article> </li><li> <a name="CL+QT:BIT-NOT"> </a> <article id="FUNCTION CL+QT:BIT-NOT"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3ABIT-NOT">BIT-NOT</a></code></h4> <code class="qualifiers"></code> <code class="arguments">BIT-ARRAY &OPTIONAL RESULT-BIT-ARRAY</code><code>)</code> </header> <div class="docstring"><pre>Performs a bit-wise logical NOT on the elements of BIT-ARRAY,
putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,
BIT-ARRAY is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is
created. Both arrays must have the same rank and dimensions.</pre></div> </article> </li><li> <a name="CL+QT:BIT-ORC1"> </a> <article id="FUNCTION CL+QT:BIT-ORC1"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3ABIT-ORC1">BIT-ORC1</a></code></h4> <code class="qualifiers"></code> <code class="arguments">BIT-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY</code><code>)</code> </header> <div class="docstring"><pre>Perform a bit-wise LOGORC1 on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,
putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,
BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is
created. All the arrays must have the same rank and dimensions.</pre></div> </article> </li><li> <a name="CL+QT:BIT-ORC2"> </a> <article id="FUNCTION CL+QT:BIT-ORC2"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3ABIT-ORC2">BIT-ORC2</a></code></h4> <code class="qualifiers"></code> <code class="arguments">BIT-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY</code><code>)</code> </header> <div class="docstring"><pre>Perform a bit-wise LOGORC2 on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,
putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,
BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is
created. All the arrays must have the same rank and dimensions.</pre></div> </article> </li><li> <a name="CL+QT:BIT-VECTOR-P"> </a> <article id="FUNCTION CL+QT:BIT-VECTOR-P"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3ABIT-VECTOR-P">BIT-VECTOR-P</a></code></h4> <code class="qualifiers"></code> <code class="arguments">OBJECT</code><code>)</code> </header> <div class="docstring"><pre>Return true if OBJECT is a BIT-VECTOR, and NIL otherwise.</pre></div> </article> </li><li> <a name="CL+QT:BIT-XOR"> </a> <article id="FUNCTION CL+QT:BIT-XOR"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3ABIT-XOR">BIT-XOR</a></code></h4> <code class="qualifiers"></code> <code class="arguments">BIT-ARRAY-1 BIT-ARRAY-2 &OPTIONAL RESULT-BIT-ARRAY</code><code>)</code> </header> <div class="docstring"><pre>Perform a bit-wise LOGXOR on the elements of BIT-ARRAY-1 and BIT-ARRAY-2,
putting the results in RESULT-BIT-ARRAY. If RESULT-BIT-ARRAY is T,
BIT-ARRAY-1 is used. If RESULT-BIT-ARRAY is NIL or omitted, a new array is
created. All the arrays must have the same rank and dimensions.</pre></div> </article> </li><li> <a name="CL+QT:BLOCK"> </a> <article id="FUNCTION CL+QT:BLOCK"> <header class="function"> <span class="type">function</span> <code>(</code><h4 class="name"><code><a href="#FUNCTION%20CL%2BQT%3ABLOCK">BLOCK</a></code></h4> <code class="qualifiers"></code> <code class="arguments">&REST ARGS</code><code>)</code> </header> <div class="docstring"><pre>BLOCK name form*
Evaluate the FORMS as a PROGN. Within the lexical scope of the body,