The qtools Reference Manual

3.1.1 qtools/qtools.asd

Source

qtools.asd.

Parent Component

qtools (system).

ASDF Systems

qtools.

---

3.1.2 qtools/package.lisp

Source

qtools.asd.

Parent Component

qtools (system).

Packages

• qtools.
• cl+qt.

---

3.1.3 qtools/toolkit.lisp

Dependency

package.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface

• 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).

Internals

• *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).

---

3.1.4 qtools/class-map.lisp

Dependency

toolkit.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface

• *qt-class-map* (special variable).
• *qt-class-vector* (special variable).
• eqt-class-name (function).
• find-qt-class-name (function).

Internals

repopulate-class-map (function).

---

3.1.5 qtools/name-translation.lisp

Dependency

class-map.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface

• 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).

Internals

• %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).

---

3.1.6 qtools/dispatch.lisp

Dependency

name-translation.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface

• define-qclass-dispatch-function (macro).
• direct-qsubclass-p (function).
• dispatch-by-qclass (function).
• qclass-precedence-list (function).
• qinstancep (function).

Internals

• *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).

---

3.1.7 qtools/finalizable.lisp

Dependency

dispatch.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface

• 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).

Internals

• %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).

---

3.1.8 qtools/gc-finalized.lisp

Dependency

finalizable.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface

• gc-finalized (class).
• initialize-instance (method).
• make-gc-finalized (function).
• print-object (method).
• unbox (reader method).
• with-gc-finalized (macro).

---

3.1.9 qtools/copying.lisp

Dependency

gc-finalized.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface

• copy (generic function).
• copy-qobject (function).
• define-copy-method (macro).
• describe-copy-method (function).

Internals

• *qclass-copy-functions* (special variable).
• define-qclass-copy-function (macro).
• qclass-copy-function (function).
• (setf qclass-copy-function) (function).
• remove-qclass-copy-function (function).

---

3.1.10 qtools/printing.lisp

Dependency

copying.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface

• define-print-method (macro).
• describe-print-method (function).
• print-qobject (function).

Internals

• *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).

---

3.1.11 qtools/signal.lisp

Dependency

printing.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface

• connect! (macro).
• define-signal-method (macro).
• disconnect! (macro).
• generic-signal (compiler macro).
• generic-signal (function).
• signal! (macro).

Internals

• process-list-arg (function).
• signal-method-for-name (function).

---

3.1.12 qtools/widget.lisp

Dependency

signal.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface

• 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).

Internals

• 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).

---

3.1.13 qtools/widget-defmethod.lisp

Dependency

widget.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface

• *method* (special variable).
• define-method-declaration (macro).
• defmethod (macro).
• method-declaration (function).
• (setf method-declaration) (function).
• remove-method-declaration (function).
• with-widget-class (macro).

Internals

• *method-declarations* (special variable).
• slot-initializer-symbol (function).

---

3.1.14 qtools/widget-convenience.lisp

Dependency

widget-defmethod.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface

• 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).

Internals

• %make-slots-bound-proper (function).
• subwidget-initializer-symbol (function).

---

3.1.15 qtools/widget-menu.lisp

Dependency

widget-convenience.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface

• *widget* (special variable).
• build-menu-content (function).
• define-menu (macro).
• define-menu-content-type (macro).
• make-chord (function).
• menu-content-type (function).
• (setf menu-content-type) (function).
• remove-menu-content-type (function).
• widget-actions (function).
• (setf widget-actions) (function).

Internals

• *menu-content-types* (special variable).
• *widget-actions* (special variable).

---

3.1.16 qtools/readtable.lisp

Dependency

widget-menu.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Internals

make-reader-for-function (function).

---

3.1.17 qtools/generate.lisp

Dependency

readtable.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface

• *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).

Internals

• %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).

---

3.1.18 qtools/dynamic.lisp

Dependency

generate.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface

• 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).

Internals

• *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).

---

3.1.19 qtools/precompile.lisp

Dependency

dynamic.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface

• q+-compile-and-load (function).
• write-everything-to-file (function).

Internals

write-forms (function).

---

3.1.20 qtools/deploy.lisp

Dependency

precompile.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface

• *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).

Internals

qtools-library-p (function).

---

3.1.21 qtools/fast-call.lisp

Dependency

deploy.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface

• fast-call (macro).
• fast-direct-call (macro).
• fast-static-call (macro).
• find-fastcall-method (function).
• with-call-stack (macro).

Internals

find-fastcall-static-method (function).

---

3.1.22 qtools/documentation.lisp

Dependency

fast-call.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

---

5.1.1 Special variables

Special Variable: *boot-hooks* ¶

A list of functions to invoke (in sequence) during the warm-boot.

Use this to run customised startup, prepare, or load functions.

Package

qtools.

Source

deploy.lisp.

Special Variable: *build-hooks* ¶

A list of functions to invoke (in sequence) during the build.

Use this to run customised cleanup, compile, or deployment functions.

Package

qtools.

Source

deploy.lisp.

Special Variable: *deployment-location* ¶

Variable containing the path to the directory that is being deployed to.

This is bound when *BOOT-HOOKS* functions are called.

Package

qtools.

Source

deploy.lisp.

Special Variable: *generated-modules* ¶

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.

Package

qtools.

Source

generate.lisp.

Special Variable: *method* ¶

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.

Package

qtools.

Source

widget-defmethod.lisp.

Special Variable: *operator-map* ¶

A hash-table of C++ operators to CL function names.

Package

qtools.

Source

generate.lisp.

Special Variable: *qmethods* ¶

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

Package

qtools.

Source

generate.lisp.

Special Variable: *qt-class-map* ¶

An EQUALP hash-table of all Qt4.8 class names to themselves as strings.

Package

qtools.

Source

class-map.lisp.

Special Variable: *qt-class-vector* ¶

A vector of all Qt4.8 class names as strings.

Package

qtools.

Source

class-map.lisp.

Special Variable: *quit-hooks* ¶

A list of functions to invoke (in sequence) when the program quits.

Use this to run customised saving or cleanup functions.

Package

qtools.

Source

deploy.lisp.

Special Variable: *smoke-modules* ¶

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.

Package

qtools.

Source

generate.lisp.

Special Variable: *smoke-modules-to-reload* ¶

A list of smoke modules that need to be reloaded on boot.

The system sets this variable itself during the build.

Package

qtools.

Source

deploy.lisp.

Special Variable: *target-package* ¶

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.

Package

qtools.

Source

generate.lisp.

Special Variable: *widget* ¶

Bound to the class-name of the widget during component expansion and bound to the class instance during initialization.

Package

qtools.

Source

widget-menu.lisp.

---

5.1.2 Macros

Macro: connect! (origin origin-function target target-function) ¶

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.

Package

qtools.

Source

signal.lisp.

Macro: defgeneric (name args &body options) ¶

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.

Package

cl+qt.

Source

dynamic.lisp.

Macro: define-1->1-translator (type match result &key test priority) ¶

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

Package

qtools.

Source

name-translation.lisp.

Macro: define-copy-method ((instance class) &body body) ¶

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

Package

qtools.

Source

copying.lisp.

Macro: define-finalizable (name direct-superclasses direct-slots &rest options) ¶

Shorthand around DEFCLASS to create a finalizable class.

Automatically adds FINALIZABLE as direct-superclass and FINALIZABLE-CLASS as metaclass.

Package

qtools.

Source

finalizable.lisp.

Macro: define-finalize-method ((instance class) &body body) ¶

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

Package

qtools.

Source

finalizable.lisp.

Macro: define-finalizer ((widget-class method-name &optional priority) &body body) ¶

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

Package

qtools.

Source

widget-convenience.lisp.

Macro: define-initializer ((widget-class method-name &optional priority) &body body) ¶

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

Package

qtools.

Source

widget-convenience.lisp.

Macro: define-menu ((widget-class name &optional menu-name) &body contents) ¶

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.

Package

qtools.

Source

widget-menu.lisp.

Macro: define-menu-content-type (type (parent &rest args) &body body) ¶

Defines a new menu content type processor NAME.

See (SETF QTOOLS:MENU-CONTENT-TYPE).

Package

qtools.

Source

widget-menu.lisp.

Macro: define-method-declaration (name args &body body) ¶

Define a new method declaration function of NAME.

See (SETF QTOOLS:METHOD-DECLARATION).

Package

qtools.

Source

widget-defmethod.lisp.

Macro: define-object (name (qt-class &rest direct-superclasses) direct-slots &rest options) ¶

Alias for DEFINE-WIDGET.

This is merely here for clarity.

See QTOOLS:DEFINE-WIDGET

Package

qtools.

Source

widget.lisp.

Macro: define-override ((widget-class override &optional method-name) args &body body) ¶

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

Package

qtools.

Source

widget-convenience.lisp.

Macro: define-print-method ((instance class stream) &body body) ¶

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

Package

qtools.

Source

printing.lisp.

Macro: define-qclass-dispatch-function (basename dispatcher args) ¶

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

Package

qtools.

Source

dispatch.lisp.

Macro: define-signal ((widget-class signal) args &body options) ¶

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

Package

qtools.

Source

widget-convenience.lisp.

Macro: define-signal-method (name args) ¶

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.

Package

qtools.

Source

signal.lisp.

Macro: define-simple-translator ((type name &optional priority) (source) &body body) ¶

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

Package

qtools.

Source

name-translation.lisp.

Macro: define-slot ((widget-class slot &optional method-name) args &body body) ¶

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

Package

qtools.

Source

widget-convenience.lisp.

Macro: define-subobject ((object-class name) initform &body body) ¶

Alias for DEFINE-SUBWIDGET

This is merely here for clarity.

See QTOOLS:DEFINE-SUBOBJECT

Package

qtools.

Source

widget-convenience.lisp.

Macro: define-subwidget ((widget-class name) initform &body body) ¶

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

Package

qtools.

Source

widget-convenience.lisp.

Macro: define-translator (name (source type &optional priority) &body body) ¶

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

Package

qtools.

Source

name-translation.lisp.

Macro: define-widget (name (qt-class &rest direct-superclasses) direct-slots &rest options) ¶

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.

Package

qtools.

Source

widget.lisp.

Macro: defmethod (name &rest args) ¶

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.

Package

cl+qt.

Source

widget-defmethod.lisp.

Macro: defun (name args &body body) ¶

Package

cl+qt.

Source

dynamic.lisp.

Macro: disconnect! (origin origin-function target target-function) ¶

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.

Package

qtools.

Source

signal.lisp.

Macro: do-layout ((widget layout) &body body) ¶

Iterate over all WIDGETs on LAYOUT.

Package

qtools.

Source

toolkit.lisp.

Macro: fast-call (method-descriptor object &rest args) ¶

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

Package

qtools.

Source

fast-call.lisp.

Macro: fast-direct-call (method object stack) ¶

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

Package

qtools.

Source

fast-call.lisp.

Macro: fast-static-call (method-descriptor &rest args) ¶

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

Package

qtools.

Source

fast-call.lisp.

Macro: fsetf (&rest pairs) ¶

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.

Package

qtools.

Source

dynamic.lisp.

Macro: function (name) ¶

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.

Package

cl+qt.

Source

dynamic.lisp.

Macro: q+ (function &rest args) ¶

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

Package

qtools.

Source

dynamic.lisp.

Macro: q+fun (function) ¶

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

Package

qtools.

Source

dynamic.lisp.

Macro: qclass=case (instance &body cases) ¶

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.

Package

qtools.

Source

toolkit.lisp.

Macro: qtenumcase (keyform &body forms) ¶

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

Package

qtools.

Source

toolkit.lisp.

Macro: qtypecase (instance &body cases) ¶

Analogous to CL:TYPECASE, but for Qt classes.

See QINSTANCEP

Package

qtools.

Source

toolkit.lisp.

Macro: setf (&rest args) ¶

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*

Package

cl+qt.

Source

dynamic.lisp.

Macro: signal! (object function &rest args) ¶

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.

Package

qtools.

Source

signal.lisp.

Macro: with-all-slots-bound ((instance class) &body body) ¶

Turns into a WITH-SLOTS with all slots of CLASS. Class is resolved as per ENSURE-CLASS.

Package

qtools.

Source

toolkit.lisp.

Macro: with-call-stack (stack args &body body) ¶

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

Package

qtools.

Source

fast-call.lisp.

Macro: with-finalizing (bindings &body body) ¶

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.

Package

qtools.

Source

finalizable.lisp.

Macro: with-finalizing* (bindings &body body) ¶

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.

Package

qtools.

Source

finalizable.lisp.

Macro: with-gc-finalized (bindings &body body) ¶

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.

Package

qtools.

Source

gc-finalized.lisp.

Macro: with-main-window ((window instantiator &key name qapplication-args blocking main-thread on-error show finalize body) &body forms) ¶

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.

Package

qtools.

Source

toolkit.lisp.

Macro: with-slots-bound ((instance class) &body body) ¶

Turns into a WITH-SLOTS with all direct-slots of CLASS. Class is resolved as per ENSURE-CLASS.

Package

qtools.

Source

toolkit.lisp.

Macro: with-widget-class ((variable &optional method) &body body) ¶

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.

Package

qtools.

Source

widget-defmethod.lisp.

---

5.1.3 Compiler macros

Compiler Macro: generic-signal (object function &rest args) ¶

Package

qtools.

Source

signal.lisp.

---

5.1.4 Ordinary functions

Function: build-menu-content (parent type contents) ¶

Calls the appropriate function to parse menu content of TYPE.

See (SETF QTOOLS:MENU-CONTENT-TYPE).

Package

qtools.

Source

widget-menu.lisp.

Function: call-finalizers (class) ¶

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.

Package

qtools.

Source

widget.lisp.

Function: call-initializers (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.

Package

qtools.

Source

widget.lisp.

Function: capitalize-on (character string &optional replacement start-capitalized) ¶

Package

qtools.

Source

toolkit.lisp.

Function: cl-type-for (qt-type) ¶

Attempts to determine the CL type for the given Qt type descriptor.

Look at the source to see the mappings.

Package

qtools.

Source

name-translation.lisp.

Function: clear-method-info () ¶

Clears the *QMETHODS* table.

See QTOOLS:*QMETHODS*

Package

qtools.

Source

generate.lisp.

Function: compile-wrapper (method) ¶

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

Package

qtools.

Source

generate.lisp.

Function: copy-qobject (instance) ¶

Package

qtools.

Source

copying.lisp.

Function: default-application-name () ¶

Attempts to find and return a default name to use for the application.

Package

qtools.

Source

toolkit.lisp.

Function: describe-copy-method (class) ¶

Prints information about the copy method for the specified class if possible.

Package

qtools.

Source

copying.lisp.

Function: describe-finalize-method (class) ¶

Prints information about the finalize method for the given class if possible.

Package

qtools.

Source

finalizable.lisp.

Function: describe-print-method (class) ¶

Prints information about the print method for the specified class if possible.

Package

qtools.

Source

printing.lisp.

Function: determined-type-method-name (function args) ¶

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.

Package

qtools.

Source

name-translation.lisp.

Function: direct-qsubclass-p (qclass maybe-superclass) ¶

Returns T if MAYBE-SUPERCLASS is a direct superclass of QCLASS.

Package

qtools.

Source

dispatch.lisp.

Function: dispatch-by-qclass (method-locator object &rest args) ¶

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

Package

qtools.

Source

dispatch.lisp.

Function: ecl-type-for (qt-type) ¶

Same as CL-TYPE-FOR, but signals an error if no matching type could be found.

Package

qtools.

Source

name-translation.lisp.

Function: emit-compilation-note (format-string &rest args) ¶

Package

qtools.

Source

toolkit.lisp.

Function: ensure-class (thing) ¶

Ensures to return a CLASS. SYMBOL -> FIND-CLASS CLASS -> IDENTITY STANDARD-OBJECT -> CLASS-OF

Package

qtools.

Source

toolkit.lisp.

Function: ensure-methods-processed () ¶

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

Package

qtools.

Source

generate.lisp.

Function: ensure-q+-method (function) ¶

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*

Package

qtools.

Source

dynamic.lisp.

Function: ensure-qapplication (&key name args main-thread) ¶

Ensures that the QT:*QAPPLICATION* is available, potentially using NAME and ARGS to initialize it.

See QT:*QAPPLICATION*
See QT:ENSURE-SMOKE

Package

qtools.

Source

toolkit.lisp.

Function: ensure-qclass (thing) ¶

Package

qtools.

Source

toolkit.lisp.

Function: ensure-qobject (thing) ¶

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.

Package

qtools.

Source

toolkit.lisp.

Function: enumerate-method-descriptors (name args) ¶

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)")

Package

qtools.

Source

toolkit.lisp.

Function: eqt-class-name (designator) ¶

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.

Package

qtools.

Source

class-map.lisp.

Function: eqt-type-of (object) ¶

Same as QT-TYPE-OF, but signals an error if no matching type could be found.

Package

qtools.

Source

name-translation.lisp.

Function: fdefinition (name) ¶

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.

Package

cl+qt.

Source

dynamic.lisp.

Function: (setf fdefinition) (name) ¶

Package

cl+qt.

Source

dynamic.lisp.

Function: finalize-qobject (instance) ¶

Package

qtools.

Source

finalizable.lisp.

Function: find-child (widget child-class) ¶

Find the first child that is an instance of CHILD-CLASS

See FIND-CHILDREN

Package

qtools.

Source

toolkit.lisp.

Function: find-children (widget child-class &key first-only) ¶

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

Package

qtools.

Source

toolkit.lisp.

Function: find-fastcall-method (class name &rest argtypes) ¶

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

Package

qtools.

Source

fast-call.lisp.

Function: find-qt-class-name (designator) ¶

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*

Package

qtools.

Source

class-map.lisp.

Function: fuse-alists (&rest alists-lists) ¶

Package

qtools.

Source

toolkit.lisp.

Function: fuse-plists (&rest plists-lists) ¶

Package

qtools.

Source

toolkit.lisp.

Function: generic-signal (object function &rest args) ¶

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.

Package

qtools.

Source

signal.lisp.

Function: load-all-smoke-modules (&rest mods) ¶

Loads all the smoke modules as passed.

See QT:ENSURE-SMOKE

Package

qtools.

Source

generate.lisp.

Function: loaded-smoke-modules () ¶

Returns a fresh list of currently loaded smoke modules.

See QTOOLS:*SMOKE-MODULES*
See QT:NAMED-MODULE-NUMBER

Package

qtools.

Source

generate.lisp.

Function: make-chord (chord) ¶

Transforms CHORD into a keychord string, if possible.

Package

qtools.

Source

widget-menu.lisp.

Function: make-gc-finalized (object) ¶

Wrap the OBJECT in a GC-FINALIZED instance. Use UNBOX to retrieve the object again.

Package

qtools.

Source

gc-finalized.lisp.

Function: map-compile-all (function) ¶

Calls FUNCTION with the result of COMPILE-WRAPPER on all available methods.

See QTOOLS:COMPILE-WRAPPER
See QTOOLS:*QMETHODS*

Package

qtools.

Source

generate.lisp.

Function: map-layout (function layout) ¶

Map all widgets and layouts on LAYOUT onto FUNCTION.

Package

qtools.

Source

toolkit.lisp.

Function: maybe-delete-qobject (object) ¶

Deletes the object if possible.

Package

qtools.

Source

toolkit.lisp.

Function: menu-content-type (name) ¶

Returns the function to process a menu content type NAME, if any.

Package

qtools.

Source

widget-menu.lisp.

Function: (setf menu-content-type) (name) ¶

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.

Package

qtools.

Source

widget-menu.lisp.

Function: method-declaration (name) ¶

Returns a function to process the method declaration NAME, if one exists.

See (SETF QTOOLS:METHOD-DECLARATION).

Package

qtools.

Source

widget-defmethod.lisp.

Function: (setf method-declaration) (name) ¶

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*.

Package

qtools.

Source

widget-defmethod.lisp.

Function: method-symbol (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

Package

qtools.

Source

generate.lisp.

Function: print-qobject (instance stream) ¶

Package

qtools.

Source

printing.lisp.

Function: process-all-methods () ¶

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

Package

qtools.

Source

generate.lisp.

Function: process-method (method) ¶

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*

Package

qtools.

Source

generate.lisp.

Function: q+-compile-and-load (&key modules file) ¶

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

Package

qtools.

Source

precompile.lisp.

Function: q+apropos (term) ¶

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*

Package

qtools.

Source

generate.lisp.

Function: qclass-precedence-list (qclass) ¶

Returns the class precedence list for the given qclass.

See *QCLASS-PRECEDENCE-LISTS*
See COMPUTE-QCLASS-PRECEDENCE-LIST

Package

qtools.

Source

dispatch.lisp.

Function: qinstancep (instance class) ¶

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.

Package

qtools.

Source

dispatch.lisp.

Function: qobject-alive-p (object) ¶

Returns T if the object is not null and not deleted.

Package

qtools.

Source

toolkit.lisp.

Function: qt-type-for (cl-type) ¶

Attempts to determine the proper Qt type descriptor for the passed cl type name.

Look at the source to see the mappings.

Package

qtools.

Source

name-translation.lisp.

Function: qt-type-of (object) ¶

Attempts to determine a proper Qt type descriptor for the type of the OBJECT.

Look at the source to see the mappings.

Package

qtools.

Source

name-translation.lisp.

Function: remove-finalizer (widget-class finalizer) ¶

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

Package

qtools.

Source

widget-convenience.lisp.

Function: remove-initializer (widget-class initializer) ¶

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

Package

qtools.

Source

widget-convenience.lisp.

Function: remove-menu-content-type (name) ¶

Removes the menu content type NAME.

Package

qtools.

Source

widget-menu.lisp.

Function: remove-method-declaration (name) ¶

Remove the method declaration processor function of NAME.

Package

qtools.

Source

widget-defmethod.lisp.

Function: remove-override (widget-class override) ¶

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

Package

qtools.

Source

widget-convenience.lisp.

Function: remove-signal (widget-class signal) ¶

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

Package

qtools.

Source

widget-convenience.lisp.

Function: remove-slot (widget-class slot) ¶

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

Package

qtools.

Source

widget-convenience.lisp.

Function: remove-subwidget (widget-class subwidget) ¶

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

Package

qtools.

Source

widget-convenience.lisp.

Function: remove-widget-class-option (class option identifier &key key test) ¶

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.

Package

qtools.

Source

widget.lisp.

Function: set-widget-class-option (class option value &key key test) ¶

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.

Package

qtools.

Source

widget.lisp.

Function: softly-redefine-widget-class (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.

Package

qtools.

Source

widget.lisp.

Function: specified-type-method-name (function args) ¶

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.

Package

qtools.

Source

name-translation.lisp.

Function: split (list items &key key test) ¶

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)))

Package

qtools.

Source

toolkit.lisp.

Function: sweep-layout (layout &optional finalize) ¶

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.

Package

qtools.

Source

toolkit.lisp.

Function: to-method-name (thing) ¶

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

Package

qtools.

Source

name-translation.lisp.

Function: to-qbyte-array (vector) ¶

Translates an unsigned-byte 8 vector into a QByteArray.

Package

qtools.

Source

toolkit.lisp.

Function: to-type-name (thing) ¶

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.

Package

qtools.

Source

name-translation.lisp.

Function: translate-name (name type &optional error-p) ¶

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

Package

qtools.

Source

name-translation.lisp.

Function: widget-actions (class) ¶

Returns a list of QAction instances that are active on the given CLASS.

Package

qtools.

Source

widget-menu.lisp.

Function: (setf widget-actions) (class) ¶

Sets the list of QAction instances that are active on the given CLASS.

Package

qtools.

Source

widget-menu.lisp.

Function: widget-class-option-p (class option value &key key test) ¶

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

Package

qtools.

Source

widget.lisp.

Function: write-everything-to-file (pathname &key package if-exists) ¶

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*

Package

qtools.

Source

precompile.lisp.

---

5.1.5 Generic functions

Generic Reader: clashing-qt-superclass (condition) ¶

Generic Writer: (setf clashing-qt-superclass) (condition) ¶

Package

qtools.

Methods

Reader Method: clashing-qt-superclass ((condition invalid-qt-superclass-hierarchy)) ¶

Writer Method: (setf clashing-qt-superclass) ((condition invalid-qt-superclass-hierarchy)) ¶

Source

widget.lisp.

Target Slot

clashing-qt-superclass.

Generic Reader: clashing-superclass (condition) ¶

Generic Writer: (setf clashing-superclass) (condition) ¶

Package

qtools.

Methods

Reader Method: clashing-superclass ((condition invalid-qt-superclass-hierarchy)) ¶

Writer Method: (setf clashing-superclass) ((condition invalid-qt-superclass-hierarchy)) ¶

Source

widget.lisp.

Target Slot

clashing-superclass.

Generic Function: construct (widget) ¶

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.

Package

qtools.

Source

widget.lisp.

Methods

Method: construct ((widget widget)) ¶

Generic Function: copy (instance) ¶

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.

Package

qtools.

Source

copying.lisp.

Methods

Method: copy ((instance gc-finalized)) ¶

Creates a new GC-Finalized object using the value of COPY on its contained object.

Method: copy (instance) ¶

Generic Function: finalize (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.

Package

qtools.

Source

finalizable.lisp.

Methods

Method: finalize :before ((widget widget)) ¶

Source

widget.lisp.

Method: finalize ((object finalizable)) ¶

Finalizes and unbinds all slots on the object that are marked as FINALIZED and then calls the next method.

Method: finalize ((object list)) ¶

Calls the next method and then invokes FINALIZE on all items of the list.

Method: finalize ((object vector)) ¶

Calls the next method and then invokes FINALIZE on all items of the vector.

Method: finalize ((object hash-table)) ¶

Calls the next method and then invokes FINALIZE on all the keys and values of the table.

Method: finalize ((object abstract-qobject)) ¶

Calls the next method and then invokes MAYBE-DELETE-QOBJECT.

Method: finalize (object) ¶

Method: finalize ((object qobject)) ¶

Generic Reader: finalized (object) ¶

Package

qtools.

Methods

Reader Method: finalized ((finalizable-slot finalizable-slot)) ¶

automatically generated reader method

Source

finalizable.lisp.

Target Slot

finalized.

Generic Function: parent (object) ¶

accesses the PARENT of the object. This usually translates to (#_parent object) unless overridden.

Package

qtools.

Source

toolkit.lisp.

Methods

Method: parent ((object qobject)) ¶

Generic Function: (setf parent) (object) ¶

Package

qtools.

Methods

Method: (setf parent) ((object qobject)) ¶

Source

toolkit.lisp.

Method: (setf parent) ((object qobject)) ¶

Source

toolkit.lisp.

Generic Reader: requested-qt-superclass (condition) ¶

Generic Writer: (setf requested-qt-superclass) (condition) ¶

Package

qtools.

Methods

Reader Method: requested-qt-superclass ((condition invalid-qt-superclass-hierarchy)) ¶

Writer Method: (setf requested-qt-superclass) ((condition invalid-qt-superclass-hierarchy)) ¶

Source

widget.lisp.

Target Slot

requested-qt-superclass.

Generic Reader: unbox (object) ¶

Package

qtools.

Methods

Reader Method: unbox ((gc-finalized gc-finalized)) ¶

automatically generated reader method

Source

gc-finalized.lisp.

Target Slot

%object.

Generic Function: value (object) ¶

Accesses the VALUE of the object. This usually translates to (#_value object) unless overridden.

Package

qtools.

Source

toolkit.lisp.

Methods

Method: value ((widget widget)) ¶

Source

widget.lisp.

Method: value ((object qobject)) ¶

Generic Function: (setf value) (object) ¶

Package

qtools.

Source

toolkit.lisp.

Methods

Method: (setf value) ((widget widget)) ¶

Source

widget.lisp.

Method: (setf value) ((object qobject)) ¶

Generic Reader: widget-class-direct-options (object) ¶

Contains all the options passed to RE/INITIALIZE-INSTANCE when the class is re/initialized directly through a DEFCLASS form.

Package

qtools.

Methods

Reader Method: widget-class-direct-options ((widget-class widget-class)) ¶

automatically generated reader method

Source

widget.lisp.

Target Slot

direct-options.

Generic Writer: (setf widget-class-direct-options) (object) ¶

Package

qtools.

Methods

Writer Method: (setf widget-class-direct-options) ((widget-class widget-class)) ¶

automatically generated writer method

Source

widget.lisp.

Target Slot

direct-options.

Generic Reader: widget-class-extern-options (object) ¶

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.

Package

qtools.

Methods

Reader Method: widget-class-extern-options ((widget-class widget-class)) ¶

automatically generated reader method

Source

widget.lisp.

Target Slot

extern-options.

Generic Writer: (setf widget-class-extern-options) (object) ¶

Package

qtools.

Methods

Writer Method: (setf widget-class-extern-options) ((widget-class widget-class)) ¶

automatically generated writer method

Source

widget.lisp.

Target Slot

extern-options.

Generic Reader: widget-class-finalizers (object) ¶

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

Package

qtools.

Methods

Reader Method: widget-class-finalizers ((widget-class widget-class)) ¶

automatically generated reader method

Source

widget.lisp.

Target Slot

finalizers.

Generic Writer: (setf widget-class-finalizers) (object) ¶

Package

qtools.

Methods

Writer Method: (setf widget-class-finalizers) ((widget-class widget-class)) ¶

automatically generated writer method

Source

widget.lisp.

Target Slot

finalizers.

Generic Reader: widget-class-initializers (object) ¶

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

Package

qtools.

Methods

Reader Method: widget-class-initializers ((widget-class widget-class)) ¶

automatically generated reader method

Source

widget.lisp.

Target Slot

initializers.

Generic Writer: (setf widget-class-initializers) (object) ¶

Package

qtools.

Methods

Writer Method: (setf widget-class-initializers) ((widget-class widget-class)) ¶

automatically generated writer method

Source

widget.lisp.

Target Slot

initializers.

---