This is the qtools Reference Manual, version 1.2.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Sun Dec 08 19:16:33 2024 GMT+0.
qtools/qtools.asd
qtools/package.lisp
qtools/toolkit.lisp
qtools/class-map.lisp
qtools/name-translation.lisp
qtools/dispatch.lisp
qtools/finalizable.lisp
qtools/gc-finalized.lisp
qtools/copying.lisp
qtools/printing.lisp
qtools/signal.lisp
qtools/widget.lisp
qtools/widget-defmethod.lisp
qtools/widget-convenience.lisp
qtools/widget-menu.lisp
qtools/readtable.lisp
qtools/generate.lisp
qtools/dynamic.lisp
qtools/precompile.lisp
qtools/deploy.lisp
qtools/fast-call.lisp
qtools/documentation.lisp
The main system appears first, followed by any subsystem dependency.
qtools
A collection of tools to aid in development with CommonQt.
Nicolas Hafner <shinmera@tymoon.eu>
Nicolas Hafner <shinmera@tymoon.eu>
(GIT https://github.com/Shinmera/qtools.git)
zlib
1.2.0
qt+libs
(system).
deploy
(system).
cl-ppcre
(system).
closer-mop
(system).
form-fiddle
(system).
named-readtables
(system).
trivial-indent
(system).
trivial-garbage
(system).
trivial-main-thread
(system).
documentation-utils
(system).
package.lisp
(file).
toolkit.lisp
(file).
class-map.lisp
(file).
name-translation.lisp
(file).
dispatch.lisp
(file).
finalizable.lisp
(file).
gc-finalized.lisp
(file).
copying.lisp
(file).
printing.lisp
(file).
signal.lisp
(file).
widget.lisp
(file).
widget-defmethod.lisp
(file).
widget-convenience.lisp
(file).
widget-menu.lisp
(file).
readtable.lisp
(file).
generate.lisp
(file).
dynamic.lisp
(file).
precompile.lisp
(file).
deploy.lisp
(file).
fast-call.lisp
(file).
documentation.lisp
(file).
Files are sorted by type and then listed depth-first from the systems components trees.
qtools/qtools.asd
qtools/package.lisp
qtools/toolkit.lisp
qtools/class-map.lisp
qtools/name-translation.lisp
qtools/dispatch.lisp
qtools/finalizable.lisp
qtools/gc-finalized.lisp
qtools/copying.lisp
qtools/printing.lisp
qtools/signal.lisp
qtools/widget.lisp
qtools/widget-defmethod.lisp
qtools/widget-convenience.lisp
qtools/widget-menu.lisp
qtools/readtable.lisp
qtools/generate.lisp
qtools/dynamic.lisp
qtools/precompile.lisp
qtools/deploy.lisp
qtools/fast-call.lisp
qtools/documentation.lisp
qtools/toolkit.lisp
package.lisp
(file).
qtools
(system).
capitalize-on
(function).
compilation-note
(condition).
default-application-name
(function).
do-layout
(macro).
emit-compilation-note
(function).
ensure-class
(function).
ensure-qapplication
(function).
ensure-qclass
(function).
ensure-qobject
(function).
enumerate-method-descriptors
(function).
find-child
(function).
find-children
(function).
fuse-alists
(function).
fuse-plists
(function).
map-layout
(function).
maybe-delete-qobject
(function).
parent
(generic function).
(setf parent)
(method).
(setf parent)
(method).
qclass=case
(macro).
qobject-alive-p
(function).
qtenumcase
(macro).
qtypecase
(macro).
split
(function).
sweep-layout
(function).
to-qbyte-array
(function).
value
(generic function).
(setf value)
(generic function).
with-all-slots-bound
(macro).
with-main-window
(macro).
with-slots-bound
(macro).
*application-name*
(special variable).
ensure-cl-function-name
(function).
ensure-completable-qclass
(function).
ensure-list
(function).
main-window-exec
(function).
maybe-unwrap-quote
(function).
message
(reader method).
(setf message)
(writer method).
named-lambda
(macro).
with-compile-and-run
(macro).
with-traps-masked
(macro).
qtools/class-map.lisp
toolkit.lisp
(file).
qtools
(system).
*qt-class-map*
(special variable).
*qt-class-vector*
(special variable).
eqt-class-name
(function).
find-qt-class-name
(function).
repopulate-class-map
(function).
qtools/name-translation.lisp
class-map.lisp
(file).
qtools
(system).
cl-type-for
(function).
define-1->1-translator
(macro).
define-simple-translator
(macro).
define-translator
(macro).
determined-type-method-name
(function).
ecl-type-for
(function).
eqt-type-of
(function).
qt-type-for
(function).
qt-type-of
(function).
specified-type-method-name
(function).
to-method-name
(function).
to-type-name
(function).
translate-name
(function).
%determined-type-method-name-arg
(function).
%specified-type-method-name-arg
(function).
*translators*
(special variable).
name
(reader method).
(setf name)
(writer method).
priority
(reader method).
(setf priority)
(writer method).
remove-translator
(function).
substring-type-p
(function).
translation
(reader method).
(setf translation)
(writer method).
translator
(function).
(setf translator)
(function).
translator
(class).
unknown-type-name
(condition).
qtools/dispatch.lisp
name-translation.lisp
(file).
qtools
(system).
define-qclass-dispatch-function
(macro).
direct-qsubclass-p
(function).
dispatch-by-qclass
(function).
qclass-precedence-list
(function).
qinstancep
(function).
*qclass-precedence-list*
(special variable).
*qclass-precedence-lists*
(special variable).
compute-qclass-precedence-list
(function).
generate-qclass-dispatch-lambda
(function).
qclass-class-list
(function).
qclass-precedence-set
(function).
qtools/finalizable.lisp
dispatch.lisp
(file).
qtools
(system).
compute-effective-slot-definition
(method).
define-finalizable
(macro).
define-finalize-method
(macro).
describe-finalize-method
(function).
direct-slot-definition-class
(method).
effective-slot-definition-class
(method).
finalizable
(class).
finalizable-class
(class).
finalizable-slot
(class).
finalize
(generic function).
finalize-qobject
(function).
finalized
(reader method).
print-object
(method).
validate-superclass
(method).
validate-superclass
(method).
validate-superclass
(method).
validate-superclass
(method).
with-finalizing
(macro).
with-finalizing*
(macro).
%build-with-finalizing-construct
(function).
*qclass-finalize-functions*
(special variable).
define-qclass-finalize-function
(macro).
finalizable-direct-slot-definition
(class).
finalizable-effective-slot-definition
(class).
normalize-bindings
(function).
qclass-finalize-function
(function).
(setf qclass-finalize-function)
(function).
remove-qclass-finalize-function
(function).
qtools/gc-finalized.lisp
finalizable.lisp
(file).
qtools
(system).
gc-finalized
(class).
initialize-instance
(method).
make-gc-finalized
(function).
print-object
(method).
unbox
(reader method).
with-gc-finalized
(macro).
qtools/copying.lisp
gc-finalized.lisp
(file).
qtools
(system).
copy
(generic function).
copy-qobject
(function).
define-copy-method
(macro).
describe-copy-method
(function).
*qclass-copy-functions*
(special variable).
define-qclass-copy-function
(macro).
qclass-copy-function
(function).
(setf qclass-copy-function)
(function).
remove-qclass-copy-function
(function).
qtools/printing.lisp
copying.lisp
(file).
qtools
(system).
define-print-method
(macro).
describe-print-method
(function).
print-qobject
(function).
*qclass-print-functions*
(special variable).
define-qclass-print-function
(macro).
print-unreadable-qobject
(macro).
qclass-print-function
(function).
(setf qclass-print-function)
(function).
remove-qclass-print-function
(function).
qtools/signal.lisp
printing.lisp
(file).
qtools
(system).
connect!
(macro).
define-signal-method
(macro).
disconnect!
(macro).
generic-signal
(compiler macro).
generic-signal
(function).
signal!
(macro).
process-list-arg
(function).
signal-method-for-name
(function).
qtools/widget.lisp
signal.lisp
(file).
qtools
(system).
call-finalizers
(function).
call-initializers
(function).
clashing-qt-superclass
(reader method).
(setf clashing-qt-superclass)
(writer method).
clashing-superclass
(reader method).
(setf clashing-superclass)
(writer method).
construct
(generic function).
define-object
(macro).
define-widget
(macro).
finalize
(method).
finalize-inheritance
(method).
initialize-instance
(method).
initialize-instance
(method).
invalid-qt-superclass-hierarchy
(condition).
reinitialize-instance
(method).
remove-widget-class-option
(function).
requested-qt-superclass
(reader method).
(setf requested-qt-superclass)
(writer method).
set-widget-class-option
(function).
softly-redefine-widget-class
(function).
value
(method).
(setf value)
(method).
widget
(class).
widget-class
(class).
widget-class-direct-options
(reader method).
(setf widget-class-direct-options)
(writer method).
widget-class-extern-options
(reader method).
(setf widget-class-extern-options)
(writer method).
widget-class-finalizers
(reader method).
(setf widget-class-finalizers)
(writer method).
widget-class-initializers
(reader method).
(setf widget-class-initializers)
(writer method).
widget-class-option-p
(function).
cascade-option-changes
(function).
check-qt-superclass-compatibility
(function).
set-effective-option
(function).
setup-widget-class
(function).
widget-class-direct-finalizers
(reader method).
(setf widget-class-direct-finalizers)
(writer method).
widget-class-direct-initializers
(reader method).
(setf widget-class-direct-initializers)
(writer method).
qtools/widget-defmethod.lisp
widget.lisp
(file).
qtools
(system).
*method*
(special variable).
define-method-declaration
(macro).
defmethod
(macro).
method-declaration
(function).
(setf method-declaration)
(function).
remove-method-declaration
(function).
with-widget-class
(macro).
*method-declarations*
(special variable).
slot-initializer-symbol
(function).
qtools/widget-convenience.lisp
widget-defmethod.lisp
(file).
qtools
(system).
define-finalizer
(macro).
define-initializer
(macro).
define-override
(macro).
define-signal
(macro).
define-slot
(macro).
define-subobject
(macro).
define-subwidget
(macro).
remove-finalizer
(function).
remove-initializer
(function).
remove-override
(function).
remove-signal
(function).
remove-slot
(function).
remove-subwidget
(function).
%make-slots-bound-proper
(function).
subwidget-initializer-symbol
(function).
qtools/readtable.lisp
widget-menu.lisp
(file).
qtools
(system).
make-reader-for-function
(function).
qtools/generate.lisp
readtable.lisp
(file).
qtools
(system).
*generated-modules*
(special variable).
*operator-map*
(special variable).
*qmethods*
(special variable).
*smoke-modules*
(special variable).
*target-package*
(special variable).
clear-method-info
(function).
compile-wrapper
(function).
ensure-methods-processed
(function).
load-all-smoke-modules
(function).
loaded-smoke-modules
(function).
map-compile-all
(function).
method-symbol
(function).
process-all-methods
(function).
process-method
(function).
q+apropos
(function).
%method-see
(function).
cl-constant-name
(function).
cl-constructor-name
(function).
cl-method-name
(function).
cl-operator-name
(function).
cl-static-method-name
(function).
cl-variable-name
(function).
clean-method-name
(function).
compile-constant
(function).
compile-constructor
(function).
compile-method
(function).
compile-operator
(function).
compile-static-method
(function).
define-extern-inline-fun
(macro).
define-extern-macro
(macro).
define-qt-constant
(macro).
emit-operator-call
(function).
ensure-methods
(function).
generate-constant-docstring
(function).
generate-method-docstring
(function).
method-needed-p
(function).
qmethod-bogus-p
(function).
qmethod-cast-operator-p
(function).
qmethod-globalspace-p
(function).
qmethod-operator-p
(function).
qmethod-translatable-operator-p
(function).
string-starts-with-p
(function).
target-symbol
(function).
with-args
(macro).
with-output-to-target-symbol
(macro).
write-qclass-name
(function).
write-qmethod-name
(function).
qtools/dynamic.lisp
generate.lisp
(file).
qtools
(system).
defgeneric
(macro).
defun
(macro).
ensure-q+-method
(function).
fdefinition
(function).
(setf fdefinition)
(function).
fsetf
(macro).
function
(macro).
function
(type).
q+
(macro).
q+fun
(macro).
setf
(macro).
*standard-function-reader*
(special variable).
*standard-paren-reader*
(special variable).
process-q+-setter
(function).
q+-symbol-name
(function).
q+-symbol-p
(function).
read-function
(function).
read-list-until
(function).
read-name
(function).
read-paren
(function).
target-package-symbol-string
(function).
to-readtable-case
(function).
qtools/precompile.lisp
dynamic.lisp
(file).
qtools
(system).
q+-compile-and-load
(function).
write-everything-to-file
(function).
write-forms
(function).
qtools/deploy.lisp
precompile.lisp
(file).
qtools
(system).
*boot-hooks*
(special variable).
*build-hooks*
(special variable).
*deployment-location*
(special variable).
*quit-hooks*
(special variable).
*smoke-modules-to-reload*
(special variable).
discover-entry-point
(method).
perform
(method).
qt-program-op
(class).
qtools-library-p
(function).
qtools/fast-call.lisp
deploy.lisp
(file).
qtools
(system).
fast-call
(macro).
fast-direct-call
(macro).
fast-static-call
(macro).
find-fastcall-method
(function).
with-call-stack
(macro).
find-fastcall-static-method
(function).
qtools/documentation.lisp
fast-call.lisp
(file).
qtools
(system).
Packages are listed by definition order.
qtools
org.shirakumo.qtools
common-lisp
.
qt
.
*boot-hooks*
(special variable).
*build-hooks*
(special variable).
*deployment-location*
(special variable).
*generated-modules*
(special variable).
*method*
(special variable).
*operator-map*
(special variable).
*qmethods*
(special variable).
*qt-class-map*
(special variable).
*qt-class-vector*
(special variable).
*quit-hooks*
(special variable).
*smoke-modules*
(special variable).
*smoke-modules-to-reload*
(special variable).
*target-package*
(special variable).
*widget*
(special variable).
build-menu-content
(function).
call-finalizers
(function).
call-initializers
(function).
capitalize-on
(function).
cl-type-for
(function).
clashing-qt-superclass
(generic reader).
(setf clashing-qt-superclass)
(generic writer).
clashing-superclass
(generic reader).
(setf clashing-superclass)
(generic writer).
clear-method-info
(function).
compilation-note
(condition).
compile-wrapper
(function).
connect!
(macro).
construct
(generic function).
copy
(generic function).
copy-qobject
(function).
default-application-name
(function).
define-1->1-translator
(macro).
define-copy-method
(macro).
define-finalizable
(macro).
define-finalize-method
(macro).
define-finalizer
(macro).
define-initializer
(macro).
define-menu
(macro).
define-menu-content-type
(macro).
define-method-declaration
(macro).
define-object
(macro).
define-override
(macro).
define-print-method
(macro).
define-qclass-dispatch-function
(macro).
define-signal
(macro).
define-signal-method
(macro).
define-simple-translator
(macro).
define-slot
(macro).
define-subobject
(macro).
define-subwidget
(macro).
define-translator
(macro).
define-widget
(macro).
describe-copy-method
(function).
describe-finalize-method
(function).
describe-print-method
(function).
determined-type-method-name
(function).
direct-qsubclass-p
(function).
disconnect!
(macro).
dispatch-by-qclass
(function).
do-layout
(macro).
ecl-type-for
(function).
emit-compilation-note
(function).
ensure-class
(function).
ensure-methods-processed
(function).
ensure-q+-method
(function).
ensure-qapplication
(function).
ensure-qclass
(function).
ensure-qobject
(function).
enumerate-method-descriptors
(function).
eqt-class-name
(function).
eqt-type-of
(function).
fast-call
(macro).
fast-direct-call
(macro).
fast-static-call
(macro).
finalizable
(class).
finalizable-class
(class).
finalizable-slot
(class).
finalize
(generic function).
finalize-qobject
(function).
finalized
(generic reader).
find-child
(function).
find-children
(function).
find-fastcall-method
(function).
find-qt-class-name
(function).
fsetf
(macro).
fuse-alists
(function).
fuse-plists
(function).
gc-finalized
(class).
generic-signal
(compiler macro).
generic-signal
(function).
invalid-qt-superclass-hierarchy
(condition).
load-all-smoke-modules
(function).
loaded-smoke-modules
(function).
make-chord
(function).
make-gc-finalized
(function).
map-compile-all
(function).
map-layout
(function).
maybe-delete-qobject
(function).
menu-content-type
(function).
(setf menu-content-type)
(function).
method-declaration
(function).
(setf method-declaration)
(function).
method-symbol
(function).
parent
(generic function).
(setf parent)
(generic function).
print-qobject
(function).
process-all-methods
(function).
process-method
(function).
q+
(macro).
q+-compile-and-load
(function).
q+apropos
(function).
q+fun
(macro).
qclass-precedence-list
(function).
qclass=case
(macro).
qinstancep
(function).
qobject-alive-p
(function).
qt-program-op
(class).
qt-type-for
(function).
qt-type-of
(function).
qtenumcase
(macro).
qtypecase
(macro).
remove-finalizer
(function).
remove-initializer
(function).
remove-menu-content-type
(function).
remove-method-declaration
(function).
remove-override
(function).
remove-signal
(function).
remove-slot
(function).
remove-subwidget
(function).
remove-widget-class-option
(function).
requested-qt-superclass
(generic reader).
(setf requested-qt-superclass)
(generic writer).
set-widget-class-option
(function).
signal!
(macro).
softly-redefine-widget-class
(function).
specified-type-method-name
(function).
split
(function).
sweep-layout
(function).
to-method-name
(function).
to-qbyte-array
(function).
to-type-name
(function).
translate-name
(function).
unbox
(generic reader).
value
(generic function).
(setf value)
(generic function).
widget
(class).
widget-actions
(function).
(setf widget-actions)
(function).
widget-class
(class).
widget-class-direct-options
(generic reader).
(setf widget-class-direct-options)
(generic writer).
widget-class-extern-options
(generic reader).
(setf widget-class-extern-options)
(generic writer).
widget-class-finalizers
(generic reader).
(setf widget-class-finalizers)
(generic writer).
widget-class-initializers
(generic reader).
(setf widget-class-initializers)
(generic writer).
widget-class-option-p
(function).
with-all-slots-bound
(macro).
with-call-stack
(macro).
with-finalizing
(macro).
with-finalizing*
(macro).
with-gc-finalized
(macro).
with-main-window
(macro).
with-slots-bound
(macro).
with-widget-class
(macro).
write-everything-to-file
(function).
%build-with-finalizing-construct
(function).
%determined-type-method-name-arg
(function).
%make-slots-bound-proper
(function).
%method-see
(function).
%specified-type-method-name-arg
(function).
*application-name*
(special variable).
*menu-content-types*
(special variable).
*method-declarations*
(special variable).
*qclass-copy-functions*
(special variable).
*qclass-finalize-functions*
(special variable).
*qclass-precedence-list*
(special variable).
*qclass-precedence-lists*
(special variable).
*qclass-print-functions*
(special variable).
*standard-function-reader*
(special variable).
*standard-paren-reader*
(special variable).
*translators*
(special variable).
*widget-actions*
(special variable).
cascade-option-changes
(function).
check-qt-superclass-compatibility
(function).
cl-constant-name
(function).
cl-constructor-name
(function).
cl-method-name
(function).
cl-operator-name
(function).
cl-static-method-name
(function).
cl-variable-name
(function).
clean-method-name
(function).
compile-constant
(function).
compile-constructor
(function).
compile-method
(function).
compile-operator
(function).
compile-static-method
(function).
compute-qclass-precedence-list
(function).
define-extern-inline-fun
(macro).
define-extern-macro
(macro).
define-qclass-copy-function
(macro).
define-qclass-finalize-function
(macro).
define-qclass-print-function
(macro).
define-qt-constant
(macro).
emit-operator-call
(function).
ensure-cl-function-name
(function).
ensure-completable-qclass
(function).
ensure-list
(function).
ensure-methods
(function).
finalizable-direct-slot-definition
(class).
finalizable-effective-slot-definition
(class).
find-fastcall-static-method
(function).
generate-constant-docstring
(function).
generate-method-docstring
(function).
generate-qclass-dispatch-lambda
(function).
main-window-exec
(function).
make-reader-for-function
(function).
maybe-unwrap-quote
(function).
message
(generic reader).
(setf message)
(generic writer).
method-needed-p
(function).
name
(generic reader).
(setf name)
(generic writer).
named-lambda
(macro).
normalize-bindings
(function).
print-unreadable-qobject
(macro).
priority
(generic reader).
(setf priority)
(generic writer).
process-list-arg
(function).
process-q+-setter
(function).
q+-symbol-name
(function).
q+-symbol-p
(function).
qclass-class-list
(function).
qclass-copy-function
(function).
(setf qclass-copy-function)
(function).
qclass-finalize-function
(function).
(setf qclass-finalize-function)
(function).
qclass-precedence-set
(function).
qclass-print-function
(function).
(setf qclass-print-function)
(function).
qmethod-bogus-p
(function).
qmethod-cast-operator-p
(function).
qmethod-globalspace-p
(function).
qmethod-operator-p
(function).
qmethod-translatable-operator-p
(function).
qtools-library-p
(function).
read-function
(function).
read-list-until
(function).
read-name
(function).
read-paren
(function).
remove-qclass-copy-function
(function).
remove-qclass-finalize-function
(function).
remove-qclass-print-function
(function).
remove-translator
(function).
repopulate-class-map
(function).
set-effective-option
(function).
setup-widget-class
(function).
signal-method-for-name
(function).
slot-initializer-symbol
(function).
string-starts-with-p
(function).
substring-type-p
(function).
subwidget-initializer-symbol
(function).
target-package-symbol-string
(function).
target-symbol
(function).
to-readtable-case
(function).
translation
(generic reader).
(setf translation)
(generic writer).
translator
(function).
(setf translator)
(function).
translator
(class).
unknown-type-name
(condition).
widget-class-direct-finalizers
(generic reader).
(setf widget-class-direct-finalizers)
(generic writer).
widget-class-direct-initializers
(generic reader).
(setf widget-class-direct-initializers)
(generic writer).
with-args
(macro).
with-compile-and-run
(macro).
with-output-to-target-symbol
(macro).
with-traps-masked
(macro).
write-forms
(function).
write-qclass-name
(function).
write-qmethod-name
(function).
cl+qt
org.shirakumo.qtools+common-lisp
common-lisp
.
qt
.
qtools
.
defgeneric
(macro).
defmethod
(macro).
defun
(macro).
fdefinition
(function).
(setf fdefinition)
(function).
function
(macro).
function
(type).
setf
(macro).
Definitions are sorted by export status, category, package, and then by lexicographic order.
A list of functions to invoke (in sequence) during the warm-boot.
Use this to run customised startup, prepare, or load functions.
A list of functions to invoke (in sequence) during the build.
Use this to run customised cleanup, compile, or deployment functions.
Variable containing the path to the directory that is being deployed to.
This is bound when *BOOT-HOOKS* functions are called.
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.
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.
A hash-table of C++ operators to CL function names.
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 QTOOLS:PROCESS-METHOD
See QTOOLS:COMPILE-WRAPPER
An EQUALP hash-table of all Qt4.8 class names to themselves as strings.
A vector of all Qt4.8 class names as strings.
A list of functions to invoke (in sequence) when the program quits.
Use this to run customised saving or cleanup functions.
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.
A list of smoke modules that need to be reloaded on boot.
The system sets this variable itself during the build.
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.
Bound to the class-name of the widget during component expansion and bound to the class instance during initialization.
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.
Defines a new generic function.
Identical to CL:DEFGENERIC, but takes care of translating function-names with SETF to use CL:SETF instead of CL+QT:SETF.
See CL:DEFGENERIC.
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 DEFINE-SIMPLE-TRANSLATOR
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 COPY-QOBJECT
Shorthand around DEFCLASS to create a finalizable class.
Automatically adds FINALIZABLE as direct-superclass and FINALIZABLE-CLASS as metaclass.
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 FINALIZE
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 CL+QT:DEFMETHOD
See QTOOLS:WITH-SLOTS-BOUND
See QTOOLS:FINALIZE
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 CL+QT:DEFMETHOD
See QTOOLS:WITH-SLOTS-BOUND
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 QTOOLS:MAKE-CHORD.
Define a new method declaration function of NAME.
See (SETF QTOOLS:METHOD-DECLARATION).
Alias for DEFINE-WIDGET.
This is merely here for clarity.
See QTOOLS:DEFINE-WIDGET
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 CL+QT:DEFMETHOD
See QTOOLS:WITH-SLOTS-BOUND
See CommonQt/override
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 PRINT-OBJECT
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 GENERATE-QCLASS-DISPATCH-LAMBDA
See DISPATCH-BY-QCLASS
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 CommonQt/signals
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.
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 DEFINE-TRANSLATOR
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 QTOOLS:CL-TYPE-FOR
See CL+QT:DEFMETHOD
See QTOOLS:WITH-SLOTS-BOUND
See CommonQt/slots
Alias for DEFINE-SUBWIDGET
This is merely here for clarity.
See QTOOLS:DEFINE-SUBOBJECT
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 QTOOLS:DEFINE-INITIALIZER
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 TRANSLATOR
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.
Defines a new method.
This is identical to CL:DEFMETHOD with one exception:
The only difference is that declarations are scanned and
potentially specially processed. If a declaration is
recognised through METHOD-DECLARATION, it is taken out of
the method definition. The declaration processor function
then may or may not cause side-effects or spit out
additional forms to be output alongside the CL:DEFMETHOD
form.
See CL:DEFMETHOD.
See QTOOLS:METHOD-DECLARATION.
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.
Iterate over all WIDGETs on LAYOUT.
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.
METHOD-DESCRIPTOR ::= (name class-name ret-type? 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.
Finally, if ret-type is not NIL, it retrieves the return value by calling the
corresponding unmarshaller on the stack.
See FIND-FASTCALL-METHOD
See FAST-DIRECT-CALL
See WITH-CALL-STACK
See FAST-STATIC-CALL
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 WITH-CALL-STACK
See FAST-CALL
Performs a fast call on a given static 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.
METHOD-DESCRIPTOR ::= (name ret-type? arg-type*)
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.
At compile time a matching method number is searched for using
FIND-FASTCALL-STATIC-METHOD. If no method can be found that matches the 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.
Finally, if ret-type is not NIL, it retrieves the return value by calling the
corresponding unmarshaller on the stack.
See FIND-FASTCALL-STATIC-METHOD
See FAST-DIRECT-CALL
See WITH-CALL-STACK
See FAST-CALL
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.
Defines a new function.
Identical to CL:DEFUN, but takes care of translating function-names
with SETF to use CL:SETF instead of CL+QT:SETF.
See CL:DEFUN.
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 QTOOLS:ENSURE-Q+-METHOD
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 QTOOLS:ENSURE-Q+-METHOD
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.
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
Analogous to CL:TYPECASE, but for Qt classes.
See QINSTANCEP
A wrapper around CL:SETF that specially handles calls to Q+ functions.
If a place is a Q+ form, or a form calling a symbol from *TARGET-PACKAGE*,
it is translated to a proper setter call using PROCESS-Q+-SETTER. Any other
place and value pair is translated to a normal CL:SETF call.
The order of places and values is preserved.
See QTOOLS:Q+
See QTOOLS:PROCESS-Q+-SETTER
See QTOOLS:*TARGET-PACKAGE*
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.
Turns into a WITH-SLOTS with all slots of CLASS. Class is resolved as per ENSURE-CLASS.
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 FAST-DIRECT-CALL
See FAST-CALL
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.
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.
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.
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.
Turns into a WITH-SLOTS with all direct-slots of CLASS. Class is resolved as per ENSURE-CLASS.
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.
Calls the appropriate function to parse menu content of TYPE.
See (SETF QTOOLS:MENU-CONTENT-TYPE).
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.
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.
Attempts to determine the CL type for the given Qt type descriptor.
Look at the source to see the mappings.
Clears the *QMETHODS* table.
See QTOOLS:*QMETHODS*
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 QTOOLS:ENSURE-METHODS
See QT:QMETHOD-ENUM-P
See QTOOLS:COMPILE-CONSTANT
See QT:QMETHOD-CTOR-P
See QT:QMETHOD-COPYCTOR-P
See QTOOLS:COMPILE-CONSTRUCTOR
See QTOOLS:QMETHOD-OPERATOR-P
See QTOOLS:COMPILE-OPERATOR
See QT:QMETHOD-STATIC-P
See QTOOLS:COMPILE-STATIC-METHOD
See QTOOLS:COMPILE-METHOD
Attempts to find and return a default name to use for the application.
Prints information about the copy method for the specified class if possible.
Prints information about the finalize method for the given class if possible.
Prints information about the print method for the specified class if possible.
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.
Returns T if MAYBE-SUPERCLASS is a direct superclass of QCLASS.
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 QCLASS-PRECEDENCE-LIST
Same as CL-TYPE-FOR, but signals an error if no matching type could be found.
Ensures to return a CLASS. SYMBOL -> FIND-CLASS CLASS -> IDENTITY STANDARD-OBJECT -> CLASS-OF
Ensures that all methods have been generated for the currently loaded smoke modules.
See QTOOLS:LOADED-SMOKE-MODULES
See QTOOLS:*GENERATED-MODULES*
See QTOOLS:PROCESS-ALL-METHODS
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 QTOOLS:ENSURE-METHODS-PROCESSED
See QTOOLS:COMPILE-WRAPPER
See QTOOLS:*TARGET-PACKAGE*
Ensures that the QT:*QAPPLICATION* is available, potentially using NAME and ARGS to initialize it.
See QT:*QAPPLICATION*
See QT:ENSURE-SMOKE
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.
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)")
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.
Same as QT-TYPE-OF, but signals an error if no matching type could be found.
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 CL:FDEFINITION.
Find the first child that is an instance of CHILD-CLASS
See FIND-CHILDREN
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 QINSTANCEP
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 FAST-CALL
See ENSURE-Q+-METHOD
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 *QT-CLASS-MAP*
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.
Loads all the smoke modules as passed.
See QT:ENSURE-SMOKE
Returns a fresh list of currently loaded smoke modules.
See QTOOLS:*SMOKE-MODULES*
See QT:NAMED-MODULE-NUMBER
Transforms CHORD into a keychord string, if possible.
Wrap the OBJECT in a GC-FINALIZED instance. Use UNBOX to retrieve the object again.
Calls FUNCTION with the result of COMPILE-WRAPPER on all available methods.
See QTOOLS:COMPILE-WRAPPER
See QTOOLS:*QMETHODS*
Map all widgets and layouts on LAYOUT onto FUNCTION.
Deletes the object if possible.
Sets the FUNCTION to process menu contents of type NAME.
The function should accept in the very least one argument, which is the symbol of the current parent. The other arguments can be used to decompose the remainder of the content form. Expected are two return values, the first being a form to call during initialization and the second being a form to be run alongside the initializer definition.
Returns a function to process the method declaration NAME, if one exists.
See (SETF QTOOLS:METHOD-DECLARATION).
Sets the FUNCTION to be used to process method declarations of NAME.
The arguments of the function should parse the inner of the declaration.
E.g: (declare (foo bar baz)) could be captured by (a &optional b) with
A=>BAR, B=>BAZ. During evaluation of the function, the special variable
*METHOD* will be bound.
See QTOOLS:*METHOD*.
Returns an appropriate symbol to use for the name of the wrapper function for METHOD.
See QT:QMETHOD-ENUM-P
See QTOOLS:CL-CONSTANT-NAME
See QT:QMETHOD-CTOR-P
See QT:QMETHOD-COPYCTOR-P
See QTOOLS:CL-CONSTRUCTOR-NAME
See QTOOLS:QMETHOD-OPERATOR-P
See QTOOLS:CL-OPERATOR-NAME
See QT:QMETHOD-STATIC-P
See QTOOLS:CL-STATIC-METHOD-NAME
See QTOOLS:CL-METHOD-NAME
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 QT:MAP-METHODS
See QTOOLS:PROCESS-METHOD
See QTOOLS:CLEAR-METHOD-INFO
See QTOOLS:*GENERATED-MODULES*
See QTOOLS:LOADED-SMOKE-MODULES
Push the given METHOD onto its appropriate place in the method table, if it is needed.
See QTOOLS:METHOD-NEEDED-P
See QTOOLS:METHOD-SYMBOL
See QTOOLS:*QMETHODS*
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 WRITE-EVERYTHING-TO-FILE
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 QTOOLS:ENSURE-METHODS-PROCESSED
See QTOOLS:*QMETHODS*
Returns the class precedence list for the given qclass.
See *QCLASS-PRECEDENCE-LISTS*
See COMPUTE-QCLASS-PRECEDENCE-LIST
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.
Returns T if the object is not null and not deleted.
Attempts to determine the proper Qt type descriptor for the passed cl type name.
Look at the source to see the mappings.
Attempts to determine a proper Qt type descriptor for the type of the OBJECT.
Look at the source to see the mappings.
Removes the FINALIZER definition from the WIDGET-CLASS.
Note that this does not remove eventual methods associated with the slot.
See QTOOLS:REMOVE-WIDGET-CLASS-OPTION
See QTOOLS:ENSURE-CLASS
Removes the INITIALIZER definition from the WIDGET-CLASS.
Note that this does not remove eventual methods associated with the slot.
See QTOOLS:REMOVE-WIDGET-CLASS-OPTION
See QTOOLS:ENSURE-CLASS
Remove the method declaration processor function of NAME.
Removes the OVERRIDE definition from the WIDGET-CLASS.
Note that this does not remove eventual methods associated with the override.
See QTOOLS:REMOVE-WIDGET-CLASS-OPTION
See QTOOLS:ENSURE-CLASS
Removes the SIGNAL definition from the WIDGET-CLASS.
Note that this does not remove eventual methods associated with the slot.
See QTOOLS:REMOVE-WIDGET-CLASS-OPTION
See QTOOLS:ENSURE-CLASS
Removes the SLOT definition from the WIDGET-CLASS.
Note that this does not remove eventual methods associated with the slot.
See QTOOLS:REMOVE-WIDGET-CLASS-OPTION
See QTOOLS:ENSURE-CLASS
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 QTOOLS:REMOVE-WIDGET-CLASS-OPTION
See QTOOLS:ENSURE-CLASS
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 QTOOLS:WIDGET-CLASS-EXTERN-OPTIONS.
See QTOOLS:SOFTLY-REDEFINE-WIDGET-CLASS.
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 QTOOLS:WIDGET-CLASS-EXTERN-OPTIONS.
See QTOOLS:SOFTLY-REDEFINE-WIDGET-CLASS.
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.
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.
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)))
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.
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
Translates an unsigned-byte 8 vector into a QByteArray.
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.
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 TRANSLATOR
Returns a list of QAction instances that are active on the given CLASS.
Sets the list of QAction instances that are active on the given CLASS.
Tests if OPTION VALUE is already present on CLASS. Returns the full option value if it can be found.
See QTOOLS:SET-WIDGET-CLASS-OPTION
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 QTOOLS:WRITE-FORMS
See QTOOLS:*TARGET-PACKAGE*
invalid-qt-superclass-hierarchy
)) ¶invalid-qt-superclass-hierarchy
)) ¶invalid-qt-superclass-hierarchy
)) ¶invalid-qt-superclass-hierarchy
)) ¶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.
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.
gc-finalized
)) ¶Creates a new GC-Finalized object using the value of COPY on its contained object.
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.
finalizable
)) ¶Finalizes and unbinds all slots on the object that are marked as FINALIZED and then calls the next method.
list
)) ¶Calls the next method and then invokes FINALIZE on all items of the list.
vector
)) ¶Calls the next method and then invokes FINALIZE on all items of the vector.
hash-table
)) ¶Calls the next method and then invokes FINALIZE on all the keys and values of the table.
abstract-qobject
)) ¶Calls the next method and then invokes MAYBE-DELETE-QOBJECT.
qobject
)) ¶finalizable-slot
)) ¶automatically generated reader method
accesses the PARENT of the object. This usually translates to (#_parent object) unless overridden.
qobject
)) ¶invalid-qt-superclass-hierarchy
)) ¶invalid-qt-superclass-hierarchy
)) ¶gc-finalized
)) ¶automatically generated reader method
Accesses the VALUE of the object. This usually translates to (#_value object) unless overridden.
Contains all the options passed to RE/INITIALIZE-INSTANCE when the class is re/initialized directly through a DEFCLASS form.
widget-class
)) ¶automatically generated reader method
widget-class
)) ¶automatically generated writer method
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.
widget-class
)) ¶automatically generated reader method
widget-class
)) ¶automatically generated writer method
A sorted list of functions to be called upon finalization.
This list is overwritten completely whenever the class is re/initialized.
See QTOOLS:CALL-FINALIZERS
widget-class
)) ¶automatically generated reader method
widget-class
)) ¶automatically generated writer method
A sorted list of functions to be called upon initialization.
This list is overwritten completely whenever the class is re/initialized.
See QTOOLS:CALL-INITIALIZERS
widget-class
)) ¶automatically generated reader method
widget-class
)) ¶automatically generated writer method
finalizable-class
) name direct-slots) ¶sb-mop
.
finalizable-class
) &rest initargs) ¶sb-mop
.
qt-program-op
) (c system
)) ¶deploy
.
finalizable-class
) &rest initargs) ¶sb-mop
.
widget-class
)) ¶sb-mop
.
widget-class
) &rest options &key constructor &allow-other-keys) ¶gc-finalized
) &key) ¶qt-program-op
) (c system
)) ¶asdf/action
.
finalizable-slot
) stream) ¶gc-finalized
) stream) ¶widget-class
) &rest options &key constructor &allow-other-keys) ¶finalizable-class
) (superclass finalizable-class
)) ¶sb-mop
.
finalizable-class
) (superclass standard-class
)) ¶sb-mop
.
standard-class
) (superclass finalizable-class
)) ¶sb-mop
.
finalizable-class
) superclass) ¶sb-mop
.
compiler-note
.
(quote (error "message required."))
:message
error
.
:requested-qt-superclass
:clashing-qt-superclass
:clashing-superclass
A class for finalizable objects.
Metaclass for classes with finalizable slots.
standard-class
.
Superclass for slots with a finalized option.
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.
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.
deploy-op
.
Common superclass for all widgets in order to allow for
general initialization and cleanup forms that are standardised across all
widgets.
See QTOOLS:DEFINE-WIDGET.
dynamic-object
.
finalizable
.
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.
finalizable-class
.
qt-class
.
finalize-inheritance
.
initialize-instance
.
reinitialize-instance
.
(setf widget-class-direct-finalizers)
.
widget-class-direct-finalizers
.
(setf widget-class-direct-initializers)
.
widget-class-direct-initializers
.
(setf widget-class-direct-options)
.
widget-class-direct-options
.
(setf widget-class-extern-options)
.
widget-class-extern-options
.
(setf widget-class-finalizers)
.
widget-class-finalizers
.
(setf widget-class-initializers)
.
widget-class-initializers
.
:initializers
:finalizers
Holds a map of computed precedence lists for qclasses.
We can cache this since the Qt class hierarchy is static.
An ordered list of name translators.
See TRANSLATOR
See REMOVE-TRANSLATOR
Shorthand for EXPORT, DECLAIM INLINE, and DEFUN.
Shorthand for EXPORT and DEFMACRO.
Calculates the proper argument list parts required for the given METHODS.
Compiles BODY in a lambda and funcalls it.
Same as WITH-OUTPUT-TO-STRING, but the result is translated to a *TARGET-PACKAGE* symbol.
See QTOOLS:TARGET-SYMBOL
See CL:WITH-OUTPUT-TO-STRING
Check whether the given QT-SUPERCLASS is permissible given the DIRECT-SUPERCLASSES.
Returns a cleaned up name of METHOD.
This effectively trims #, $, and ? from the name.
Calculates the class precedence list for the given qclass as per CLHS 4.3.5
Attempts to return the list of methods associated with METHOD.
METHOD can be a SYMBOL, LIST, FIXNUM, or STRING.
If no methods can be found in the method table, an error is signalled.
Attempts to find a matching method on the class.
This is done by iterating over all methods that match the name, comparing
its argument types, and checking that it is static. 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 FAST-STATIC-CALL
See ENSURE-Q+-METHOD
Generates a docstring for an enum constant.
Generates a docstring that references all the Qt methods that a wrapper function can be used for.
Generates a named-lambda form suitable for usage in a qclass-method.
Specifically, it establishes the appropriate local NEXT-METHOD-P and CALL-NEXT-METHOD functions within the lambda body. Both of them behave exactly like the CLOS ones do– NEXT-METHOD-P returns T if there is a next method that can be dispatched to, and CALL-NEXT-METHOD calls this method if it exists or calls NO-NEXT-METHOD if it does not exist.
If it is a quote form, unwraps the contents. Otherwise returns it directly.
Returns T if the METHOD is considered to be useful for wrapper compilation.
Processes a PLACE and VALUE pair for a Q+ setter call. PLACE should be a form calling the Q+ macro, or a form calling a symbol in the *TARGET-PACKAGE* directly. The name of the function being called is prefixed with "SET-", and is then used to form the function name for the resulting Q+ call. If the VALUE is a VALUES form, then all the parts of values are used as individual arguments in the resulting Q+ call.
Example: (process-q+-setter ’(q+ foo 0 1) ’(values 2 3))
=> (q+ "FOO" 0 1 2 3)
See QTOOLS:Q+
See CL+QT:SETF
See QTOOLS:*TARGET-PACKAGE*
Returns a list containing the given class and all of its transient superclasses.
Builds a class precedence set for the class and all of its transient superclasses.
Returns T if the METHOD is bogus and unneeded.
Returns T if the METHOD is a casting operator.
Returns T if the method is from the QGlobalSpace class.
Returns T if the METHOD is an operator.
Returns T if the operator METHOD is one that can be compiled by Qtools.
Test whether the given CFFI library is a Qtools library.
Removes the translator by the given name.
See TRANSLATOR
See *TRANSLATORS*
This function should not be called directly, but is instead invoked by the appropriate functions such as INITIALIZE-INSTANCE, REINITIALIZE-INSTANCE, and SOFTLY-REDEFINE-WIDGET-CLASS. In brief, it concerns itself with proper option merging and filtering before passing it on to the CommonQt and CLOS methods that process them.
Returns T if the STRING starts with START.
Strings are compared using STRING=
Returns a symbol from the *TARGET-PACKAGE* whose name is formed by
FORMAT-STRING and FORMAT-ARGS.
See QTOOLS:*TARGET-PACKAGE*
See CL:INTERN
See CL:FORMAT
Translates STRING to the requested reading case according to CASE.
See CL:READTABLE-CASE
Accessor to retrieve or update/add a translator function.
The SETF variant takes an additional, optional argument that sets the translator’s priority.
Higher priority numbers get considered first.
See TRANSLATOR
See REMOVE-TRANSLATOR
See DEFINE-TRANSLATOR
See *TRANSLATORS*
Writes all compileable forms to STREAM.
See QTOOLS:MAP-COMPILE-ALL
Writes an appropriate translation of the QCLASS’ name to STREAM.
Translation is as follows:
For every character, its uppercase equivalent is printed to stream,
with the exception of #: which is printed as a #-. Any number of
succeeding #: s is translated to a single #-.
KLUDGE: This approach does not currently take the readtable case into account. This will be problematic on systems where it matters.
See CL:CHAR-UPCASE
Writes an appropriate translation of the QMETHOD’s name to STREAM.
Translation is as follows:
If an uppercase alphabetic character is encountered and the previous
character was not already uppercase, #- is printed. If #_ is
encountered, it is treated as an uppercase character and printed
as #_. A #- would be more "lispy" to use for a #_, but doing so
leads to method name clashes (most notably "set_widget" and
"setWidget"). Any other character is printed as their uppercase
equivalent.
KLUDGE: This approach does not currently take the readtable case into account. This will be problematic on systems where it matters.
See CL:CHAR-UPCASE
compilation-note
)) ¶compilation-note
)) ¶translator
)) ¶automatically generated reader method
name
.
translator
)) ¶automatically generated writer method
name
.
translator
)) ¶automatically generated reader method
translator
)) ¶automatically generated writer method
translator
)) ¶automatically generated reader method
translator
)) ¶automatically generated writer method
widget-class
)) ¶automatically generated reader method
widget-class
)) ¶automatically generated writer method
widget-class
)) ¶automatically generated reader method
widget-class
)) ¶automatically generated writer method
style-warning
.
:type-name
finalizable-slot
.
standard-direct-slot-definition
.
finalizable-slot
.
standard-effective-slot-definition
.
Translator data type class holding the name, priority, and translation function.
See TRANSLATOR
Initarg | Value |
---|---|
:name | (error name required.) |
:translation | (error translation required.) |
:priority | 0 |
:translation
:priority
Jump to: | %
(
B C D E F G I L M N P Q R S T U V W |
---|
Jump to: | %
(
B C D E F G I L M N P Q R S T U V W |
---|
Jump to: | %
*
C D E F I M N P R S T |
---|
Jump to: | %
*
C D E F I M N P R S T |
---|
Jump to: | C D F G I N P Q R S T U W |
---|
Jump to: | C D F G I N P Q R S T U W |
---|