The qtools Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The qtools Reference Manual

This is the qtools Reference Manual, version 1.0.0, generated automatically by Declt version 2.3 "Robert April" on Tue Feb 20 09:14:25 2018 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

About Qtools Build Status

Qtools is a collection of utilities to help development with CommonQt. There are a lot of things in there, from name mapping over garbage handling to widget class definition. Some tools are straightforward, others are quite complex. I'll try to explain everything as best I can.

Fundamentals

There are three layers working beneath Qtools, of which you need to know about in order to understand how to use the various facilities Qtools offers.

Qt

Qt is a gigantic toolkit that mainly concerns itself with GUI creation. It is cross-platform and written in C++. While its size and large user-base means that it is very mature and usable for pretty much any kind of GUI, the fact that it's written in C++ makes things complicated. The usual way to interoperate with C++ libraries and projects is to create a C API wrapper.

Smoke

And this is what Smoke does. It generates a C wrapper so that other languages can make use of Qt through C-FFI. Smoke is divided up into a bunch of modules, each being associated with a part of Qt, such as qtcore, qtgui, qtopengl, phonon, etc.

CommonQt

The heavy lifting and ground-work that is required to interface with Smoke (and thus with Qt) is done by CommonQt. By itself, CommonQt offers a complete framework to create Qt GUIs from Common Lisp out.

Qtools

Unfortunately, working with CommonQt itself is a bit awkward. While it offers everything you need, the way you have to make use of it is sub-par. Qtools attempts to help with this by offering another layer over CommonQt to smooth everything out. However, since you might not like certain parts of the Qtools ecosystem, it should be possible for you to only use the features you like, rather than being forced to use everything. So, you can always mix and match "plain" CommonQt and Qtools extensions.

Getting Started

Qt

In case you already know Qt, you may skip this part and go straight to the next section. I'll briefly explain some of the core Qt concepts and how they fit together. However, you should still read the official Qt documentation for anything that's left unclear.

Since Qt is a C++ library it is heavily focused around classes and methods. At the top of the class hierarchy sits QObject. Almost all classes in Qt inherit from this. The more important one for us however is the QWidget class, which already gives you everything you need to get started. It can act as a window or be contained in other widgets. It has all the sizing mechanics and is properly hooked into the event system that allows you to catch when keys are pressed, the window is resized, and so forth.

Usually you create your new widgets by subclassing something like QWidget and then overriding methods to do what you want or simply attach other widgets to it and connect them up so that they can communicate to each other via the signal system. Classes have slots and signals. Signals are a form of method signature that describe a list of arguments and their type. Slots are the corresponding methods that perform actions when a signal reaches them. Wiring things up functions by connecting a signal and a source instance to a slot and a target instance. When then a signal is signalled onto the source instance, the target instance's slot method is called.

And that's pretty much all of the core mechanics that you need to know about. For everything else, you usually refer to the documentation page for the specific class involved and see what kind of methods or signals you can use to do what you want. Seriously, the docs are good. I use them constantly while developing.

Qtools

Before getting started with explaining the details on the various parts of Qtools, I'll go through a basic project setup of a project using it.

First you will want an ASDF system to define your project. In its dependencies it should contain :qtools and the smoke modules you require, usually just :qtcore and :qtgui.

(asdf:defsystem qtools-intro
  ...
  :depends-on (:qtools :qtcore :qtgui))

If you want to just try things out on the REPL real quick, just (ql:quickload '(qtools qtcore qtgui)) should suffice.

Then of course you'll usually want a package to put all your stuff in. Instead of :use #:cl you will most likely want to :use #:cl+qt. This package combines the symbols of the common-lisp base package, the commonqt package, and qtools. Thus all the symbols and functions you usually need for development are already included.

(defpackage #:qtools-intro
  (:use #:cl+qt)
  (:export #:main))

CommonQt, and Qtools itself, require a few extensions to the standard reader syntax. For this reason you will want to change the readtable using named-readtables:in-readtable, which cl+qt includes. Readtable changes are on a per-file basis, so you need both an in-package and an in-readtable call on every file.

(in-package #:qtools-intro)
(in-readtable :qtools)

This sets up everything you need to get started writing an actual GUI. So let's do that as well. In Qt things are organised as widgets. Windows are widgets, buttons are widgets, text fields are widgets, etc. Qtools mirrors this.

(define-widget main-window (QWidget)
  ())

This define-widget form is syntactically equivalent to defclass. The only change is that the first argument in the superclass list is the Qt class to inherit from. Now we'll want to add some things to display in the widget.

(define-subwidget (main-window name) (q+:make-qlineedit main-window)
  (setf (q+:placeholder-text name) "Your name please."))

(define-subwidget (main-window go) (q+:make-qpushbutton "Go!" main-window))

This adds a QLineEdit widget called name to the main-window and sets its placeholder text to "Your name please.". The second form adds a button called go with a label of "Go!". Simple stuff. The body of the define-subwidget form can contain any number of statements. By default, the symbols of all the other subwidgets and slots defined prior to the define-subwidget form are bound to their corresponding values. This is useful if you for example need to define a layout, as we will do now.

(define-subwidget (main-window layout) (q+:make-qhboxlayout main-window)
  (q+:add-widget layout name)
  (q+:add-widget layout go))

This sets up the displaying part of our GUI, but so far we haven't made it react to anything yet. Reacting to events in Qt happens through signals and slots. Slots are functions that receive signals, and signals are event carriers.

(define-signal (main-window name-set) (string))

(define-slot (main-window go) ()
  (declare (connected go (pressed)))
  (declare (connected name (return-pressed)))
  (signal! main-window (name-set string) (q+:text name)))

(define-slot (main-window name-set) ((new-name string))
  (declare (connected main-window (name-set string)))
  (q+:qmessagebox-information main-window "Greetings" (format NIL "Good day to you, ~a!" new-name)))

We're doing things a bit roundabout here to illustrate creating signals. define-signal introduces a new signal called name-set that takes a single string as argument. We then define a new slot that is connected to the go button's pressed signal (which has no arguments) as well as the name field's return-pressed. We then simply fetch the current text of our name field and send it out again with our custom signal. The second slot catches this signal again and uses it to display a message box.

You can now try and see what kind of magical wonders you have created by using with-main-window to launch everything: (with-main-window (window 'main-window)). This will block until your window is closed, as Qt needs to capture the thread to handle events.

And that's that. The only thing we didn't take a look at here is define-override, which allows you to define override functions for your Qt classes. So, if you for example want to manually draw onto a widget you can override its paintEvent method using this.

(define-override (main-window paint-event) (event)
  (declare (ignore event))
  (with-finalizing ((painter (q+:make-qpainter main-window)))
    (q+:fill-rect painter (q+:rect main-window) (q+:qt.white))))

This'll make the background of our window completely white. The important thing to note here is the with-finalizing. What has been rather well hidden from you so far, is that as Qt is a C++ framework, you will have to do manual memory management. Qtools makes this a lot easier by offering macros and automations to take most of it off of your hands. For example, all the sub widgets we defined are automatically deleted once the main window is.

A general note about developing with Qtools/CommonQt: While custom function bodies such as from qt-slots, overrides, initializers, and finalizers reside on the CL side and can thus be redefined at any time and take effect immediately, adding or removing qt-slots and overrides will not affect already created instances. This is to say, if you run your application and recompile your override, the effect will be visible immediately. But if you add a new slot, override, or signal, the existing instance will not have them. This is due to the fact that these things need to be tied to the C++ class, which will not update existing instances when it is changed, like CLOS usually does. This means that if you change a running widget by adding new components, you need to recreate or restart it to see the effects.

Deployment

So, you've built a neat little Qt application and you would like to deploy it and ship it to people that aren't developers. For this, you will want to dump a binary and bundle it together with the necessary shared libraries. Qtools will take care of this for you, to the point where it becomes very trivial to do.

You will need an ASDF system that compiles your program and add the following options to your system definition:

:defsystem-depends-on (:qtools)
:build-operation "qt-program-op"
:build-pathname "executable-name"
:entry-point "my-package:my-launch-function"

You can change the string of :build-pathname to whatever pathname-name you'd like your executable to have. You should change the stirng of :entry-point to be a designator for an external symbol that is either your main window class name, or a function that handles the launching of your GUI.

Once you have updated your ASD, you should launch a clean instance of your implementation from the command line -- make sure not to load slime or anything else that creates threads. Then simply invoke (asdf:operate :build-op :system-name :force T). For sbcl, that would be:

sbcl --eval "(asdf:operate :build-op :system-name :force T)"

This will compile your system, gather some info on it, copy the necessary shared libraries to the deployment folder, and finally dump an image with your system ready to go. It should put it all into a new bin folder within your project's root. If everything went right, you should be able to just launch the executable within and be greeted with your nice GUI. You can then just ZIP up the build folder and ship that-- it should contain all of the necessary shared library dependencies to run outside of your development environment.

As an example for a working system that can be deployed, have a look at halftone or cl-gamepad-visualizer.

For more customisation and other details of the deployment system, see the underlying library Deploy.

If you need to debug the built binary on Windows, the default behaviour is a bit annoying, as it causes Windows to completely prevent all terminal output. To circumvent this, you must either run it under mintty, or deploy it with the feature :qtools-deploy-console set before the build-op.

Qtools Components

Name Conversion

Common Lisp and C++ follow different naming conventions for classes, variables, methods, and types. Qtools offers a couple of functions to attempt to translate between the two. Finding a Qt class can be done with find-qt-class-name. It searches a static table of known Qt classes (*qt-class-map*) by first stripping all dashes from the name, and then case-insensitively finding a matching name.

Translating method names can be done through to-method-name, which translates dashes to mean that the next character should be in uppercase. So foo-bar is fooBar. In case you pass it a string instead of a symbol however, it will not do any translation. This is important to take care of edge-cases, where this primitive translation would prohibit using a certain name. If you need a method signature instead of just a name, there are specified-type-method-name that takes a name and a list of type specifiers, and determined-type-method-name, which attempts to determine the type of the arguments, rather than requiring type specifiers directly.

Types are translated using qt-type-of, eqt-type-of, qt-type-for, and to-type-name. Where qt-type-for translates a type specifier and qt-type-of tries to determine the type through a value. Reversing from a Qt type specifier to a CL type is possible with cl-type-for and ecl-type-for.

Object Handling

In C++ there usually is no garbage collector, so you need to carefully clean up yourself or you'll create a memory leak. In Common Lisp we're used to the luxury of not having to worry about this, thanks to garbage collection. Sadly, we cannot use the garbage collector to also take care of C++ objects, as they live in a different world not governed by us. So, garbage collection of Qt objects is still our own worry.

To make this all just a smidgeon easier, Qtools introduces a system of finalizables, the central point of which is the finalize generic function. This function should take care of all necessary cleanup when an object is no longer needed. For qobjects, this means running eventual cleanup (through finalize-using-class) and then being deleted, thus properly removed from memory. However, finalize can not only be used for Qt objects, but for anything else as well. Especially interesting here are finalizable objects, whose slots can specify an additional argument :finalized, which dictates whether finalize is run on the slot's value when the class instance is finalized.

Often times we only need Qt instances for a certain lexical context of code. For this case, with-finalizing (and with-finalizing*) can be used, which is a counterpart to let that calls finalize on all its bindings once the form exits. This will take care of most cases. For cases where the instance may escape, or has to stay bound in a closure, there's with-gc-finalized. This wraps the value of each binding in a gc-finalized object. Using such a container, we can use Common Lisp's garbage collector to keep track of the references and, once the object is garbage collected it calls finalize on its inner value, ensuring proper removal. The with-gc-finalized uses a symbol-macrolet to ensure that you don't have to worry about the boxing. However, if you manually use gc-finalized objects, there's the make-gc-finalized and unbox functions (with corresponding reader macros #> and #< in the :qtools read-table).

While this kind of system takes care of a lot of cases, it's still not perfect and it may happen that you accidentally create a memory leak somewhere. I wish there was an easier way, but alas, life is difficult. You can try to solve this kind of situation by debugging Qtools and keeping track of which objects get finalized and which don't.

Another occasional task is to copy an object instance. Qtools offers a copy and copy-using-class methods which handle proper copying for a couple of Qt objects, but sadly by far not all. If you want to use the copying system for a class that isn't handled by Qtools by default, you can define your own using define-copy-method.

Qtools will handle the printing of QObject instances as well and provides you with a mechanism of defining print methods for a qclass, just like you normally would for CL classes by print-object. Simply use define-print-method.

Widgets

Qt deals with widgets. As such, making everything associated with them simple and easy to use should be a primary objective. Qtools' widget system attempts to do exactly that. The central part to this is the define-widget macro. This expands to a defclass with the following effects: It sets widget-class as the metaclass, sets the first item of the superclass list as the qt-superclass, and injects widget as a superclass, if it isn't one already. This means that essentially you can use anything you could in a standard defclass without having to worry about the necessary default options.

However, just with a single define-widget you won't get far ahead. You still need to use CommonQt's way of declaring slots, signals, and overrides, which is quite cumbersome. You can do that of course, but there is a more convenient method, which is to use define-slot, define-signal, and define-override. These essentially translate to class options, albeit in a detached way. Each of these define statements is of the following syntax:

(define-* (widget-class name) arglist &body body)

Some of them take optional extra arguments in the name-list, such as a method-name in the case of define-slot and define-override. In the case of define-signal the body is discarded. However, even with these extensions things are rather cumbersome: You need to manually define slots for each of the widgets you want to use inside your widget class, and define their behaviour in an initialize-instance function. This is unwieldy, which is why Qtools also adds define-initializer, define-finalizer, and define-subwidget. The first two follow in signature to the above minus the arglist and do what you might expect them to do: handle initialization and finalization. The initializer and finalizer forms take an optional priority argument in their name-list. The higher, the sooner. define-subwidget on the other hand looks like this:

(define-subwidget (widget-class name) initform &body body)

And its effects are two-fold. First, it adds a finalized slot to the widget-class called name. Then, it adds an initializer (with priority 10) that sets the slot-value to the value of initform and then evaluates the body forms. This by itself takes care of the repetitive slot and initializer definition, but without an extra helper called with-slots-bound, it would still be annoying to write functions, as you would have to reference widgets using slot-value everywhere. with-slots-bound is like with-slots, but it binds all direct class-slot values to their respective slot names. Every define-* function's body is automatically wrapped in a with-slots-bound, to make this convenience possible.

If you do not like this behaviour, due to potential symbol clashes and general confusion that might arise from the implicit action, you can instead use cl+qt:defmethod and declare statements. This is actually what all the define-* (with the exception of define-signal) expand to: A cl+qt:defmethod with an appropriate declaration inserted into the body. The cl+qt:defmethod behaves exaclty like cl:defmethod with the exception of allowing the handling of custom declaration forms. Qtools defines the following declarations: slot, override, initializer, and finalizer. In the case of a slot definition, an extra declaration called connected is also available. The effects of the declarations are as you might expect, and have the following signatures:

(slot slot-name args)
(connected slot-name (signal-name &rest args))
(override &optional method-name)
(initializer &optional (priority 0))
(finalizer &optional (priority 0))

The user may define additional declarations using define-method-declaration.

At this point it is useful to note about the general startup sequence of a widget. Once make-instance is called, it calls to initialize-instance. Qtools defines a primary method on this specialized on the widget class. It then immediately calls the next method (call-next-method), followed by construct which should call qt:new, instantiating the C++ parts. Following that are the initializers in the order of their priority (highest goes first). This means that if you (for some reason) define an :after method on initialize-instance for your own widget, it will be run after all initializers have completed. For finalization it is the same: all finalizers are run before your own finalize method is run. However, if you define a :before method on finalize for your class, it will be run before the :finalized slots are finalized, otherwise all primary and :after methods should not access :finalized slots anymore. If you absolutely do need to do things before normal initialization or finalization, you can define an :around method.

One last widget-related definition form is define-menu, which is a very convenient way of specifying menus:

(define-menu (my-widget File)
  (:item ("Open..." (ctrl o))
    (open-file))
  (:menu recent-files)
  (:separator)
  (:item ("Save" (ctrl s))
    (save-file))
  (:item ("Save As..." (ctrl alt s))
    (save-file NIL))
  (:menu "Export"
    (:item "PNG" (save-file NIL "png")))
  (:separator)
  (:item ("Quit" (ctrl q))
    (#_close widget)))

Out of the box, it supports :item, :menu, and :separator components. The item takes a name, which can be either a string for a label, a list of string and keyboard mnemonic, or a symbol indicating the class slot that contains the item widget, and it takes a body of forms to execute if the item is triggered. Menus take a name as a string and a body of components to contain, or a symbol indicating the slot that contains the menu widget. New components can be added with define-menu-content-type.

If your widget has a Qt superclass to whose constructor you would like to pass certain arguments, you can do so by adding a method on construct that calls qt:new with the arguments you need. You can also use a shorthand to do the same by adding a (:constructor ..) option to your widget definition form. This expands to a defmethod form that binds all slots (with-all-slots-bound) and otherwise just contains a call to qt:new supplying the arguments of the option form verbatim. In effect this means that any unquoted symbol in the option denotes a slot reference. Note that the call to construct happens before the widget initializers are run. Thus you will not be able to use slot values that are set by subwidgets or initializers.

As a final touch, Qtools offers macros for connecting slots and emitting signals. These translate to CommonQt's emit-signal and connect functions, and thus just offer a bit of syntactic sugar. They're called signal! and connect!. Their use is simple enough:

 (connect! input (text-edited string) widget (text-changed string))
 (signal! input (text-edited string) "Eyyyy")

An experimental variant for the adventurous is generic-signal, which attempts to determine the argument types by their values at run-time. It does therefore not require specifying the type explicitly, but might instead screw up and choose a wrong type for the signal and thus fail to emit.

Q+

By default with CommonQt, calling Qt methods happens with the #_ reader macro. This requires you to follow the proper case of the class and method names. Having this kind of mixture of conventions in the code is a bit jarring. While Qtools offers solutions to deal with the discrepancies of defining your own classes and widgets using the various define-* macros, Q+ fixes the method calling discrepancy. In order to use Q+ you have a choice of either using the q+ macro, or using the :qtools read-table. Using the q+ macro directly an example translates like this:

(let ((widget (#_new QWidget)))
  (#_setWindowTitle widget "Hello!")
  (#_show widget)
  (#_exec *qapplication*))

(let ((widget (q+ make-qwidget)))
  (q+ set-window-title widget "Hello!")
  (q+ show widget)
  (q+ exec *qapplication*))

And the same using the readtable:

(let ((widget (q+:make-qwidget)))
  (q+:set-window-title widget "Hello!")
  (q+:show widget)
  (q+:exec *qapplication*))

The difference is minimal in the typed code. However, the second approach will give you the convenience of letting the editor display the possible arguments and a docstring linking to the Qt methods. The second example is read by the Common Lisp reader to the first example. There is therefore no code difference in how the two work. If you use the cl+qt package, you can also take advantage of an extended setf macro. Using it, the second line would look like so:

(setf (q+ window-title widget) "Hello!")

Some of the setter functions require multiple values to be set at once. The updated setf can also deal with that:

(setf (q+ window painter) (values 0 0 100 100))

The setf has extra support for q+, but is otherwise identical to cl:setf and actually expands to that for all other places.

In order to access enum values, you simply use the class name followed by a dot and the enum name. Constructors are the class name prefixed with "make". Static functions are the class name, a dash, and the method name in the standard translation scheme.

(q+:qt.blue)
(q+:make-qpushbutton "Foo!")
(q+:qmessagebox-information parent "!" "hello!")

For the specific arguments, names, and everything else, refer to the Qt4.8 documentation. It's very good, trust me. The only thing you need to be aware of is the name conversion rules that Q+ uses to determine the proper Lisp symbol to use:

For Q+ to work seamlessly in conjunction with ASDF systems and compiling/loading code, you have to make sure that the smoke modules are set up correctly.

q+ and the reader extension dynamically compile wrapper functions for the Qt methods you access. You can, however, also precompile all possible methods for the currently active set of smoke modules. To do this, you can either :depends-on (:q+) or compile a source file using write-everything-to-file and include it in your ASDF system. If you choose this approach, you will not need to switch the readtable or use the q+ macro, as the package will be available fully populated.

Smoke Modules

In order to be able to use the various parts of Qt, the corresponding smoke modules need to be loaded. By default CommonQt loads qtcore and qtgui when make-qapplication is called. However, if you want to use, say, the OpenGL parts you'll also need qtopengl.

Qtools provides ASDF systems for all the different smoke modules. That way, you can simply push the modules you want into your project's ASDF system dependencies and it'll ensure that the modules are available at compile and load time. Having the modules loaded at both times is especially important for Q+ to work properly. An example system making use of this would look like

(asdf:defsystem foo
  ...
  :depends-on (:qtcore :qtgui))

For a list of available smoke modules, see *smoke-modules*.

Fast Calling

In some cases it is vital to minimise overhead to a method call. Since usually dispatch is dynamic at run-time and un/marshalling of arguments and return values is involved, the standard way of calling methods might be too slow. In that case, you can use Qtools' fast-call mechanism to perform a method call as quickly as possible. At a cost, naturally.

(let ((size (q+:make-qsize 100 100)))
  (fast-call (set-height QSize int) size 200)
  size)

Fast-calling is possible if you know the exact method signature to call and are willing to translate the arguments to their proper required CFFI types. In the case of passing QObjects, you must pass their pointer. You can get that pointer by qt::qobject-pointer.

Examples

A couple of example applications using Qtools can be found in the examples/ folder: qtools-evaluator, qtools-titter, qtools-melody, and qtools-opengl. Each of them can be loaded by their name, and launched using the main function from their package.

Extending Qtools

Copying and Finalizing

In order to account for your own objects and operations you can extend the copy and finalize functions by using define-copy-method and define-finalize-method or defmethod directly. The two define macros bring the convenience of automatically resolving to a Qt class (and thus using copy/finalize-using-class) if possible, making it all look a bit cleaner.

(define-copy-method (instance QPixmap)
  "Creates a new QPixmap using QPixmap::copy (deep copy)."
  (#_copy instance (#_rect instance)))

Since copying and finalizing are operations associated with a certain amount of ambiguity, it is advisable to always write documentation strings for your copy/finalize methods. That way users can get a better idea of what will happen by reading about it using describe-copy-method and describe-finalize-method respectively.

Adding defmethod declarations

Using define-method-declaration you can add your own processing to method declarations. Your function should extract the necessary information from its declaration arguments and the *method* form. Each method declaration processing function should return a single form (like a macro) to be put before the resulting defmethod. The existing declaration processors are really short:

(define-method-declaration override (&optional name)
  (let ((slot (qtools:to-method-name (or name (form-fiddle:lambda-name *method*)))))
    (with-widget-class (widget-class)
      `(set-widget-class-option ',widget-class :override '(,slot ,name)))))

In this example we're using form-fiddle to parse the method form. Using a library like that to ensure proper destructuring is important, as otherwise it's easy to accidentally butcher the method form, or get the wrong information.

Extending the menu definition

The menu definition form allows for arbitrary content types, so you may add new ones yourself by using define-menu-content-type. Each content type definition can return two values: an initform and a side-form. The initform will be put into the initialization function for the menu and thus evaluated when the widget is created. The side-form is put alongside the initializer definition and thus evaluated during compilation. If your menu type needs to modify the widget class in some way, that should be done through the side-forms. If it needs to connect signals, add items, or perform similar actions that involve Qt, that should go into the initform. You can call the expansion of other component types using build-menu-content. During the time your content-type function is run, *widget* is bound to the class-name of the widget and during initialization it is bound to the actual widget instance.

Qtools Concepts

Qtools has grown to be a large library with a lot of rather complicated concepts. I will try to describe them here, in order to retain some information in non-code form and make things clearer to the average user. It is not necessary to read and understand this section to use Qtools, but it may be useful to be aware of the underlying ideas and functionality that make Qtools work.

Finalizables

A finalizable is implemented using two classes, one serving as the metaclass and the other as a superclass. The metaclass is required in order to allow a custom slot type that supports the :finalized argument. The superclass is necessary in order to allow methods such as finalize to operate on instances of the finalizable classes. The handling of the finalized slots is done through a general method on finalize that scans through the slots of the class instance and then calls finalize on each slot for which the definition is set to be :finalized. This makes finalization of class slots automatic and convenient.

Since finalizables don't add any metaclass properties, there is no need to manually calculate inheritance order. However, as with all custom slot definitions, the slot properties must be copied over from the direct-slot instance to the effective slot. In the case of finalizable-class this happens in compute-effective-slot-definition.

In order to support finalizing of Qt class instances that don't have a CL class equivalent, the finalize method is extended wit ha finalize-using-class that is dispatched to using the Qt class and the instance of a qobject instance is passed to finalize.

Widgets

As with finalizables, the widget is implemented using two classes, the widget-class metaclass and the widget superclass. These both inherit from the finalizable equivalents. The main crux of the widget-class lies in its widget-class-direct-options and widget-class-extern-options. The direct options are the options that are passed to a re/ initialize-instance (and thus also to defclass). They're caught in the appropriately specialised methods and then stored on the class. The effect of this is that we can fully recompute the class definition at any time, and potentially add or remove options without influencing the original defclass statement. This is where the extern-options come in.

Using set-widget-class-option options can be added to the class definition dynamically at any point in the program. This function then adds the option to the class' extern-options and then calls reinitialize-instance, which in turn causes the class to get effectively redefined outside of its defclass form. This redefinition also allows us to change CommonQt class options. Using this we can create forms outside of the original defclass that act as if they were actually options in the defclass form.

Qtools effectively only provides two forms that do this: define-signal and defmethod. The define-signal is relatively straightforward and simply expands to a class option set to add a new signal option. The defmethod is an extensible machine in itself.

What's special about the cl+qt:defmethod is that it inspects the declaration forms in the method body. It then checks for each declaration form whether a handler function exist and if so, calls that function. Such a method-declaration function can then return forms to be put into the macroexpansion of the cl+qt:defmethod, before the resulting cl:defmethod. The processed declaration is then left out of the cl:defmethodform as it is assumed that it isn't a standard common lisp declaration. However, the declaration function also has the ability to change the contents of the cl:defmethod form itself, by manipulating *method*. This allows the declaration to output special handling for the method body, for example.

This kind of extensible declaration mechanism is necessary both to allow further evolving of Qtools in the future as well as adaptation by users. It also offers a very "native-like" way of specifying external effects of a method. Qtools uses this construct then to allow definition of slots, overrides, finalizers, and initializers.

In case the user doesn't appreciate the defmethod way, Qtools then provides define-* alternative functions that simply wrap over defmethod, establish some default bindings, and take care of naming and specialising the method.

The define-subwidget deserves special attention here, as it does more work than the rest. A large part of defining widgets is adding sub-components to it, which is a task that usually involves a lot of repetition or awkward function sharing: Setting up a slot to hold the instance, defining or using an initializer to set it up. define-subwidget makes this both distributed and simple by both taking care of setting up an appropriate initializer function, and automatically adding the slot to the class using, again, set-widget-class-option. This slot is also always automatically set to be finalized in order to ensure that all widgets are properly cleaned up when the GUI is no longer needed.

A minor problem regarding this approach is the same problem that appears with all of CL's definition forms. While developing incrementally, merely removing the definition form from the source file, will not actually remove it from the image. This can trip developers up, as definitions will still be active later. In this case it means having widgets still sticking around, or initializers running, etc. For this purpose there are corresponding remove-* functions to all the define-* functions to allow easy removal. This part cannot possibly be automated due to the nature of Common Lisp, but it is at least simple to correct should the need arise.

Q+

CommonQt's way of dealing with method calls is the simple and most direct way of doing it. The first possible alternative to remove the need for typing method names in their corresponding case would be to simply introduce a different reader macro that automatically translates a example-function-like name into exampleFunction as is done already in other parts of Qtools. However, this has two downsides, the first being that there does not exist a 1:1 mapping of methods anywhere. The dynamic computation of the function name means that there isn't a full correspondence table anywhere. The second downside is that methods are still not passable as first-class objects.

The way to solve this is to generate actual CL wrapper functions to the method calls. This allows us to use them as first-class objects, have at least compile-time argument number checking, and have a linkage of wrapper name to Qt method by listing it in the docstring.

In order to achieve this, there are two possible choices. First, the entirety of all possible wrappers can be computed once, and then subsequently loaded into the image and used directly. However, this creates two new problems. Computing all wrappers, compiling them, and loading them, takes a long time and subsequently litters the image with thousands of functions and symbols that won't ever be used in the program. Then, we have a problem with the smoke modules, as we need to know which modules will be used in a potential application ahead of time, load them all, and then generate the wrappers. We cannot generate wrappers for each module separately, as the methods from different classes share the same wrapper functions. This means that whenever a different set of modules is needed, the wrappers need to be regenerated, recompiled, and reloaded. A lot of time and space goes to waste with this. However, this approach also has an advantage: As all functions are always available, it is easy to develop with. Arguments and docstrings will be readily available through the editor. Qtools offers this approach through q+-compile-and-load.

The second approach is to dynamically only compile what is needed. That way, the image only ever contains wrappers for function that are actually called (at some point). However, this complicates things a lot. When a function is compiled that calls such a function, it doesn't exist yet. Even worse, when the form is read, the symbol for the function does not exist yet and isn't external! In order to catch this problem, a modified reader macro is necessary. This reader macro will detect when a call to a wrapper function is made, and instead transform it into a macro call that then sees to it that the wrapper will be created. Modifying the reader in such a way is a heavy change, and should only be used sparingly, however there is no alternative here. Qtools does not force you to use this reader extension, you can always just use the macro directly.

However, dynamic compilation complications don't end there. Since we never dump the function to a file, it only ever exists in the environment it was compiled in. That means, if you compile a function that then dynamically generates the wrapper function, the wrapper won't be available anymore at load time. Qtools solves this issue with a trick. The q+ macro expands to a load-time-value form that then generates the wrapper function. That way, the wrapper will always be available at load- and execution time, while posing no overhead to the execution time, as it will return a value to that won't impact anything.

Function referencing gets the same problems as function calling, so the Qtools readtable also contains an overridden #' reader macro to handle that. In the case of a wrapper call, it expands to Q+FUN which in turn expands to a load-time-value form that generates and returns the function object.

As is probably obvious by now, Qtools also implements the second approach. Therefore, the choice as a user is yours: You can statically precompile everything and use it directly, or you an use the dynamic on the fly compilation using either a readtable expansion, or a simple macro. The concepts to make this all possible are rather complex, but the actual function wrapper compilations are quite straight-forward. The system is currently not suited for extension, but I see no need to allow that as the kind of Qt methods that can exist are fixed and Q+ should handle all that are relevant.

Q+ does one last thing to fix the "issue" of having setters instead of being able to use setf. For this purpose it has an extended setf macro that checks if a place is a function in the Q+ package. if so, this place/value pair is instead expanded to a call to the appropriate wrapper function with the function name transformed. However, that's not the only reason to do this. The second is that some setters require multiple arguments to be set at once. Usually, cl:setf allows for cases like these by permitting setf expanders to accept multiple values. However, the number of values is fixed, and there's no way to dynamically know how many values where passed. Since Q+ needs to dispatch based on the number of values, this is not a viable approach. Therefore, with cl+qt:setf a (values ..) value form is specially treated and its arguments are inlined into the wrapper call. This also means that it isn't possible to use multiple values of a returning function as the values to a setter call, however while that is an inconsistency, I don't think it will be a big issue. If it turns out to be problematic in the later run, this will have to be changed to a dynamic analysis at run-time, which is an overhead I wanted to avoid.

Support

Currently the following implementations are tested and supported by Qtools:

You can run it on x86_64 Linux, OS X, and Windows, where SBCL on Linux is the recommended platform.

It may or may not work more or less smoothly on other implementations and platforms depending on MOP and CommonQt support and general implementation quirks.


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

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


Previous: , Up: Systems   [Contents][Index]

2.1 qtools

Maintainer

Nicolas Hafner <shinmera@tymoon.eu>

Author

Nicolas Hafner <shinmera@tymoon.eu>

Home Page

https://github.com/Shinmera/qtools

License

Artistic

Description

A collection of tools to aid in development with CommonQt.

Version

1.0.0

Dependencies
Source

qtools.asd (file)

Components

Next: , Previous: , Up: Top   [Contents][Index]

3 Files

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


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.1 qtools.asd

Location

qtools.asd

Systems

qtools (system)


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.2 qtools/package.lisp

Parent

qtools (system)

Location

package.lisp

Packages

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.3 qtools/toolkit.lisp

Dependency

package.lisp (file)

Parent

qtools (system)

Location

toolkit.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.4 qtools/class-map.lisp

Dependency

toolkit.lisp (file)

Parent

qtools (system)

Location

class-map.lisp

Exported Definitions
Internal Definitions

repopulate-class-map (function)


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.5 qtools/name-translation.lisp

Dependency

class-map.lisp (file)

Parent

qtools (system)

Location

name-translation.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.6 qtools/dispatch.lisp

Dependency

name-translation.lisp (file)

Parent

qtools (system)

Location

dispatch.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.7 qtools/finalizable.lisp

Dependency

dispatch.lisp (file)

Parent

qtools (system)

Location

finalizable.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.8 qtools/gc-finalized.lisp

Dependency

finalizable.lisp (file)

Parent

qtools (system)

Location

gc-finalized.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.9 qtools/copying.lisp

Dependency

gc-finalized.lisp (file)

Parent

qtools (system)

Location

copying.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.10 qtools/printing.lisp

Dependency

copying.lisp (file)

Parent

qtools (system)

Location

printing.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.11 qtools/signal.lisp

Dependency

printing.lisp (file)

Parent

qtools (system)

Location

signal.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.12 qtools/widget.lisp

Dependency

signal.lisp (file)

Parent

qtools (system)

Location

widget.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.13 qtools/widget-defmethod.lisp

Dependency

widget.lisp (file)

Parent

qtools (system)

Location

widget-defmethod.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.14 qtools/widget-convenience.lisp

Dependency

widget-defmethod.lisp (file)

Parent

qtools (system)

Location

widget-convenience.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.15 qtools/widget-menu.lisp

Dependency

widget-convenience.lisp (file)

Parent

qtools (system)

Location

widget-menu.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.16 qtools/readtable.lisp

Dependency

widget-menu.lisp (file)

Parent

qtools (system)

Location

readtable.lisp

Internal Definitions

make-reader-for-function (function)


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.17 qtools/generate.lisp

Dependency

readtable.lisp (file)

Parent

qtools (system)

Location

generate.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.18 qtools/dynamic.lisp

Dependency

generate.lisp (file)

Parent

qtools (system)

Location

dynamic.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.19 qtools/precompile.lisp

Dependency

dynamic.lisp (file)

Parent

qtools (system)

Location

precompile.lisp

Exported Definitions
Internal Definitions

write-forms (function)


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.20 qtools/deploy.lisp

Dependency

precompile.lisp (file)

Parent

qtools (system)

Location

deploy.lisp

Exported Definitions
Internal Definitions

qtools-library-p (function)


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.21 qtools/fast-call.lisp

Dependency

deploy.lisp (file)

Parent

qtools (system)

Location

fast-call.lisp

Exported Definitions

Previous: , Up: Lisp files   [Contents][Index]

3.1.22 qtools/documentation.lisp

Dependency

fast-call.lisp (file)

Parent

qtools (system)

Location

documentation.lisp


Next: , Previous: , Up: Top   [Contents][Index]

4 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

4.1 cl+qt

Source

package.lisp (file)

Nickname

org.shirakumo.qtools+common-lisp

Use List
Exported Definitions

Previous: , Up: Packages   [Contents][Index]

4.2 qtools

Source

package.lisp (file)

Nickname

org.shirakumo.qtools

Use List
Used By List

cl+qt

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Definitions

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


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

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

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

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

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

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

Special Variable: *operator-map*

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

Package

qtools

Source

generate.lisp (file)

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

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

Special Variable: *qt-class-vector*

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

Package

qtools

Source

class-map.lisp (file)

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

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

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

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

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


Next: , Previous: , Up: Exported definitions   [Contents][Index]

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

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

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

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

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

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

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

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

Macro: define-menu (WIDGET-CLASS 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 (file)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Macro: defun NAME ARGS &body BODY
Package

cl+qt

Source

dynamic.lisp (file)

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

Macro: do-layout (WIDGET LAYOUT) &body BODY

Iterate over all WIDGETs on LAYOUT.

Package

qtools

Source

toolkit.lisp (file)

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. FAST-CALL also will not read out the return value.

METHOD-DESCRIPTOR ::= (name class-name arg-type*)
object — The instance of the class to call a method on.
Must match the given class-name.
args — The arguments to call the method with. Their types must match the ones given in the arg-types and must be prepared. Especially objects must be translated to pointers manually. See QT::QOBJECT-POINTER.
name — The Q+ name of the method being called.
class-name — The Qt class name of the class the method belongs to.

At compile time a matching method number is searched for using FIND-FASTCALL-METHOD. If no method can be found that matches the class, name, and argument types, an error is signalled.
The fast call procedure creates a stack for the arguments by WITH-CALL-STACK. It then uses FAST-DIRECT-CALL on the found method number, class, and stack to perform the actual call to the method.

See FIND-FASTCALL-METHOD
See FAST-DIRECT-CALL
See WITH-CALL-STACK

Package

qtools

Source

fast-call.lisp (file)

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

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

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

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

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

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

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

Macro: qtypecase INSTANCE &body CASES

Analogous to CL:TYPECASE, but for Qt classes.

See QINSTANCEP

Package

qtools

Source

toolkit.lisp (file)

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

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

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

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

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

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

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

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

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

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


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.3 Compiler macros

Compiler Macro: generic-signal OBJECT FUNCTION &rest ARGS
Package

qtools

Source

signal.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.4 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 (file)

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

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

Function: capitalize-on CHARACTER STRING &optional REPLACEMENT START-CAPITALIZED
Package

qtools

Source

toolkit.lisp (file)

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

Function: clear-method-info ()

Clears the *QMETHODS* table.

See QTOOLS:*QMETHODS*

Package

qtools

Source

generate.lisp (file)

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

Function: copy-qobject INSTANCE
Package

qtools

Source

copying.lisp (file)

Function: default-application-name ()

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

Package

qtools

Source

toolkit.lisp (file)

Function: describe-copy-method CLASS

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

Package

qtools

Source

copying.lisp (file)

Function: describe-finalize-method CLASS

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

Package

qtools

Source

finalizable.lisp (file)

Function: describe-print-method CLASS

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

Package

qtools

Source

printing.lisp (file)

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

Function: direct-qsubclass-p QCLASS MAYBE-SUPERCLASS

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

Package

qtools

Source

dispatch.lisp (file)

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

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

Function: emit-compilation-note FORMAT-STRING &rest ARGS
Package

qtools

Source

toolkit.lisp (file)

Function: ensure-class THING

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

Package

qtools

Source

toolkit.lisp (file)

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

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

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

Function: ensure-qclass THING
Package

qtools

Source

toolkit.lisp (file)

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

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

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

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

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

Writer

(setf fdefinition) (function)

Function: (setf fdefinition) FUNCTION NAME
Package

cl+qt

Source

dynamic.lisp (file)

Reader

fdefinition (function)

Function: finalize-qobject INSTANCE
Package

qtools

Source

finalizable.lisp (file)

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

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

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

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

Function: fuse-alists &rest ALISTS-LISTS
Package

qtools

Source

toolkit.lisp (file)

Function: fuse-plists &rest PLISTS-LISTS
Package

qtools

Source

toolkit.lisp (file)

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

Function: load-all-smoke-modules &rest MODS

Loads all the smoke modules as passed.

See QT:ENSURE-SMOKE

Package

qtools

Source

generate.lisp (file)

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

Function: make-chord CHORD

Transforms CHORD into a keychord string, if possible.

Package

qtools

Source

widget-menu.lisp (file)

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

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

Function: map-layout FUNCTION LAYOUT

Map all widgets and layouts on LAYOUT onto FUNCTION.

Package

qtools

Source

toolkit.lisp (file)

Function: maybe-delete-qobject OBJECT

Deletes the object if possible.

Package

qtools

Source

toolkit.lisp (file)

Function: menu-content-type NAME

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

Package

qtools

Source

widget-menu.lisp (file)

Writer

(setf menu-content-type) (function)

Function: (setf menu-content-type) FUNCTION 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 (file)

Reader

menu-content-type (function)

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

Writer

(setf method-declaration) (function)

Function: (setf method-declaration) FUNCTION 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 (file)

Reader

method-declaration (function)

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

Function: print-qobject INSTANCE STREAM
Package

qtools

Source

printing.lisp (file)

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

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

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

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

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

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

Function: qobject-alive-p OBJECT

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

Package

qtools

Source

toolkit.lisp (file)

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

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

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

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

Function: remove-menu-content-type NAME

Removes the menu content type NAME.

Package

qtools

Source

widget-menu.lisp (file)

Function: remove-method-declaration NAME

Remove the method declaration processor function of NAME.

Package

qtools

Source

widget-defmethod.lisp (file)

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

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

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

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

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

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

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

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

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

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

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

Function: to-qbyte-array VECTOR

Translates an unsigned-byte 8 vector into a QByteArray.

Package

qtools

Source

toolkit.lisp (file)

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

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

Function: widget-actions CLASS

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

Package

qtools

Source

widget-menu.lisp (file)

Writer

(setf widget-actions) (function)

Function: (setf widget-actions) ACTIONS CLASS

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

Package

qtools

Source

widget-menu.lisp (file)

Reader

widget-actions (function)

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

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


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.5 Generic functions

Generic Function: clashing-qt-superclass CONDITION
Generic Function: (setf clashing-qt-superclass) NEW-VALUE CONDITION
Package

qtools

Methods
Method: clashing-qt-superclass (CONDITION invalid-qt-superclass-hierarchy)
Method: (setf clashing-qt-superclass) NEW-VALUE (CONDITION invalid-qt-superclass-hierarchy)
Source

widget.lisp (file)

Generic Function: clashing-superclass CONDITION
Generic Function: (setf clashing-superclass) NEW-VALUE CONDITION
Package

qtools

Methods
Method: clashing-superclass (CONDITION invalid-qt-superclass-hierarchy)
Method: (setf clashing-superclass) NEW-VALUE (CONDITION invalid-qt-superclass-hierarchy)
Source

widget.lisp (file)

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

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

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

Methods
Method: finalize (WIDGET widget) before
Source

widget.lisp (file)

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 Function: finalized OBJECT
Package

qtools

Methods
Method: finalized (FINALIZABLE-SLOT finalizable-slot)

automatically generated reader method

Source

finalizable.lisp (file)

Generic Function: parent OBJECT

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

Package

qtools

Source

toolkit.lisp (file)

Writer

(setf parent) (generic function)

Methods
Method: parent (OBJECT qobject)
Generic Function: (setf parent) VALUE OBJECT
Package

qtools

Reader

parent (generic function)

Methods
Method: (setf parent) VALUE (OBJECT qobject)
Source

toolkit.lisp (file)

Generic Function: requested-qt-superclass CONDITION
Generic Function: (setf requested-qt-superclass) NEW-VALUE CONDITION
Package

qtools

Methods
Method: requested-qt-superclass (CONDITION invalid-qt-superclass-hierarchy)
Method: (setf requested-qt-superclass) NEW-VALUE (CONDITION invalid-qt-superclass-hierarchy)
Source

widget.lisp (file)

Generic Function: unbox OBJECT
Package

qtools

Methods
Method: unbox (GC-FINALIZED gc-finalized)

automatically generated reader method

Source

gc-finalized.lisp (file)

Generic Function: value OBJECT

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

Package

qtools

Source

toolkit.lisp (file)

Writer

(setf value) (generic function)

Methods
Method: value (WIDGET widget)
Source

widget.lisp (file)

Method: value (OBJECT qobject)
Generic Function: (setf value) VALUE OBJECT
Package

qtools

Source

toolkit.lisp (file)

Reader

value (generic function)

Methods
Method: (setf value) VALUE (WIDGET widget)
Source

widget.lisp (file)

Method: (setf value) VALUE (OBJECT qobject)
Generic Function: 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

Writer

(setf widget-class-direct-options) (generic function)

Methods
Method: widget-class-direct-options (WIDGET-CLASS widget-class)

automatically generated reader method

Source

widget.lisp (file)

Generic Function: (setf widget-class-direct-options) NEW-VALUE OBJECT
Package

qtools

Reader

widget-class-direct-options (generic function)

Methods
Method: (setf widget-class-direct-options) NEW-VALUE (WIDGET-CLASS widget-class)

automatically generated writer method

Source

widget.lisp (file)

Generic Function: 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

Writer

(setf widget-class-extern-options) (generic function)

Methods
Method: widget-class-extern-options (WIDGET-CLASS widget-class)

automatically generated reader method

Source

widget.lisp (file)

Generic Function: (setf widget-class-extern-options) NEW-VALUE OBJECT
Package

qtools

Reader

widget-class-extern-options (generic function)

Methods
Method: (setf widget-class-extern-options) NEW-VALUE (WIDGET-CLASS widget-class)

automatically generated writer method

Source

widget.lisp (file)

Generic Function: 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

Writer

(setf widget-class-finalizers) (generic function)

Methods
Method: widget-class-finalizers (WIDGET-CLASS widget-class)

automatically generated reader method

Source

widget.lisp (file)

Generic Function: (setf widget-class-finalizers) NEW-VALUE OBJECT
Package

qtools

Reader

widget-class-finalizers (generic function)

Methods
Method: (setf widget-class-finalizers) NEW-VALUE (WIDGET-CLASS widget-class)

automatically generated writer method

Source

widget.lisp (file)

Generic Function: 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

Writer

(setf widget-class-initializers) (generic function)

Methods
Method: widget-class-initializers (WIDGET-CLASS widget-class)

automatically generated reader method

Source

widget.lisp (file)

Generic Function: (setf widget-class-initializers) NEW-VALUE OBJECT
Package

qtools

Reader

widget-class-initializers (generic function)

Methods
Method: (setf widget-class-initializers) NEW-VALUE (WIDGET-CLASS widget-class)

automatically generated writer method

Source

widget.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.6 Conditions

Condition: compilation-note ()
Package

qtools

Source

toolkit.lisp (file)

Direct superclasses

compiler-note (condition)

Direct methods
  • message (method)
  • message (method)
Direct slots
Slot: message
Initargs

:message

Initform

(quote (error "message required."))

Readers

message (generic function)

Writers

(setf message) (generic function)

Condition: invalid-qt-superclass-hierarchy ()
Package

qtools

Source

widget.lisp (file)

Direct superclasses

error (condition)

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

:requested-qt-superclass

Readers

requested-qt-superclass (generic function)

Writers

(setf requested-qt-superclass) (generic function)

Slot: clashing-qt-superclass
Initargs

:clashing-qt-superclass

Readers

clashing-qt-superclass (generic function)

Writers

(setf clashing-qt-superclass) (generic function)

Slot: clashing-superclass
Initargs

:clashing-superclass

Readers

clashing-superclass (generic function)

Writers

(setf clashing-superclass) (generic function)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.7 Classes

Class: finalizable ()

A class for finalizable objects.

Package

qtools

Source

finalizable.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods

finalize (method)

Class: finalizable-class ()

Metaclass for classes with finalizable slots.

Package

qtools

Source

finalizable.lisp (file)

Direct superclasses

standard-class (class)

Direct subclasses

widget-class (class)

Direct methods
  • effective-slot-definition-class (method)
  • direct-slot-definition-class (method)
  • compute-effective-slot-definition (method)
  • validate-superclass (method)
  • validate-superclass (method)
  • validate-superclass (method)
  • validate-superclass (method)
Class: finalizable-slot ()

Superclass for slots with a finalized option.

Package

qtools

Source

finalizable.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: finalized
Initargs

:finalized

Readers

finalized (generic function)

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

Direct superclasses

finalizable (class)

Direct methods
  • copy (method)
  • initialize-instance (method)
  • print-object (method)
  • unbox (method)
Direct slots
Slot: %object
Initargs

:object

Initform

(error "object required.")

Readers

unbox (generic function)

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

Direct superclasses

deploy-op (class)

Direct methods
  • perform (method)
  • discover-entry-point (method)
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 (file)

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

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

widget-class-direct-options (generic function)

Writers

(setf widget-class-direct-options) (generic function)

Slot: extern-options
Readers

widget-class-extern-options (generic function)

Writers

(setf widget-class-extern-options) (generic function)

Slot: direct-initializers
Initargs

:initializers

Readers

widget-class-direct-initializers (generic function)

Writers

(setf widget-class-direct-initializers) (generic function)

Slot: direct-finalizers
Initargs

:finalizers

Readers

widget-class-direct-finalizers (generic function)

Writers

(setf widget-class-direct-finalizers) (generic function)

Slot: initializers
Readers

widget-class-initializers (generic function)

Writers

(setf widget-class-initializers) (generic function)

Slot: finalizers
Readers

widget-class-finalizers (generic function)

Writers

(setf widget-class-finalizers) (generic function)


Previous: , Up: Exported definitions   [Contents][Index]

5.1.8 Types

Type: function ()
Package

cl+qt

Source

dynamic.lisp (file)


Previous: , Up: Definitions   [Contents][Index]

5.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.1 Special variables

Special Variable: *application-name*
Package

qtools

Source

toolkit.lisp (file)

Special Variable: *menu-content-types*
Package

qtools

Source

widget-menu.lisp (file)

Special Variable: *method-declarations*
Package

qtools

Source

widget-defmethod.lisp (file)

Special Variable: *qclass-copy-functions*
Package

qtools

Source

copying.lisp (file)

Special Variable: *qclass-finalize-functions*
Package

qtools

Source

finalizable.lisp (file)

Special Variable: *qclass-precedence-list*
Package

qtools

Source

dispatch.lisp (file)

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

Special Variable: *qclass-print-functions*
Package

qtools

Source

printing.lisp (file)

Special Variable: *standard-function-reader*
Package

qtools

Source

dynamic.lisp (file)

Special Variable: *standard-paren-reader*
Package

qtools

Source

dynamic.lisp (file)

Special Variable: *translators*

An ordered list of name translators.

See TRANSLATOR
See REMOVE-TRANSLATOR

Package

qtools

Source

name-translation.lisp (file)

Special Variable: *widget-actions*
Package

qtools

Source

widget-menu.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

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

Macro: define-extern-macro NAME LAMBDA-LIST &body BODY

Shorthand for EXPORT and DEFMACRO.

Package

qtools

Source

generate.lisp (file)

Macro: define-qclass-copy-function QCLASS ARGS &body BODY
Package

qtools

Source

copying.lisp (file)

Macro: define-qclass-finalize-function QCLASS ARGS &body BODY
Package

qtools

Source

finalizable.lisp (file)

Macro: define-qclass-print-function QCLASS ARGS &body BODY
Package

qtools

Source

printing.lisp (file)

Macro: define-qt-constant NAME (CLASS METHOD) &optional DOCUMENTATION
Package

qtools

Source

generate.lisp (file)

Macro: named-lambda NAME ARGS &body BODY
Package

qtools

Source

toolkit.lisp (file)

Macro: print-unreadable-qobject (OBJECT STREAM &key TYPE IDENTITY) &body BODY
Package

qtools

Source

printing.lisp (file)

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

Macro: with-compile-and-run &body BODY

Compiles BODY in a lambda and funcalls it.

Package

qtools

Source

toolkit.lisp (file)

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

Macro: with-traps-masked &body BODY
Package

qtools

Source

toolkit.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.3 Functions

Function: %build-with-finalizing-construct BINDER BINDINGS BODY
Package

qtools

Source

finalizable.lisp (file)

Function: %determined-type-method-name-arg STREAM ARG A B
Package

qtools

Source

name-translation.lisp (file)

Function: %make-slots-bound-proper WIDGET-CLASS BODY
Package

qtools

Source

widget-convenience.lisp (file)

Function: %method-see STREAM METHOD &rest REST
Package

qtools

Source

generate.lisp (file)

Function: %specified-type-method-name-arg STREAM ARG A B
Package

qtools

Source

name-translation.lisp (file)

Function: cascade-option-changes CLASS
Package

qtools

Source

widget.lisp (file)

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

Function: cl-constant-name METHOD
Package

qtools

Source

generate.lisp (file)

Function: cl-constructor-name METHOD
Package

qtools

Source

generate.lisp (file)

Function: cl-method-name METHOD
Package

qtools

Source

generate.lisp (file)

Function: cl-operator-name METHOD
Package

qtools

Source

generate.lisp (file)

Function: cl-static-method-name METHOD
Package

qtools

Source

generate.lisp (file)

Function: cl-variable-name METHOD
Package

qtools

Source

generate.lisp (file)

Function: clean-method-name METHOD

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

Package

qtools

Source

generate.lisp (file)

Function: compile-constant METHODS
Package

qtools

Source

generate.lisp (file)

Function: compile-constructor METHODS
Package

qtools

Source

generate.lisp (file)

Function: compile-method METHODS
Package

qtools

Source

generate.lisp (file)

Function: compile-operator METHODS
Package

qtools

Source

generate.lisp (file)

Function: compile-static-method METHODS
Package

qtools

Source

generate.lisp (file)

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

Function: emit-operator-call METHODS INSTANCE &rest ARGS
Package

qtools

Source

generate.lisp (file)

Function: ensure-cl-function-name NAME
Package

qtools

Source

toolkit.lisp (file)

Function: ensure-completable-qclass THING
Package

qtools

Source

toolkit.lisp (file)

Function: ensure-list A
Package

qtools

Source

toolkit.lisp (file)

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

Function: generate-constant-docstring METHOD

Generates a docstring for an enum constant.

Package

qtools

Source

generate.lisp (file)

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

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

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

Function: make-reader-for-function FUNCTION
Package

qtools

Source

readtable.lisp (file)

Function: maybe-unwrap-quote THING

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

Package

qtools

Source

toolkit.lisp (file)

Function: method-needed-p METHOD

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

Package

qtools

Source

generate.lisp (file)

Function: normalize-bindings BINDINGS
Package

qtools

Source

finalizable.lisp (file)

Function: process-list-arg ARG
Package

qtools

Source

signal.lisp (file)

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

Function: q+-symbol-name STRING
Package

qtools

Source

dynamic.lisp (file)

Function: q+-symbol-p STREAM
Package

qtools

Source

dynamic.lisp (file)

Function: qclass-class-list QCLASS

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

Package

qtools

Source

dispatch.lisp (file)

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

qtools

Source

copying.lisp (file)

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

qtools

Source

finalizable.lisp (file)

Function: qclass-precedence-set QCLASS

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

Package

qtools

Source

dispatch.lisp (file)

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

qtools

Source

printing.lisp (file)

Function: qmethod-bogus-p METHOD

Returns T if the METHOD is bogus and unneeded.

Package

qtools

Source

generate.lisp (file)

Function: qmethod-cast-operator-p METHOD

Returns T if the METHOD is a casting operator.

Package

qtools

Source

generate.lisp (file)

Function: qmethod-globalspace-p METHOD

Returns T if the method is from the QGlobalSpace class.

Package

qtools

Source

generate.lisp (file)

Function: qmethod-operator-p METHOD

Returns T if the METHOD is an operator.

Package

qtools

Source

generate.lisp (file)

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

Function: qtools-library-p LIB

Test whether the given CFFI library is a Qtools library.

Package

qtools

Source

deploy.lisp (file)

Function: read-function STREAM SUBCHAR ARG
Package

qtools

Source

dynamic.lisp (file)

Function: read-list-until CHAR STREAM &optional RECURSIVE-P
Package

qtools

Source

dynamic.lisp (file)

Function: read-name STREAM
Package

qtools

Source

dynamic.lisp (file)

Function: read-paren STREAM CHAR
Package

qtools

Source

dynamic.lisp (file)

Function: remove-qclass-copy-function QCLASS
Package

qtools

Source

copying.lisp (file)

Function: remove-qclass-finalize-function QCLASS
Package

qtools

Source

finalizable.lisp (file)

Function: remove-qclass-print-function QCLASS
Package

qtools

Source

printing.lisp (file)

Function: remove-translator NAME

Removes the translator by the given name.

See TRANSLATOR
See *TRANSLATORS*

Package

qtools

Source

name-translation.lisp (file)

Function: repopulate-class-map ()
Package

qtools

Source

class-map.lisp (file)

Function: set-effective-option CLASS SLOT DIRECT-VALUES &key DIRECT-SUPERCLASSES
Package

qtools

Source

widget.lisp (file)

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

Function: signal-method-for-name NAME
Package

qtools

Source

signal.lisp (file)

Function: slot-initializer-symbol SLOT
Package

qtools

Source

widget-defmethod.lisp (file)

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

Function: substring-type-p TEST TYPE
Package

qtools

Source

name-translation.lisp (file)

Function: subwidget-initializer-symbol WIDGET-CLASS NAME
Package

qtools

Source

widget-convenience.lisp (file)

Function: target-package-symbol-string &key EXTERN SYMBOL
Package

qtools

Source

dynamic.lisp (file)

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

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

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

Writer

(setf translator) (function)

Function: (setf translator) TRANSLATION NAME &optional PRIORITY
Package

qtools

Source

name-translation.lisp (file)

Reader

translator (function)

Function: write-forms STREAM

Writes all compileable forms to STREAM.

See QTOOLS:MAP-COMPILE-ALL

Package

qtools

Source

precompile.lisp (file)

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

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


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.4 Generic functions

Generic Function: message CONDITION
Generic Function: (setf message) NEW-VALUE CONDITION
Package

qtools

Methods
Method: message (CONDITION compilation-note)
Method: (setf message) NEW-VALUE (CONDITION compilation-note)
Source

toolkit.lisp (file)

Generic Function: name OBJECT
Generic Function: (setf name) NEW-VALUE OBJECT
Package

qtools

Methods
Method: name (TRANSLATOR translator)

automatically generated reader method

Source

name-translation.lisp (file)

Method: (setf name) NEW-VALUE (TRANSLATOR translator)

automatically generated writer method

Source

name-translation.lisp (file)

Generic Function: priority OBJECT
Generic Function: (setf priority) NEW-VALUE OBJECT
Package

qtools

Methods
Method: priority (TRANSLATOR translator)

automatically generated reader method

Source

name-translation.lisp (file)

Method: (setf priority) NEW-VALUE (TRANSLATOR translator)

automatically generated writer method

Source

name-translation.lisp (file)

Generic Function: translation OBJECT
Generic Function: (setf translation) NEW-VALUE OBJECT
Package

qtools

Methods
Method: translation (TRANSLATOR translator)

automatically generated reader method

Source

name-translation.lisp (file)

Method: (setf translation) NEW-VALUE (TRANSLATOR translator)

automatically generated writer method

Source

name-translation.lisp (file)

Generic Function: widget-class-direct-finalizers OBJECT
Generic Function: (setf widget-class-direct-finalizers) NEW-VALUE OBJECT
Package

qtools

Methods
Method: widget-class-direct-finalizers (WIDGET-CLASS widget-class)

automatically generated reader method

Source

widget.lisp (file)

Method: (setf widget-class-direct-finalizers) NEW-VALUE (WIDGET-CLASS widget-class)

automatically generated writer method

Source

widget.lisp (file)

Generic Function: widget-class-direct-initializers OBJECT
Generic Function: (setf widget-class-direct-initializers) NEW-VALUE OBJECT
Package

qtools

Methods
Method: widget-class-direct-initializers (WIDGET-CLASS widget-class)

automatically generated reader method

Source

widget.lisp (file)

Method: (setf widget-class-direct-initializers) NEW-VALUE (WIDGET-CLASS widget-class)

automatically generated writer method

Source

widget.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.5 Conditions

Condition: unknown-type-name ()
Package

qtools

Source

name-translation.lisp (file)

Direct superclasses

style-warning (condition)

Direct slots
Slot: type-name
Initargs

:type-name


Previous: , Up: Internal definitions   [Contents][Index]

5.2.6 Classes

Class: finalizable-direct-slot-definition ()
Package

qtools

Source

finalizable.lisp (file)

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

qtools

Source

finalizable.lisp (file)

Direct superclasses
Class: translator ()

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

See TRANSLATOR

Package

qtools

Source

name-translation.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: name
Initargs

:name

Readers

name (generic function)

Writers

(setf name) (generic function)

Slot: translation
Initargs

:translation

Readers

translation (generic function)

Writers

(setf translation) (generic function)

Slot: priority
Initargs

:priority

Readers

priority (generic function)

Writers

(setf priority) (generic function)

Direct Default Initargs
InitargValue
:name(error "name required.")
:translation(error "translation required.")
:priority0

Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   F   L   Q  
Index Entry  Section

F
File, Lisp, qtools.asd: The qtools<dot>asd file
File, Lisp, qtools/class-map.lisp: The qtools/class-map<dot>lisp file
File, Lisp, qtools/copying.lisp: The qtools/copying<dot>lisp file
File, Lisp, qtools/deploy.lisp: The qtools/deploy<dot>lisp file
File, Lisp, qtools/dispatch.lisp: The qtools/dispatch<dot>lisp file
File, Lisp, qtools/documentation.lisp: The qtools/documentation<dot>lisp file
File, Lisp, qtools/dynamic.lisp: The qtools/dynamic<dot>lisp file
File, Lisp, qtools/fast-call.lisp: The qtools/fast-call<dot>lisp file
File, Lisp, qtools/finalizable.lisp: The qtools/finalizable<dot>lisp file
File, Lisp, qtools/gc-finalized.lisp: The qtools/gc-finalized<dot>lisp file
File, Lisp, qtools/generate.lisp: The qtools/generate<dot>lisp file
File, Lisp, qtools/name-translation.lisp: The qtools/name-translation<dot>lisp file
File, Lisp, qtools/package.lisp: The qtools/package<dot>lisp file
File, Lisp, qtools/precompile.lisp: The qtools/precompile<dot>lisp file
File, Lisp, qtools/printing.lisp: The qtools/printing<dot>lisp file
File, Lisp, qtools/readtable.lisp: The qtools/readtable<dot>lisp file
File, Lisp, qtools/signal.lisp: The qtools/signal<dot>lisp file
File, Lisp, qtools/toolkit.lisp: The qtools/toolkit<dot>lisp file
File, Lisp, qtools/widget-convenience.lisp: The qtools/widget-convenience<dot>lisp file
File, Lisp, qtools/widget-defmethod.lisp: The qtools/widget-defmethod<dot>lisp file
File, Lisp, qtools/widget-menu.lisp: The qtools/widget-menu<dot>lisp file
File, Lisp, qtools/widget.lisp: The qtools/widget<dot>lisp file

L
Lisp File, qtools.asd: The qtools<dot>asd file
Lisp File, qtools/class-map.lisp: The qtools/class-map<dot>lisp file
Lisp File, qtools/copying.lisp: The qtools/copying<dot>lisp file
Lisp File, qtools/deploy.lisp: The qtools/deploy<dot>lisp file
Lisp File, qtools/dispatch.lisp: The qtools/dispatch<dot>lisp file
Lisp File, qtools/documentation.lisp: The qtools/documentation<dot>lisp file
Lisp File, qtools/dynamic.lisp: The qtools/dynamic<dot>lisp file
Lisp File, qtools/fast-call.lisp: The qtools/fast-call<dot>lisp file
Lisp File, qtools/finalizable.lisp: The qtools/finalizable<dot>lisp file
Lisp File, qtools/gc-finalized.lisp: The qtools/gc-finalized<dot>lisp file
Lisp File, qtools/generate.lisp: The qtools/generate<dot>lisp file
Lisp File, qtools/name-translation.lisp: The qtools/name-translation<dot>lisp file
Lisp File, qtools/package.lisp: The qtools/package<dot>lisp file
Lisp File, qtools/precompile.lisp: The qtools/precompile<dot>lisp file
Lisp File, qtools/printing.lisp: The qtools/printing<dot>lisp file
Lisp File, qtools/readtable.lisp: The qtools/readtable<dot>lisp file
Lisp File, qtools/signal.lisp: The qtools/signal<dot>lisp file
Lisp File, qtools/toolkit.lisp: The qtools/toolkit<dot>lisp file
Lisp File, qtools/widget-convenience.lisp: The qtools/widget-convenience<dot>lisp file
Lisp File, qtools/widget-defmethod.lisp: The qtools/widget-defmethod<dot>lisp file
Lisp File, qtools/widget-menu.lisp: The qtools/widget-menu<dot>lisp file
Lisp File, qtools/widget.lisp: The qtools/widget<dot>lisp file

Q
qtools.asd: The qtools<dot>asd file
qtools/class-map.lisp: The qtools/class-map<dot>lisp file
qtools/copying.lisp: The qtools/copying<dot>lisp file
qtools/deploy.lisp: The qtools/deploy<dot>lisp file
qtools/dispatch.lisp: The qtools/dispatch<dot>lisp file
qtools/documentation.lisp: The qtools/documentation<dot>lisp file
qtools/dynamic.lisp: The qtools/dynamic<dot>lisp file
qtools/fast-call.lisp: The qtools/fast-call<dot>lisp file
qtools/finalizable.lisp: The qtools/finalizable<dot>lisp file
qtools/gc-finalized.lisp: The qtools/gc-finalized<dot>lisp file
qtools/generate.lisp: The qtools/generate<dot>lisp file
qtools/name-translation.lisp: The qtools/name-translation<dot>lisp file
qtools/package.lisp: The qtools/package<dot>lisp file
qtools/precompile.lisp: The qtools/precompile<dot>lisp file
qtools/printing.lisp: The qtools/printing<dot>lisp file
qtools/readtable.lisp: The qtools/readtable<dot>lisp file
qtools/signal.lisp: The qtools/signal<dot>lisp file
qtools/toolkit.lisp: The qtools/toolkit<dot>lisp file
qtools/widget-convenience.lisp: The qtools/widget-convenience<dot>lisp file
qtools/widget-defmethod.lisp: The qtools/widget-defmethod<dot>lisp file
qtools/widget-menu.lisp: The qtools/widget-menu<dot>lisp file
qtools/widget.lisp: The qtools/widget<dot>lisp file

Jump to:   F   L   Q  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

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

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

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

B
build-menu-content: Exported functions

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

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

E
ecl-type-for: Exported functions
emit-compilation-note: Exported functions
emit-operator-call: Internal functions
ensure-cl-function-name: Internal functions
ensure-class: Exported functions
ensure-completable-qclass: Internal functions
ensure-list: Internal functions
ensure-methods: Internal functions
ensure-methods-processed: Exported functions
ensure-q+-method: Exported functions
ensure-qapplication: Exported functions
ensure-qclass: Exported functions
ensure-qobject: Exported functions
enumerate-method-descriptors: Exported functions
eqt-class-name: Exported functions
eqt-type-of: Exported functions

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

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

L
load-all-smoke-modules: Exported functions
loaded-smoke-modules: Exported functions

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

N
name: Internal generic functions
name: Internal generic functions
named-lambda: Internal macros
normalize-bindings: Internal functions

P
parent: Exported generic functions
parent: Exported generic functions
print-qobject: Exported functions
print-unreadable-qobject: Internal macros
priority: Internal generic functions
priority: Internal generic functions
process-all-methods: Exported functions
process-list-arg: Internal functions
process-method: Exported functions
process-q+-setter: Internal functions

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

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

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

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

U
unbox: Exported generic functions
unbox: Exported generic functions

V
value: Exported generic functions
value: Exported generic functions
value: Exported generic functions

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

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

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

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

%
%object: Exported classes

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

C
clashing-qt-superclass: Exported conditions
clashing-superclass: Exported conditions

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

E
extern-options: Exported classes

F
finalized: Exported classes
finalizers: Exported classes

I
initializers: Exported classes

M
message: Exported conditions

N
name: Internal classes

P
priority: Internal classes

R
requested-qt-superclass: Exported conditions

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

T
translation: Internal classes
type-name: Internal conditions

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

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

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

C
cl+qt: The cl+qt package
Class, finalizable: Exported classes
Class, finalizable-class: Exported classes
Class, finalizable-direct-slot-definition: Internal classes
Class, finalizable-effective-slot-definition: Internal classes
Class, finalizable-slot: Exported classes
Class, gc-finalized: Exported classes
Class, qt-program-op: Exported classes
Class, translator: Internal classes
Class, widget: Exported classes
Class, widget-class: Exported classes
compilation-note: Exported conditions
Condition, compilation-note: Exported conditions
Condition, invalid-qt-superclass-hierarchy: Exported conditions
Condition, unknown-type-name: Internal conditions

F
finalizable: Exported classes
finalizable-class: Exported classes
finalizable-direct-slot-definition: Internal classes
finalizable-effective-slot-definition: Internal classes
finalizable-slot: Exported classes
function: Exported types

G
gc-finalized: Exported classes

I
invalid-qt-superclass-hierarchy: Exported conditions

P
Package, cl+qt: The cl+qt package
Package, qtools: The qtools package

Q
qt-program-op: Exported classes
qtools: The qtools system
qtools: The qtools package

S
System, qtools: The qtools system

T
translator: Internal classes
Type, function: Exported types

U
unknown-type-name: Internal conditions

W
widget: Exported classes
widget-class: Exported classes

Jump to:   C   F   G   I   P   Q   S   T   U   W