The qtools Reference Manual

This is the qtools Reference Manual, version 1.2.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Wed May 15 06:37:29 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

The main system appears first, followed by any subsystem dependency.


2.1 qtools

A collection of tools to aid in development with CommonQt.

Maintainer

Nicolas Hafner <>

Author

Nicolas Hafner <>

Home Page

https://Shinmera.github.io/qtools/

Source Control

(GIT https://github.com/Shinmera/qtools.git)

Bug Tracker

https://github.com/Shinmera/qtools/issues

License

zlib

Version

1.2.0

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

qtools.asd.

Child Components

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


3.1 Lisp


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

3.1.3 qtools/toolkit.lisp

Dependency

package.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface
Internals

3.1.4 qtools/class-map.lisp

Dependency

toolkit.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface
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
Internals

3.1.6 qtools/dispatch.lisp

Dependency

name-translation.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface
Internals

3.1.7 qtools/finalizable.lisp

Dependency

dispatch.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface
Internals

3.1.8 qtools/gc-finalized.lisp

Dependency

finalizable.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface

3.1.9 qtools/copying.lisp

Dependency

gc-finalized.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface
Internals

3.1.10 qtools/printing.lisp

Dependency

copying.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface
Internals

3.1.11 qtools/signal.lisp

Dependency

printing.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface
Internals

3.1.12 qtools/widget.lisp

Dependency

signal.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface
Internals

3.1.13 qtools/widget-defmethod.lisp

Dependency

widget.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface
Internals

3.1.14 qtools/widget-convenience.lisp

Dependency

widget-defmethod.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface
Internals

3.1.15 qtools/widget-menu.lisp

Dependency

widget-convenience.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface
Internals

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
Internals

3.1.18 qtools/dynamic.lisp

Dependency

generate.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface
Internals

3.1.19 qtools/precompile.lisp

Dependency

dynamic.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface
Internals

write-forms (function).


3.1.20 qtools/deploy.lisp

Dependency

precompile.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).

Public Interface
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
Internals

find-fastcall-static-method (function).


3.1.22 qtools/documentation.lisp

Dependency

fast-call.lisp (file).

Source

qtools.asd.

Parent Component

qtools (system).


4 Packages

Packages are listed by definition order.


4.1 qtools

Source

package.lisp.

Nickname

org.shirakumo.qtools

Use List
  • common-lisp.
  • qt.
Used By List

cl+qt.

Public Interface
Internals

4.2 cl+qt

Source

package.lisp.

Nickname

org.shirakumo.qtools+common-lisp

Use List
Public Interface

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


5.1 Public Interface


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.


5.1.6 Standalone methods

Method: compute-effective-slot-definition ((class finalizable-class) name direct-slots)
Package

sb-mop.

Source

finalizable.lisp.

Method: direct-slot-definition-class ((class finalizable-class) &rest initargs)
Package

sb-mop.

Source

finalizable.lisp.

Method: discover-entry-point ((o qt-program-op) (c system))
Package

deploy.

Source

deploy.lisp.

Method: effective-slot-definition-class ((class finalizable-class) &rest initargs)
Package

sb-mop.

Source

finalizable.lisp.

Method: finalize-inheritance :after ((class widget-class))
Package

sb-mop.

Source

widget.lisp.

Method: initialize-instance :around ((class widget-class) &rest options &key constructor &allow-other-keys)
Source

widget.lisp.

Method: initialize-instance :after ((finalized gc-finalized) &key)
Source

gc-finalized.lisp.

Method: initialize-instance ((widget widget) &key)
Source

widget.lisp.

Method: perform :before ((o qt-program-op) (c system))
Package

asdf/action.

Source

deploy.lisp.

Method: print-object ((slot finalizable-slot) stream)
Source

finalizable.lisp.

Method: print-object ((finalized gc-finalized) stream)
Source

gc-finalized.lisp.

Method: reinitialize-instance :around ((class widget-class) &rest options &key constructor &allow-other-keys)
Source

widget.lisp.

Method: validate-superclass ((class finalizable-class) (superclass finalizable-class))
Package

sb-mop.

Source

finalizable.lisp.

Method: validate-superclass ((class finalizable-class) (superclass standard-class))
Package

sb-mop.

Source

finalizable.lisp.

Method: validate-superclass ((class standard-class) (superclass finalizable-class))
Package

sb-mop.

Source

finalizable.lisp.

Method: validate-superclass ((class finalizable-class) superclass)
Package

sb-mop.

Source

finalizable.lisp.


5.1.7 Conditions

Condition: compilation-note
Package

qtools.

Source

toolkit.lisp.

Direct superclasses

compiler-note.

Direct methods
Direct slots
Slot: message
Initform

(quote (error "message required."))

Initargs

:message

Readers

message.

Writers

(setf message).

Condition: invalid-qt-superclass-hierarchy
Package

qtools.

Source

widget.lisp.

Direct superclasses

error.

Direct methods
Direct slots
Slot: requested-qt-superclass
Initargs

:requested-qt-superclass

Readers

requested-qt-superclass.

Writers

(setf requested-qt-superclass).

Slot: clashing-qt-superclass
Initargs

:clashing-qt-superclass

Readers

clashing-qt-superclass.

Writers

(setf clashing-qt-superclass).

Slot: clashing-superclass
Initargs

:clashing-superclass

Readers

clashing-superclass.

Writers

(setf clashing-superclass).


5.1.8 Classes

Class: finalizable

A class for finalizable objects.

Package

qtools.

Source

finalizable.lisp.

Direct subclasses
Direct methods

finalize.

Class: finalizable-class

Metaclass for classes with finalizable slots.

Package

qtools.

Source

finalizable.lisp.

Direct superclasses

standard-class.

Direct subclasses

widget-class.

Direct methods
Class: finalizable-slot

Superclass for slots with a finalized option.

Package

qtools.

Source

finalizable.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: finalized
Initargs

:finalized

Readers

finalized.

Writers

This slot is read-only.

Class: gc-finalized

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.

Package

qtools.

Source

gc-finalized.lisp.

Direct superclasses

finalizable.

Direct methods
Direct slots
Slot: %object
Initform

(error "object required.")

Initargs

:object

Readers

unbox.

Writers

This slot is read-only.

Class: qt-program-op

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.

Package

qtools.

Source

deploy.lisp.

Direct superclasses

deploy-op.

Direct methods
Class: widget

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.

Package

qtools.

Source

widget.lisp.

Direct superclasses
Direct methods
Class: widget-class

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.

Package

qtools.

Source

widget.lisp.

Direct superclasses
Direct methods
Direct slots
Slot: direct-options
Readers

widget-class-direct-options.

Writers

(setf widget-class-direct-options).

Slot: extern-options
Readers

widget-class-extern-options.

Writers

(setf widget-class-extern-options).

Slot: direct-initializers
Initargs

:initializers

Readers

widget-class-direct-initializers.

Writers

(setf widget-class-direct-initializers).

Slot: direct-finalizers
Initargs

:finalizers

Readers

widget-class-direct-finalizers.

Writers

(setf widget-class-direct-finalizers).

Slot: initializers
Readers

widget-class-initializers.

Writers

(setf widget-class-initializers).

Slot: finalizers
Readers

widget-class-finalizers.

Writers

(setf widget-class-finalizers).


5.1.9 Types

Type: function ()
Package

cl+qt.

Source

dynamic.lisp.


5.2 Internals


5.2.1 Special variables

Special Variable: *application-name*
Package

qtools.

Source

toolkit.lisp.

Special Variable: *menu-content-types*
Package

qtools.

Source

widget-menu.lisp.

Special Variable: *method-declarations*
Package

qtools.

Source

widget-defmethod.lisp.

Special Variable: *qclass-copy-functions*
Package

qtools.

Source

copying.lisp.

Special Variable: *qclass-finalize-functions*
Package

qtools.

Source

finalizable.lisp.

Special Variable: *qclass-precedence-list*
Package

qtools.

Source

dispatch.lisp.

Special Variable: *qclass-precedence-lists*

Holds a map of computed precedence lists for qclasses.

We can cache this since the Qt class hierarchy is static.

Package

qtools.

Source

dispatch.lisp.

Special Variable: *qclass-print-functions*
Package

qtools.

Source

printing.lisp.

Special Variable: *standard-function-reader*
Package

qtools.

Source

dynamic.lisp.

Special Variable: *standard-paren-reader*
Package

qtools.

Source

dynamic.lisp.

Special Variable: *translators*

An ordered list of name translators.

See TRANSLATOR
See REMOVE-TRANSLATOR

Package

qtools.

Source

name-translation.lisp.

Special Variable: *widget-actions*
Package

qtools.

Source

widget-menu.lisp.


5.2.2 Macros

Macro: define-extern-inline-fun (name lambda-list &body body)

Shorthand for EXPORT, DECLAIM INLINE, and DEFUN.

Package

qtools.

Source

generate.lisp.

Macro: define-extern-macro (name lambda-list &body body)

Shorthand for EXPORT and DEFMACRO.

Package

qtools.

Source

generate.lisp.

Macro: define-qclass-copy-function (qclass args &body body)
Package

qtools.

Source

copying.lisp.

Macro: define-qclass-finalize-function (qclass args &body body)
Package

qtools.

Source

finalizable.lisp.

Macro: define-qclass-print-function (qclass args &body body)
Package

qtools.

Source

printing.lisp.

Macro: define-qt-constant (name (class method) &optional documentation)
Package

qtools.

Source

generate.lisp.

Macro: named-lambda (name args &body body)
Package

qtools.

Source

toolkit.lisp.

Macro: print-unreadable-qobject ((object stream &key type identity) &body body)
Package

qtools.

Source

printing.lisp.

Macro: with-args ((required optional optional-p) methods &body body)

Calculates the proper argument list parts required for the given METHODS.

Package

qtools.

Source

generate.lisp.

Macro: with-compile-and-run (&body body)

Compiles BODY in a lambda and funcalls it.

Package

qtools.

Source

toolkit.lisp.

Macro: with-output-to-target-symbol ((stream) &body body)

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

Package

qtools.

Source

generate.lisp.

Macro: with-traps-masked (&body body)
Package

qtools.

Source

toolkit.lisp.


5.2.3 Ordinary functions

Function: %build-with-finalizing-construct (binder bindings body)
Package

qtools.

Source

finalizable.lisp.

Function: %determined-type-method-name-arg (stream arg a b)
Package

qtools.

Source

name-translation.lisp.

Function: %make-slots-bound-proper (widget-class body)
Package

qtools.

Source

widget-convenience.lisp.

Function: %method-see (stream method &rest rest)
Package

qtools.

Source

generate.lisp.

Function: %specified-type-method-name-arg (stream arg a b)
Package

qtools.

Source

name-translation.lisp.

Function: cascade-option-changes (class)
Package

qtools.

Source

widget.lisp.

Function: check-qt-superclass-compatibility (qt-superclass direct-superclasses)

Check whether the given QT-SUPERCLASS is permissible given the DIRECT-SUPERCLASSES.

Package

qtools.

Source

widget.lisp.

Function: cl-constant-name (method)
Package

qtools.

Source

generate.lisp.

Function: cl-constructor-name (method)
Package

qtools.

Source

generate.lisp.

Function: cl-method-name (method)
Package

qtools.

Source

generate.lisp.

Function: cl-operator-name (method)
Package

qtools.

Source

generate.lisp.

Function: cl-static-method-name (method)
Package

qtools.

Source

generate.lisp.

Function: cl-variable-name (method)
Package

qtools.

Source

generate.lisp.

Function: clean-method-name (method)

Returns a cleaned up name of METHOD.
This effectively trims #, $, and ? from the name.

Package

qtools.

Source

generate.lisp.

Function: compile-constant (methods)
Package

qtools.

Source

generate.lisp.

Function: compile-constructor (methods)
Package

qtools.

Source

generate.lisp.

Function: compile-method (methods)
Package

qtools.

Source

generate.lisp.

Function: compile-operator (methods)
Package

qtools.

Source

generate.lisp.

Function: compile-static-method (methods)
Package

qtools.

Source

generate.lisp.

Function: compute-qclass-precedence-list (qclass)

Calculates the class precedence list for the given qclass as per CLHS 4.3.5

Package

qtools.

Source

dispatch.lisp.

Function: emit-operator-call (methods instance &rest args)
Package

qtools.

Source

generate.lisp.

Function: ensure-cl-function-name (name)
Package

qtools.

Source

toolkit.lisp.

Function: ensure-completable-qclass (thing)
Package

qtools.

Source

toolkit.lisp.

Function: ensure-list (a)
Package

qtools.

Source

toolkit.lisp.

Function: ensure-methods (method)

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.

Package

qtools.

Source

generate.lisp.

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

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

Package

qtools.

Source

fast-call.lisp.

Function: generate-constant-docstring (method)

Generates a docstring for an enum constant.

Package

qtools.

Source

generate.lisp.

Function: generate-method-docstring (methods)

Generates a docstring that references all the Qt methods that a wrapper function can be used for.

Package

qtools.

Source

generate.lisp.

Function: generate-qclass-dispatch-lambda (qclass fun basename args body)

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.

Package

qtools.

Source

dispatch.lisp.

Function: main-window-exec (window &key name qapplication-args blocking main-thread on-error show finalize before-exec after-exec)
Package

qtools.

Source

toolkit.lisp.

Function: make-reader-for-function (function)
Package

qtools.

Source

readtable.lisp.

Function: maybe-unwrap-quote (thing)

If it is a quote form, unwraps the contents. Otherwise returns it directly.

Package

qtools.

Source

toolkit.lisp.

Function: method-needed-p (method)

Returns T if the METHOD is considered to be useful for wrapper compilation.

Package

qtools.

Source

generate.lisp.

Function: normalize-bindings (bindings)
Package

qtools.

Source

finalizable.lisp.

Function: process-list-arg (arg)
Package

qtools.

Source

signal.lisp.

Function: process-q+-setter (place value)

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*

Package

qtools.

Source

dynamic.lisp.

Function: q+-symbol-name (string)
Package

qtools.

Source

dynamic.lisp.

Function: q+-symbol-p (stream)
Package

qtools.

Source

dynamic.lisp.

Function: qclass-class-list (qclass)

Returns a list containing the given class and all of its transient superclasses.

Package

qtools.

Source

dispatch.lisp.

Function: qclass-copy-function (qclass)
Package

qtools.

Source

copying.lisp.

Function: (setf qclass-copy-function) (qclass)
Package

qtools.

Source

copying.lisp.

Function: qclass-finalize-function (qclass)
Package

qtools.

Source

finalizable.lisp.

Function: (setf qclass-finalize-function) (qclass)
Package

qtools.

Source

finalizable.lisp.

Function: qclass-precedence-set (qclass)

Builds a class precedence set for the class and all of its transient superclasses.

Package

qtools.

Source

dispatch.lisp.

Function: qclass-print-function (qclass)
Package

qtools.

Source

printing.lisp.

Function: (setf qclass-print-function) (qclass)
Package

qtools.

Source

printing.lisp.

Function: qmethod-bogus-p (method)

Returns T if the METHOD is bogus and unneeded.

Package

qtools.

Source

generate.lisp.

Function: qmethod-cast-operator-p (method)

Returns T if the METHOD is a casting operator.

Package

qtools.

Source

generate.lisp.

Function: qmethod-globalspace-p (method)

Returns T if the method is from the QGlobalSpace class.

Package

qtools.

Source

generate.lisp.

Function: qmethod-operator-p (method)

Returns T if the METHOD is an operator.

Package

qtools.

Source

generate.lisp.

Function: qmethod-translatable-operator-p (method)

Returns T if the operator METHOD is one that can be compiled by Qtools.

Package

qtools.

Source

generate.lisp.

Function: qtools-library-p (lib)

Test whether the given CFFI library is a Qtools library.

Package

qtools.

Source

deploy.lisp.

Function: read-function (stream subchar arg)
Package

qtools.

Source

dynamic.lisp.

Function: read-list-until (char stream &optional recursive-p)
Package

qtools.

Source

dynamic.lisp.

Function: read-name (stream)
Package

qtools.

Source

dynamic.lisp.

Function: read-paren (stream char)
Package

qtools.

Source

dynamic.lisp.

Function: remove-qclass-copy-function (qclass)
Package

qtools.

Source

copying.lisp.

Function: remove-qclass-finalize-function (qclass)
Package

qtools.

Source

finalizable.lisp.

Function: remove-qclass-print-function (qclass)
Package

qtools.

Source

printing.lisp.

Function: remove-translator (name)

Removes the translator by the given name.

See TRANSLATOR
See *TRANSLATORS*

Package

qtools.

Source

name-translation.lisp.

Function: repopulate-class-map ()
Package

qtools.

Source

class-map.lisp.

Function: set-effective-option (class slot direct-values &key direct-superclasses)
Package

qtools.

Source

widget.lisp.

Function: setup-widget-class (class next-method &rest options &key direct-superclasses qt-superclass initializers finalizers save-direct-options constructor &allow-other-keys)

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.

Package

qtools.

Source

widget.lisp.

Function: signal-method-for-name (name)
Package

qtools.

Source

signal.lisp.

Function: slot-initializer-symbol (slot)
Package

qtools.

Source

widget-defmethod.lisp.

Function: string-starts-with-p (start string &key offset)

Returns T if the STRING starts with START.

Strings are compared using STRING=

Package

qtools.

Source

generate.lisp.

Function: substring-type-p (test type)
Package

qtools.

Source

name-translation.lisp.

Function: subwidget-initializer-symbol (widget-class name)
Package

qtools.

Source

widget-convenience.lisp.

Function: target-package-symbol-string (&key extern symbol)
Package

qtools.

Source

dynamic.lisp.

Function: target-symbol (format-string &rest format-args)

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

Package

qtools.

Source

generate.lisp.

Function: to-readtable-case (string &optional case)

Translates STRING to the requested reading case according to CASE.

See CL:READTABLE-CASE

Package

qtools.

Source

dynamic.lisp.

Function: translator (name)

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*

Package

qtools.

Source

name-translation.lisp.

Function: (setf translator) (name &optional priority)
Package

qtools.

Source

name-translation.lisp.

Function: write-forms (stream)

Writes all compileable forms to STREAM.

See QTOOLS:MAP-COMPILE-ALL

Package

qtools.

Source

precompile.lisp.

Function: write-qclass-name (qclass stream)

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

Package

qtools.

Source

generate.lisp.

Function: write-qmethod-name (qmethod stream)

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

Package

qtools.

Source

generate.lisp.


5.2.4 Generic functions

Generic Reader: message (condition)
Generic Writer: (setf message) (condition)
Package

qtools.

Methods
Reader Method: message ((condition compilation-note))
Writer Method: (setf message) ((condition compilation-note))
Source

toolkit.lisp.

Target Slot

message.

Generic Reader: name (object)
Package

qtools.

Methods
Reader Method: name ((translator translator))

automatically generated reader method

Source

name-translation.lisp.

Target Slot

name.

Generic Writer: (setf name) (object)
Package

qtools.

Methods
Writer Method: (setf name) ((translator translator))

automatically generated writer method

Source

name-translation.lisp.

Target Slot

name.

Generic Reader: priority (object)
Package

qtools.

Methods
Reader Method: priority ((translator translator))

automatically generated reader method

Source

name-translation.lisp.

Target Slot

priority.

Generic Writer: (setf priority) (object)
Package

qtools.

Methods
Writer Method: (setf priority) ((translator translator))

automatically generated writer method

Source

name-translation.lisp.

Target Slot

priority.

Generic Reader: translation (object)
Package

qtools.

Methods
Reader Method: translation ((translator translator))

automatically generated reader method

Source

name-translation.lisp.

Target Slot

translation.

Generic Writer: (setf translation) (object)
Package

qtools.

Methods
Writer Method: (setf translation) ((translator translator))

automatically generated writer method

Source

name-translation.lisp.

Target Slot

translation.

Generic Reader: widget-class-direct-finalizers (object)
Package

qtools.

Methods
Reader Method: widget-class-direct-finalizers ((widget-class widget-class))

automatically generated reader method

Source

widget.lisp.

Target Slot

direct-finalizers.

Generic Writer: (setf widget-class-direct-finalizers) (object)
Package

qtools.

Methods
Writer Method: (setf widget-class-direct-finalizers) ((widget-class widget-class))

automatically generated writer method

Source

widget.lisp.

Target Slot

direct-finalizers.

Generic Reader: widget-class-direct-initializers (object)
Package

qtools.

Methods
Reader Method: widget-class-direct-initializers ((widget-class widget-class))

automatically generated reader method

Source

widget.lisp.

Target Slot

direct-initializers.

Generic Writer: (setf widget-class-direct-initializers) (object)
Package

qtools.

Methods
Writer Method: (setf widget-class-direct-initializers) ((widget-class widget-class))

automatically generated writer method

Source

widget.lisp.

Target Slot

direct-initializers.


5.2.5 Conditions

Condition: unknown-type-name
Package

qtools.

Source

name-translation.lisp.

Direct superclasses

style-warning.

Direct slots
Slot: type-name
Initargs

:type-name


5.2.6 Classes

Class: finalizable-direct-slot-definition
Package

qtools.

Source

finalizable.lisp.

Direct superclasses
Class: finalizable-effective-slot-definition
Package

qtools.

Source

finalizable.lisp.

Direct superclasses
Class: translator

Translator data type class holding the name, priority, and translation function.

See TRANSLATOR

Package

qtools.

Source

name-translation.lisp.

Direct methods
Direct Default Initargs
InitargValue
:name(error name required.)
:translation(error translation required.)
:priority0
Direct slots
Slot: name
Initargs

:name

Readers

name.

Writers

(setf name).

Slot: translation
Initargs

:translation

Readers

translation.

Writers

(setf translation).

Slot: priority
Initargs

:priority

Readers

priority.

Writers

(setf priority).


Appendix A Indexes


A.1 Concepts


A.2 Functions

Jump to:   %   (  
B   C   D   E   F   G   I   L   M   N   P   Q   R   S   T   U   V   W  
Index Entry  Section

%
%build-with-finalizing-construct: Private ordinary functions
%determined-type-method-name-arg: Private ordinary functions
%make-slots-bound-proper: Private ordinary functions
%method-see: Private ordinary functions
%specified-type-method-name-arg: Private ordinary functions

(
(setf clashing-qt-superclass): Public generic functions
(setf clashing-qt-superclass): Public generic functions
(setf clashing-superclass): Public generic functions
(setf clashing-superclass): Public generic functions
(setf fdefinition): Public ordinary functions
(setf menu-content-type): Public ordinary functions
(setf message): Private generic functions
(setf message): Private generic functions
(setf method-declaration): Public ordinary functions
(setf name): Private generic functions
(setf name): Private generic functions
(setf parent): Public generic functions
(setf parent): Public generic functions
(setf parent): Public generic functions
(setf priority): Private generic functions
(setf priority): Private generic functions
(setf qclass-copy-function): Private ordinary functions
(setf qclass-finalize-function): Private ordinary functions
(setf qclass-print-function): Private ordinary functions
(setf requested-qt-superclass): Public generic functions
(setf requested-qt-superclass): Public generic functions
(setf translation): Private generic functions
(setf translation): Private generic functions
(setf translator): Private ordinary functions
(setf value): Public generic functions
(setf value): Public generic functions
(setf value): Public generic functions
(setf widget-actions): Public ordinary functions
(setf widget-class-direct-finalizers): Private generic functions
(setf widget-class-direct-finalizers): Private generic functions
(setf widget-class-direct-initializers): Private generic functions
(setf widget-class-direct-initializers): Private generic functions
(setf widget-class-direct-options): Public generic functions
(setf widget-class-direct-options): Public generic functions
(setf widget-class-extern-options): Public generic functions
(setf widget-class-extern-options): Public generic functions
(setf widget-class-finalizers): Public generic functions
(setf widget-class-finalizers): Public generic functions
(setf widget-class-initializers): Public generic functions
(setf widget-class-initializers): Public generic functions

B
build-menu-content: Public ordinary functions

C
call-finalizers: Public ordinary functions
call-initializers: Public ordinary functions
capitalize-on: Public ordinary functions
cascade-option-changes: Private ordinary functions
check-qt-superclass-compatibility: Private ordinary functions
cl-constant-name: Private ordinary functions
cl-constructor-name: Private ordinary functions
cl-method-name: Private ordinary functions
cl-operator-name: Private ordinary functions
cl-static-method-name: Private ordinary functions
cl-type-for: Public ordinary functions
cl-variable-name: Private ordinary functions
clashing-qt-superclass: Public generic functions
clashing-qt-superclass: Public generic functions
clashing-superclass: Public generic functions
clashing-superclass: Public generic functions
clean-method-name: Private ordinary functions
clear-method-info: Public ordinary functions
compile-constant: Private ordinary functions
compile-constructor: Private ordinary functions
compile-method: Private ordinary functions
compile-operator: Private ordinary functions
compile-static-method: Private ordinary functions
compile-wrapper: Public ordinary functions
Compiler Macro, generic-signal: Public compiler macros
compute-effective-slot-definition: Public standalone methods
compute-qclass-precedence-list: Private ordinary functions
connect!: Public macros
construct: Public generic functions
construct: Public generic functions
copy: Public generic functions
copy: Public generic functions
copy: Public generic functions
copy-qobject: Public ordinary functions

D
default-application-name: Public ordinary functions
defgeneric: Public macros
define-1->1-translator: Public macros
define-copy-method: Public macros
define-extern-inline-fun: Private macros
define-extern-macro: Private macros
define-finalizable: Public macros
define-finalize-method: Public macros
define-finalizer: Public macros
define-initializer: Public macros
define-menu: Public macros
define-menu-content-type: Public macros
define-method-declaration: Public macros
define-object: Public macros
define-override: Public macros
define-print-method: Public macros
define-qclass-copy-function: Private macros
define-qclass-dispatch-function: Public macros
define-qclass-finalize-function: Private macros
define-qclass-print-function: Private macros
define-qt-constant: Private macros
define-signal: Public macros
define-signal-method: Public macros
define-simple-translator: Public macros
define-slot: Public macros
define-subobject: Public macros
define-subwidget: Public macros
define-translator: Public macros
define-widget: Public macros
defmethod: Public macros
defun: Public macros
describe-copy-method: Public ordinary functions
describe-finalize-method: Public ordinary functions
describe-print-method: Public ordinary functions
determined-type-method-name: Public ordinary functions
direct-qsubclass-p: Public ordinary functions
direct-slot-definition-class: Public standalone methods
disconnect!: Public macros
discover-entry-point: Public standalone methods
dispatch-by-qclass: Public ordinary functions
do-layout: Public macros

E
ecl-type-for: Public ordinary functions
effective-slot-definition-class: Public standalone methods
emit-compilation-note: Public ordinary functions
emit-operator-call: Private ordinary functions
ensure-cl-function-name: Private ordinary functions
ensure-class: Public ordinary functions
ensure-completable-qclass: Private ordinary functions
ensure-list: Private ordinary functions
ensure-methods: Private ordinary functions
ensure-methods-processed: Public ordinary functions
ensure-q+-method: Public ordinary functions
ensure-qapplication: Public ordinary functions
ensure-qclass: Public ordinary functions
ensure-qobject: Public ordinary functions
enumerate-method-descriptors: Public ordinary functions
eqt-class-name: Public ordinary functions
eqt-type-of: Public ordinary functions

F
fast-call: Public macros
fast-direct-call: Public macros
fast-static-call: Public macros
fdefinition: Public ordinary functions
finalize: Public generic functions
finalize: Public generic functions
finalize: Public generic functions
finalize: Public generic functions
finalize: Public generic functions
finalize: Public generic functions
finalize: Public generic functions
finalize: Public generic functions
finalize: Public generic functions
finalize-inheritance: Public standalone methods
finalize-qobject: Public ordinary functions
finalized: Public generic functions
finalized: Public generic functions
find-child: Public ordinary functions
find-children: Public ordinary functions
find-fastcall-method: Public ordinary functions
find-fastcall-static-method: Private ordinary functions
find-qt-class-name: Public ordinary functions
fsetf: Public macros
function: Public macros
Function, %build-with-finalizing-construct: Private ordinary functions
Function, %determined-type-method-name-arg: Private ordinary functions
Function, %make-slots-bound-proper: Private ordinary functions
Function, %method-see: Private ordinary functions
Function, %specified-type-method-name-arg: Private ordinary functions
Function, (setf fdefinition): Public ordinary functions
Function, (setf menu-content-type): Public ordinary functions
Function, (setf method-declaration): Public ordinary functions
Function, (setf qclass-copy-function): Private ordinary functions
Function, (setf qclass-finalize-function): Private ordinary functions
Function, (setf qclass-print-function): Private ordinary functions
Function, (setf translator): Private ordinary functions
Function, (setf widget-actions): Public ordinary functions
Function, build-menu-content: Public ordinary functions
Function, call-finalizers: Public ordinary functions
Function, call-initializers: Public ordinary functions
Function, capitalize-on: Public ordinary functions
Function, cascade-option-changes: Private ordinary functions
Function, check-qt-superclass-compatibility: Private ordinary functions
Function, cl-constant-name: Private ordinary functions
Function, cl-constructor-name: Private ordinary functions
Function, cl-method-name: Private ordinary functions
Function, cl-operator-name: Private ordinary functions
Function, cl-static-method-name: Private ordinary functions
Function, cl-type-for: Public ordinary functions
Function, cl-variable-name: Private ordinary functions
Function, clean-method-name: Private ordinary functions
Function, clear-method-info: Public ordinary functions
Function, compile-constant: Private ordinary functions
Function, compile-constructor: Private ordinary functions
Function, compile-method: Private ordinary functions
Function, compile-operator: Private ordinary functions
Function, compile-static-method: Private ordinary functions
Function, compile-wrapper: Public ordinary functions
Function, compute-qclass-precedence-list: Private ordinary functions
Function, copy-qobject: Public ordinary functions
Function, default-application-name: Public ordinary functions
Function, describe-copy-method: Public ordinary functions
Function, describe-finalize-method: Public ordinary functions
Function, describe-print-method: Public ordinary functions
Function, determined-type-method-name: Public ordinary functions
Function, direct-qsubclass-p: Public ordinary functions
Function, dispatch-by-qclass: Public ordinary functions
Function, ecl-type-for: Public ordinary functions
Function, emit-compilation-note: Public ordinary functions
Function, emit-operator-call: Private ordinary functions
Function, ensure-cl-function-name: Private ordinary functions
Function, ensure-class: Public ordinary functions
Function, ensure-completable-qclass: Private ordinary functions
Function, ensure-list: Private ordinary functions
Function, ensure-methods: Private ordinary functions
Function, ensure-methods-processed: Public ordinary functions
Function, ensure-q+-method: Public ordinary functions
Function, ensure-qapplication: Public ordinary functions
Function, ensure-qclass: Public ordinary functions
Function, ensure-qobject: Public ordinary functions
Function, enumerate-method-descriptors: Public ordinary functions
Function, eqt-class-name: Public ordinary functions
Function, eqt-type-of: Public ordinary functions
Function, fdefinition: Public ordinary functions
Function, finalize-qobject: Public ordinary functions
Function, find-child: Public ordinary functions
Function, find-children: Public ordinary functions
Function, find-fastcall-method: Public ordinary functions
Function, find-fastcall-static-method: Private ordinary functions
Function, find-qt-class-name: Public ordinary functions
Function, fuse-alists: Public ordinary functions
Function, fuse-plists: Public ordinary functions
Function, generate-constant-docstring: Private ordinary functions
Function, generate-method-docstring: Private ordinary functions
Function, generate-qclass-dispatch-lambda: Private ordinary functions
Function, generic-signal: Public ordinary functions
Function, load-all-smoke-modules: Public ordinary functions
Function, loaded-smoke-modules: Public ordinary functions
Function, main-window-exec: Private ordinary functions
Function, make-chord: Public ordinary functions
Function, make-gc-finalized: Public ordinary functions
Function, make-reader-for-function: Private ordinary functions
Function, map-compile-all: Public ordinary functions
Function, map-layout: Public ordinary functions
Function, maybe-delete-qobject: Public ordinary functions
Function, maybe-unwrap-quote: Private ordinary functions
Function, menu-content-type: Public ordinary functions
Function, method-declaration: Public ordinary functions
Function, method-needed-p: Private ordinary functions
Function, method-symbol: Public ordinary functions
Function, normalize-bindings: Private ordinary functions
Function, print-qobject: Public ordinary functions
Function, process-all-methods: Public ordinary functions
Function, process-list-arg: Private ordinary functions
Function, process-method: Public ordinary functions
Function, process-q+-setter: Private ordinary functions
Function, q+-compile-and-load: Public ordinary functions
Function, q+-symbol-name: Private ordinary functions
Function, q+-symbol-p: Private ordinary functions
Function, q+apropos: Public ordinary functions
Function, qclass-class-list: Private ordinary functions
Function, qclass-copy-function: Private ordinary functions
Function, qclass-finalize-function: Private ordinary functions
Function, qclass-precedence-list: Public ordinary functions
Function, qclass-precedence-set: Private ordinary functions
Function, qclass-print-function: Private ordinary functions
Function, qinstancep: Public ordinary functions
Function, qmethod-bogus-p: Private ordinary functions
Function, qmethod-cast-operator-p: Private ordinary functions
Function, qmethod-globalspace-p: Private ordinary functions
Function, qmethod-operator-p: Private ordinary functions
Function, qmethod-translatable-operator-p: Private ordinary functions
Function, qobject-alive-p: Public ordinary functions
Function, qt-type-for: Public ordinary functions
Function, qt-type-of: Public ordinary functions
Function, qtools-library-p: Private ordinary functions
Function, read-function: Private ordinary functions
Function, read-list-until: Private ordinary functions
Function, read-name: Private ordinary functions
Function, read-paren: Private ordinary functions
Function, remove-finalizer: Public ordinary functions
Function, remove-initializer: Public ordinary functions
Function, remove-menu-content-type: Public ordinary functions
Function, remove-method-declaration: Public ordinary functions
Function, remove-override: Public ordinary functions
Function, remove-qclass-copy-function: Private ordinary functions
Function, remove-qclass-finalize-function: Private ordinary functions
Function, remove-qclass-print-function: Private ordinary functions
Function, remove-signal: Public ordinary functions
Function, remove-slot: Public ordinary functions
Function, remove-subwidget: Public ordinary functions
Function, remove-translator: Private ordinary functions
Function, remove-widget-class-option: Public ordinary functions
Function, repopulate-class-map: Private ordinary functions
Function, set-effective-option: Private ordinary functions
Function, set-widget-class-option: Public ordinary functions
Function, setup-widget-class: Private ordinary functions
Function, signal-method-for-name: Private ordinary functions
Function, slot-initializer-symbol: Private ordinary functions
Function, softly-redefine-widget-class: Public ordinary functions
Function, specified-type-method-name: Public ordinary functions
Function, split: Public ordinary functions
Function, string-starts-with-p: Private ordinary functions
Function, substring-type-p: Private ordinary functions
Function, subwidget-initializer-symbol: Private ordinary functions
Function, sweep-layout: Public ordinary functions
Function, target-package-symbol-string: Private ordinary functions
Function, target-symbol: Private ordinary functions
Function, to-method-name: Public ordinary functions
Function, to-qbyte-array: Public ordinary functions
Function, to-readtable-case: Private ordinary functions
Function, to-type-name: Public ordinary functions
Function, translate-name: Public ordinary functions
Function, translator: Private ordinary functions
Function, widget-actions: Public ordinary functions
Function, widget-class-option-p: Public ordinary functions
Function, write-everything-to-file: Public ordinary functions
Function, write-forms: Private ordinary functions
Function, write-qclass-name: Private ordinary functions
Function, write-qmethod-name: Private ordinary functions
fuse-alists: Public ordinary functions
fuse-plists: Public ordinary functions

G
generate-constant-docstring: Private ordinary functions
generate-method-docstring: Private ordinary functions
generate-qclass-dispatch-lambda: Private ordinary functions
Generic Function, (setf clashing-qt-superclass): Public generic functions
Generic Function, (setf clashing-superclass): Public generic functions
Generic Function, (setf message): Private generic functions
Generic Function, (setf name): Private generic functions
Generic Function, (setf parent): Public generic functions
Generic Function, (setf priority): Private generic functions
Generic Function, (setf requested-qt-superclass): Public generic functions
Generic Function, (setf translation): Private generic functions
Generic Function, (setf value): Public generic functions
Generic Function, (setf widget-class-direct-finalizers): Private generic functions
Generic Function, (setf widget-class-direct-initializers): Private generic functions
Generic Function, (setf widget-class-direct-options): Public generic functions
Generic Function, (setf widget-class-extern-options): Public generic functions
Generic Function, (setf widget-class-finalizers): Public generic functions
Generic Function, (setf widget-class-initializers): Public generic functions
Generic Function, clashing-qt-superclass: Public generic functions
Generic Function, clashing-superclass: Public generic functions
Generic Function, construct: Public generic functions
Generic Function, copy: Public generic functions
Generic Function, finalize: Public generic functions
Generic Function, finalized: Public generic functions
Generic Function, message: Private generic functions
Generic Function, name: Private generic functions
Generic Function, parent: Public generic functions
Generic Function, priority: Private generic functions
Generic Function, requested-qt-superclass: Public generic functions
Generic Function, translation: Private generic functions
Generic Function, unbox: Public generic functions
Generic Function, value: Public generic functions
Generic Function, widget-class-direct-finalizers: Private generic functions
Generic Function, widget-class-direct-initializers: Private generic functions
Generic Function, widget-class-direct-options: Public generic functions
Generic Function, widget-class-extern-options: Public generic functions
Generic Function, widget-class-finalizers: Public generic functions
Generic Function, widget-class-initializers: Public generic functions
generic-signal: Public compiler macros
generic-signal: Public ordinary functions

I
initialize-instance: Public standalone methods
initialize-instance: Public standalone methods
initialize-instance: Public standalone methods

L
load-all-smoke-modules: Public ordinary functions
loaded-smoke-modules: Public ordinary functions

M
Macro, connect!: Public macros
Macro, defgeneric: Public macros
Macro, define-1->1-translator: Public macros
Macro, define-copy-method: Public macros
Macro, define-extern-inline-fun: Private macros
Macro, define-extern-macro: Private macros
Macro, define-finalizable: Public macros
Macro, define-finalize-method: Public macros
Macro, define-finalizer: Public macros
Macro, define-initializer: Public macros
Macro, define-menu: Public macros
Macro, define-menu-content-type: Public macros
Macro, define-method-declaration: Public macros
Macro, define-object: Public macros
Macro, define-override: Public macros
Macro, define-print-method: Public macros
Macro, define-qclass-copy-function: Private macros
Macro, define-qclass-dispatch-function: Public macros
Macro, define-qclass-finalize-function: Private macros
Macro, define-qclass-print-function: Private macros
Macro, define-qt-constant: Private macros
Macro, define-signal: Public macros
Macro, define-signal-method: Public macros
Macro, define-simple-translator: Public macros
Macro, define-slot: Public macros
Macro, define-subobject: Public macros
Macro, define-subwidget: Public macros
Macro, define-translator: Public macros
Macro, define-widget: Public macros
Macro, defmethod: Public macros
Macro, defun: Public macros
Macro, disconnect!: Public macros
Macro, do-layout: Public macros
Macro, fast-call: Public macros
Macro, fast-direct-call: Public macros
Macro, fast-static-call: Public macros
Macro, fsetf: Public macros
Macro, function: Public macros
Macro, named-lambda: Private macros
Macro, print-unreadable-qobject: Private macros
Macro, q+: Public macros
Macro, q+fun: Public macros
Macro, qclass=case: Public macros
Macro, qtenumcase: Public macros
Macro, qtypecase: Public macros
Macro, setf: Public macros
Macro, signal!: Public macros
Macro, with-all-slots-bound: Public macros
Macro, with-args: Private macros
Macro, with-call-stack: Public macros
Macro, with-compile-and-run: Private macros
Macro, with-finalizing: Public macros
Macro, with-finalizing*: Public macros
Macro, with-gc-finalized: Public macros
Macro, with-main-window: Public macros
Macro, with-output-to-target-symbol: Private macros
Macro, with-slots-bound: Public macros
Macro, with-traps-masked: Private macros
Macro, with-widget-class: Public macros
main-window-exec: Private ordinary functions
make-chord: Public ordinary functions
make-gc-finalized: Public ordinary functions
make-reader-for-function: Private ordinary functions
map-compile-all: Public ordinary functions
map-layout: Public ordinary functions
maybe-delete-qobject: Public ordinary functions
maybe-unwrap-quote: Private ordinary functions
menu-content-type: Public ordinary functions
message: Private generic functions
message: Private generic functions
Method, (setf clashing-qt-superclass): Public generic functions
Method, (setf clashing-superclass): Public generic functions
Method, (setf message): Private generic functions
Method, (setf name): Private generic functions
Method, (setf parent): Public generic functions
Method, (setf parent): Public generic functions
Method, (setf priority): Private generic functions
Method, (setf requested-qt-superclass): Public generic functions
Method, (setf translation): Private generic functions
Method, (setf value): Public generic functions
Method, (setf value): Public generic functions
Method, (setf widget-class-direct-finalizers): Private generic functions
Method, (setf widget-class-direct-initializers): Private generic functions
Method, (setf widget-class-direct-options): Public generic functions
Method, (setf widget-class-extern-options): Public generic functions
Method, (setf widget-class-finalizers): Public generic functions
Method, (setf widget-class-initializers): Public generic functions
Method, clashing-qt-superclass: Public generic functions
Method, clashing-superclass: Public generic functions
Method, compute-effective-slot-definition: Public standalone methods
Method, construct: Public generic functions
Method, copy: Public generic functions
Method, copy: Public generic functions
Method, direct-slot-definition-class: Public standalone methods
Method, discover-entry-point: Public standalone methods
Method, effective-slot-definition-class: Public standalone methods
Method, finalize: Public generic functions
Method, finalize: Public generic functions
Method, finalize: Public generic functions
Method, finalize: Public generic functions
Method, finalize: Public generic functions
Method, finalize: Public generic functions
Method, finalize: Public generic functions
Method, finalize: Public generic functions
Method, finalize-inheritance: Public standalone methods
Method, finalized: Public generic functions
Method, initialize-instance: Public standalone methods
Method, initialize-instance: Public standalone methods
Method, initialize-instance: Public standalone methods
Method, message: Private generic functions
Method, name: Private generic functions
Method, parent: Public generic functions
Method, perform: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, priority: Private generic functions
Method, reinitialize-instance: Public standalone methods
Method, requested-qt-superclass: Public generic functions
Method, translation: Private generic functions
Method, unbox: Public generic functions
Method, validate-superclass: Public standalone methods
Method, validate-superclass: Public standalone methods
Method, validate-superclass: Public standalone methods
Method, validate-superclass: Public standalone methods
Method, value: Public generic functions
Method, value: Public generic functions
Method, widget-class-direct-finalizers: Private generic functions
Method, widget-class-direct-initializers: Private generic functions
Method, widget-class-direct-options: Public generic functions
Method, widget-class-extern-options: Public generic functions
Method, widget-class-finalizers: Public generic functions
Method, widget-class-initializers: Public generic functions
method-declaration: Public ordinary functions
method-needed-p: Private ordinary functions
method-symbol: Public ordinary functions

N
name: Private generic functions
name: Private generic functions
named-lambda: Private macros
normalize-bindings: Private ordinary functions

P
parent: Public generic functions
parent: Public generic functions
perform: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-qobject: Public ordinary functions
print-unreadable-qobject: Private macros
priority: Private generic functions
priority: Private generic functions
process-all-methods: Public ordinary functions
process-list-arg: Private ordinary functions
process-method: Public ordinary functions
process-q+-setter: Private ordinary functions

Q
q+: Public macros
q+-compile-and-load: Public ordinary functions
q+-symbol-name: Private ordinary functions
q+-symbol-p: Private ordinary functions
q+apropos: Public ordinary functions
q+fun: Public macros
qclass-class-list: Private ordinary functions
qclass-copy-function: Private ordinary functions
qclass-finalize-function: Private ordinary functions
qclass-precedence-list: Public ordinary functions
qclass-precedence-set: Private ordinary functions
qclass-print-function: Private ordinary functions
qclass=case: Public macros
qinstancep: Public ordinary functions
qmethod-bogus-p: Private ordinary functions
qmethod-cast-operator-p: Private ordinary functions
qmethod-globalspace-p: Private ordinary functions
qmethod-operator-p: Private ordinary functions
qmethod-translatable-operator-p: Private ordinary functions
qobject-alive-p: Public ordinary functions
qt-type-for: Public ordinary functions
qt-type-of: Public ordinary functions
qtenumcase: Public macros
qtools-library-p: Private ordinary functions
qtypecase: Public macros

R
read-function: Private ordinary functions
read-list-until: Private ordinary functions
read-name: Private ordinary functions
read-paren: Private ordinary functions
reinitialize-instance: Public standalone methods
remove-finalizer: Public ordinary functions
remove-initializer: Public ordinary functions
remove-menu-content-type: Public ordinary functions
remove-method-declaration: Public ordinary functions
remove-override: Public ordinary functions
remove-qclass-copy-function: Private ordinary functions
remove-qclass-finalize-function: Private ordinary functions
remove-qclass-print-function: Private ordinary functions
remove-signal: Public ordinary functions
remove-slot: Public ordinary functions
remove-subwidget: Public ordinary functions
remove-translator: Private ordinary functions
remove-widget-class-option: Public ordinary functions
repopulate-class-map: Private ordinary functions
requested-qt-superclass: Public generic functions
requested-qt-superclass: Public generic functions

S
set-effective-option: Private ordinary functions
set-widget-class-option: Public ordinary functions
setf: Public macros
setup-widget-class: Private ordinary functions
signal!: Public macros
signal-method-for-name: Private ordinary functions
slot-initializer-symbol: Private ordinary functions
softly-redefine-widget-class: Public ordinary functions
specified-type-method-name: Public ordinary functions
split: Public ordinary functions
string-starts-with-p: Private ordinary functions
substring-type-p: Private ordinary functions
subwidget-initializer-symbol: Private ordinary functions
sweep-layout: Public ordinary functions

T
target-package-symbol-string: Private ordinary functions
target-symbol: Private ordinary functions
to-method-name: Public ordinary functions
to-qbyte-array: Public ordinary functions
to-readtable-case: Private ordinary functions
to-type-name: Public ordinary functions
translate-name: Public ordinary functions
translation: Private generic functions
translation: Private generic functions
translator: Private ordinary functions

U
unbox: Public generic functions
unbox: Public generic functions

V
validate-superclass: Public standalone methods
validate-superclass: Public standalone methods
validate-superclass: Public standalone methods
validate-superclass: Public standalone methods
value: Public generic functions
value: Public generic functions
value: Public generic functions

W
widget-actions: Public ordinary functions
widget-class-direct-finalizers: Private generic functions
widget-class-direct-finalizers: Private generic functions
widget-class-direct-initializers: Private generic functions
widget-class-direct-initializers: Private generic functions
widget-class-direct-options: Public generic functions
widget-class-direct-options: Public generic functions
widget-class-extern-options: Public generic functions
widget-class-extern-options: Public generic functions
widget-class-finalizers: Public generic functions
widget-class-finalizers: Public generic functions
widget-class-initializers: Public generic functions
widget-class-initializers: Public generic functions
widget-class-option-p: Public ordinary functions
with-all-slots-bound: Public macros
with-args: Private macros
with-call-stack: Public macros
with-compile-and-run: Private macros
with-finalizing: Public macros
with-finalizing*: Public macros
with-gc-finalized: Public macros
with-main-window: Public macros
with-output-to-target-symbol: Private macros
with-slots-bound: Public macros
with-traps-masked: Private macros
with-widget-class: Public macros
write-everything-to-file: Public ordinary functions
write-forms: Private ordinary functions
write-qclass-name: Private ordinary functions
write-qmethod-name: Private ordinary functions


A.3 Variables

Jump to:   %   *  
C   D   E   F   I   M   N   P   R   S   T  
Index Entry  Section

%
%object: Public classes

*
*application-name*: Private special variables
*boot-hooks*: Public special variables
*build-hooks*: Public special variables
*deployment-location*: Public special variables
*generated-modules*: Public special variables
*menu-content-types*: Private special variables
*method*: Public special variables
*method-declarations*: Private special variables
*operator-map*: Public special variables
*qclass-copy-functions*: Private special variables
*qclass-finalize-functions*: Private special variables
*qclass-precedence-list*: Private special variables
*qclass-precedence-lists*: Private special variables
*qclass-print-functions*: Private special variables
*qmethods*: Public special variables
*qt-class-map*: Public special variables
*qt-class-vector*: Public special variables
*quit-hooks*: Public special variables
*smoke-modules*: Public special variables
*smoke-modules-to-reload*: Public special variables
*standard-function-reader*: Private special variables
*standard-paren-reader*: Private special variables
*target-package*: Public special variables
*translators*: Private special variables
*widget*: Public special variables
*widget-actions*: Private special variables

C
clashing-qt-superclass: Public conditions
clashing-superclass: Public conditions

D
direct-finalizers: Public classes
direct-initializers: Public classes
direct-options: Public classes

E
extern-options: Public classes

F
finalized: Public classes
finalizers: Public classes

I
initializers: Public classes

M
message: Public conditions

N
name: Private classes

P
priority: Private classes

R
requested-qt-superclass: Public conditions

S
Slot, %object: Public classes
Slot, clashing-qt-superclass: Public conditions
Slot, clashing-superclass: Public conditions
Slot, direct-finalizers: Public classes
Slot, direct-initializers: Public classes
Slot, direct-options: Public classes
Slot, extern-options: Public classes
Slot, finalized: Public classes
Slot, finalizers: Public classes
Slot, initializers: Public classes
Slot, message: Public conditions
Slot, name: Private classes
Slot, priority: Private classes
Slot, requested-qt-superclass: Public conditions
Slot, translation: Private classes
Slot, type-name: Private conditions
Special Variable, *application-name*: Private special variables
Special Variable, *boot-hooks*: Public special variables
Special Variable, *build-hooks*: Public special variables
Special Variable, *deployment-location*: Public special variables
Special Variable, *generated-modules*: Public special variables
Special Variable, *menu-content-types*: Private special variables
Special Variable, *method*: Public special variables
Special Variable, *method-declarations*: Private special variables
Special Variable, *operator-map*: Public special variables
Special Variable, *qclass-copy-functions*: Private special variables
Special Variable, *qclass-finalize-functions*: Private special variables
Special Variable, *qclass-precedence-list*: Private special variables
Special Variable, *qclass-precedence-lists*: Private special variables
Special Variable, *qclass-print-functions*: Private special variables
Special Variable, *qmethods*: Public special variables
Special Variable, *qt-class-map*: Public special variables
Special Variable, *qt-class-vector*: Public special variables
Special Variable, *quit-hooks*: Public special variables
Special Variable, *smoke-modules*: Public special variables
Special Variable, *smoke-modules-to-reload*: Public special variables
Special Variable, *standard-function-reader*: Private special variables
Special Variable, *standard-paren-reader*: Private special variables
Special Variable, *target-package*: Public special variables
Special Variable, *translators*: Private special variables
Special Variable, *widget*: Public special variables
Special Variable, *widget-actions*: Private special variables

T
translation: Private classes
type-name: Private conditions


A.4 Data types

Jump to:   C   D   F   G   I   N   P   Q   R   S   T   U   W  
Index Entry  Section

C
cl+qt: The cl+qt package
Class, finalizable: Public classes
Class, finalizable-class: Public classes
Class, finalizable-direct-slot-definition: Private classes
Class, finalizable-effective-slot-definition: Private classes
Class, finalizable-slot: Public classes
Class, gc-finalized: Public classes
Class, qt-program-op: Public classes
Class, translator: Private classes
Class, widget: Public classes
Class, widget-class: Public classes
class-map.lisp: The qtools/class-map․lisp file
compilation-note: Public conditions
Condition, compilation-note: Public conditions
Condition, invalid-qt-superclass-hierarchy: Public conditions
Condition, unknown-type-name: Private conditions
copying.lisp: The qtools/copying․lisp file

D
deploy.lisp: The qtools/deploy․lisp file
dispatch.lisp: The qtools/dispatch․lisp file
documentation.lisp: The qtools/documentation․lisp file
dynamic.lisp: The qtools/dynamic․lisp file

F
fast-call.lisp: The qtools/fast-call․lisp file
File, class-map.lisp: The qtools/class-map․lisp file
File, copying.lisp: The qtools/copying․lisp file
File, deploy.lisp: The qtools/deploy․lisp file
File, dispatch.lisp: The qtools/dispatch․lisp file
File, documentation.lisp: The qtools/documentation․lisp file
File, dynamic.lisp: The qtools/dynamic․lisp file
File, fast-call.lisp: The qtools/fast-call․lisp file
File, finalizable.lisp: The qtools/finalizable․lisp file
File, gc-finalized.lisp: The qtools/gc-finalized․lisp file
File, generate.lisp: The qtools/generate․lisp file
File, name-translation.lisp: The qtools/name-translation․lisp file
File, package.lisp: The qtools/package․lisp file
File, precompile.lisp: The qtools/precompile․lisp file
File, printing.lisp: The qtools/printing․lisp file
File, qtools.asd: The qtools/qtools․asd file
File, readtable.lisp: The qtools/readtable․lisp file
File, signal.lisp: The qtools/signal․lisp file
File, toolkit.lisp: The qtools/toolkit․lisp file
File, widget-convenience.lisp: The qtools/widget-convenience․lisp file
File, widget-defmethod.lisp: The qtools/widget-defmethod․lisp file
File, widget-menu.lisp: The qtools/widget-menu․lisp file
File, widget.lisp: The qtools/widget․lisp file
finalizable: Public classes
finalizable-class: Public classes
finalizable-direct-slot-definition: Private classes
finalizable-effective-slot-definition: Private classes
finalizable-slot: Public classes
finalizable.lisp: The qtools/finalizable․lisp file
function: Public types

G
gc-finalized: Public classes
gc-finalized.lisp: The qtools/gc-finalized․lisp file
generate.lisp: The qtools/generate․lisp file

I
invalid-qt-superclass-hierarchy: Public conditions

N
name-translation.lisp: The qtools/name-translation․lisp file

P
Package, cl+qt: The cl+qt package
Package, qtools: The qtools package
package.lisp: The qtools/package․lisp file
precompile.lisp: The qtools/precompile․lisp file
printing.lisp: The qtools/printing․lisp file

Q
qt-program-op: Public classes
qtools: The qtools system
qtools: The qtools package
qtools.asd: The qtools/qtools․asd file

R
readtable.lisp: The qtools/readtable․lisp file

S
signal.lisp: The qtools/signal․lisp file
System, qtools: The qtools system

T
toolkit.lisp: The qtools/toolkit․lisp file
translator: Private classes
Type, function: Public types

U
unknown-type-name: Private conditions

W
widget: Public classes
widget-class: Public classes
widget-convenience.lisp: The qtools/widget-convenience․lisp file
widget-defmethod.lisp: The qtools/widget-defmethod․lisp file
widget-menu.lisp: The qtools/widget-menu․lisp file
widget.lisp: The qtools/widget․lisp file