Wed Mar 10 18:13:52 CET 2010  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Delete QPainDevices before the QApplication is destroyed.
Mon Jan 25 20:09:40 CET 2010  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Fix with-app cleanup
Mon Jan 25 19:50:16 CET 2010  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Fix with-painter
Mon Jan 25 19:49:07 CET 2010  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * QList<Foo*> translations
Mon Jan 25 19:48:42 CET 2010  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * QVector<QPointF> translation
Mon Jan 25 19:48:17 CET 2010  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * ownership transfer QGraphicsScene::addItem
Sat Jan 23 20:48:00 CET 2010  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * QVector translations
Sun Jan 10 09:52:49 CET 2010  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Split up in qt.gui & cleanup name prefix.
Sun Dec 13 13:44:37 CET 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Support ASDF instead of Mudballs.
Sun Dec 13 11:50:24 CET 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Install msg-handler also when starting from an image
Sun Dec 13 11:49:35 CET 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Convert C++ exceptions to a qFatal
Wed Sep  9 15:18:08 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Cleanup msg-handler
Wed Sep  2 14:00:35 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Better Lisp vector to QList<*> conversion.
Thu Aug 27 10:37:36 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Update to the new smokegenerator.
Sun Aug  2 13:29:13 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Fix double space when printing a qt:object.
Sun Aug  2 13:29:02 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * qt:event upcasting cleanup
Sun Aug  2 13:15:21 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Support ownership transfer to non smoke wrapped QObjects & cleanup C++ to Lisp translation.
Mon Jul 27 21:39:43 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Fix ownership transfer for lambda slot to no Smoke object.
Fri Jul 24 15:40:52 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Remove unnecessary #'cxx:data calls.
Thu Jul 23 00:21:01 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * support packages for symbols as property names.
Wed Jul  8 22:55:24 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * The smoke call stack is now a struct -> adapt.
Fri Jul  3 12:14:09 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Fix nested #'qt:exec
Thu Jul  2 21:37:42 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Fix potential lisp-object ID generation overflow for excessive lisp-object creation.
Thu Jul  2 21:12:45 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * move emit slot code to new function ACTIVATE & image startup fix for STATIC-META-OBJECT
Wed Jul  1 12:58:06 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Break API compatibility for qt:with-app and qt:exec & spellcheck
Sun Jun 21 11:29:25 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * *SMOKE-MODULE* must be passed instead of *QT-SMOKE*.
Thu Jun 11 20:50:26 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * The CLISP null pointer is NIL
Thu Jun 11 16:59:48 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * :qt and :qt-impl packages to prevent collision with :cl symbols and fix object with non smoke parent.
Wed Jun 10 14:14:34 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Transfer ownerhip only for smoke classes.
Wed Jun 10 14:02:01 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * more qt:variant conversions
Fri Jun  5 09:45:07 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * get-slot for function with this argument
Thu Jun  4 12:58:29 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Normalize signal and slot names at compile time.
Thu Jun  4 00:02:12 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Fix QT:APPLICATION cleanup in QT:WITH-APP and add restart to slot invocation.
Mon Jun  1 00:39:13 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * QList<QWidget*>
Mon Jun  1 00:22:22 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * QList<QObject*>
Sun May 31 23:59:55 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * cxx:push undo-stack takes ownership
Sun May 31 19:33:32 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Rework QObject parent ownership transfer
Sat May 30 14:16:53 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * soversion for wrapper
Thu May 28 16:13:57 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * ASDF
Wed May 27 19:18:41 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * QList<QByteArray> and QList<QVariant> conversion & use cxx:operator== and qt:operator== in cxx:=
Wed May 27 14:26:25 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * cleanup
Tue May 26 11:57:44 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Use argument conversion/promotion when emiting signals
Sun May 24 17:02:00 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * *exec-p* allows disabling qt:exec
Sun May 24 16:42:40 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Clozure CL Cmd line args for with-app
Sun May 24 16:40:11 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Use overload resolution instead of static-call
Sun May 24 16:30:31 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Cleanup app in with-app
Sun May 24 13:42:39 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Signal slot finalization fix
Tue May 19 17:16:49 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Search paths in with-translator
Tue May 19 16:32:42 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Clozure CL save-application fixes
Thu May 14 14:11:11 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Lisp image loading
Tue May 12 17:42:35 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Make *qt-smoke* read only
Mon May 11 21:50:13 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * print-object qt:object object-name
Mon May 11 16:15:30 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Cleanup remove unnecessary smoke:: in translation code.
Mon May 11 16:14:14 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Fix setf value and export variant-boundp.
Mon May 11 14:07:17 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * GCC visibility support for C wrapper symbols
Mon May 11 13:21:14 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * QList translations C wrapper
Mon May 11 13:18:36 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * update marshalling for overload resolution
Mon May 11 13:09:54 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * cleanup variant
Wed Apr 15 10:20:41 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * It is cxx:>= not cxx:=>.
Tue Apr 14 16:25:46 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * License
Tue Apr 14 11:16:21 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Do not use :asdf.
Sun Apr 12 21:56:34 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Add operator Lisp style functions.
Sun Apr 12 21:55:35 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * indent variant.lisp & minor cleanup
Sun Apr 12 15:12:20 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * get rid of &args for "defmethod cxx:"
Thu Apr  9 00:33:55 CEST 2009  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Fix receiving C++ classes by value in a slot
diff -rN -u old-qt.gui/CMakeLists.txt new-qt.gui/CMakeLists.txt
--- old-qt.gui/CMakeLists.txt	2014-11-25 11:01:46.000000000 +0100
+++ new-qt.gui/CMakeLists.txt	1970-01-01 01:00:00.000000000 +0100
@@ -1,7 +0,0 @@
-cmake_minimum_required(VERSION 2.6)
-
-project(qt)
-
-add_subdirectory(src)
-
-include(UseDoxygen OPTIONAL)
diff -rN -u old-qt.gui/COPYING new-qt.gui/COPYING
--- old-qt.gui/COPYING	1970-01-01 01:00:00.000000000 +0100
+++ new-qt.gui/COPYING	2014-11-25 11:01:47.000000000 +0100
@@ -0,0 +1,676 @@
+
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+ 
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+  
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
+
diff -rN -u old-qt.gui/LICENSE new-qt.gui/LICENSE
--- old-qt.gui/LICENSE	1970-01-01 01:00:00.000000000 +0100
+++ new-qt.gui/LICENSE	2014-11-25 11:01:47.000000000 +0100
@@ -0,0 +1,22 @@
+The software in this package is distributed under the GNU General Public
+License (with a special exception described below).
+
+A copy of GNU General Public License (GPL) is included in this distribution,
+in the file COPYING. 
+
+  Linking this library statically or dynamically with other modules is
+  making a combined work based on this library.  Thus, the terms and
+  conditions of the GNU General Public License cover the whole
+  combination.
+ 
+  As a special exception, the copyright holders of this library give you
+  permission to link this library with independent modules to produce an
+  executable, regardless of the license terms of these independent
+  modules, and to copy and distribute the resulting executable under
+  terms of your choice, provided that you also meet, for each linked
+  independent module, the terms and conditions of the license of that
+  module.  An independent module is a module which is not derived from
+  or based on this library.  If you modify this library, you may extend
+  this exception to your version of the library, but you are not
+  obligated to do so.  If you do not wish to do so, delete this
+  exception statement from your version.
diff -rN -u old-qt.gui/TODO new-qt.gui/TODO
--- old-qt.gui/TODO	2014-11-25 11:01:46.000000000 +0100
+++ new-qt.gui/TODO	1970-01-01 01:00:00.000000000 +0100
@@ -1 +0,0 @@
-* QApplication and KCmdLineArgs.init call exit() on e.g. "--help"
diff -rN -u old-qt.gui/cl-smoke.qt.gui.asd new-qt.gui/cl-smoke.qt.gui.asd
--- old-qt.gui/cl-smoke.qt.gui.asd	1970-01-01 01:00:00.000000000 +0100
+++ new-qt.gui/cl-smoke.qt.gui.asd	2014-11-25 11:01:47.000000000 +0100
@@ -0,0 +1,21 @@
+(defsystem :cl-smoke.qt.gui
+  :name :cl-smoke.qt.gui
+  :version (0 0 1)
+  :author "Tobias Rautenkranz"
+  :license "GPL with linking exception"
+  :description "Smoke Qt GUI bindings."
+  :depends-on (:cl-smoke.qt.core)
+
+  :components 
+  ((:module "src"
+            :components
+            ((:file "package")
+             (:file "qt.gui" :depends-on ("package"))
+             (:file "ownership" :depends-on ("qt.gui"))
+             (:file "application" :depends-on ("qt.gui"))
+             (:file "translations" :depends-on ("qt.gui"))
+             (:file "painter" :depends-on ("qt.gui"))))))
+
+(defmethod perform ((operation test-op) (c (eql (find-system :cl-smoke.qt.gui))))
+  (operate 'asdf:load-op :cl-smoke.qt.tests)
+  (operate 'asdf:test-op :cl-smoke.qt.tests))
diff -rN -u old-qt.gui/examples/hello-world.lisp new-qt.gui/examples/hello-world.lisp
--- old-qt.gui/examples/hello-world.lisp	2014-11-25 11:01:46.000000000 +0100
+++ new-qt.gui/examples/hello-world.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,63 +0,0 @@
-(in-package :qt-examples)
-(declaim (optimize (debug 3)))
-
-(defun hello-world ()
-  "Hello world"
-  (qt:with-app
-    (let ((widget (make-instance 'qt:push-button :args '("Hello world"))))
-      (cxx:show widget)
-      (qt:exec))))
-
-
-(defun hello-world-quit ()
-  "Quit on push-button click"
-  (qt:with-app
-    (let ((quit (make-instance 'qt:push-button :args '("Quit"))))
-      (cxx:resize quit 75 30)
-      (cxx:set-font quit (make-instance 'qt:font :args (list "Times"
-                                                             18
-                                                            qt:font.+bold+)))
-      
-      (qt:object.connect quit (qt:qsignal "clicked()")
-                   (qt:app) (qt:qslot "quit()"))
-      (cxx:show quit)
-      (qt:exec))))
-
-(defun hello-world-gc ()
-  "GC on push-button click"
-  (qt:with-app
-    (let ((gc (make-instance 'qt:widget)))
-      (let ((layout (make-instance 'qt:vbox-layout))
-            (button (make-instance 'qt:push-button :args '("GC"))))
-        (trivial-garbage:gc :full t)
-        (cxx:add-widget layout button)
-        (trivial-garbage:gc :full t)
-        (cxx:set-layout gc layout)
-        (trivial-garbage:gc :full t)
-        (qt:connect-function button "clicked()"
-                             #'(lambda () 
-                                 (format t "GC-ing~%")
-                                 (trivial-garbage:gc :full t))))
-        (trivial-garbage:gc :full t)
-      (cxx:show gc)
-        (trivial-garbage:gc :full t)
-      (qt:exec))))
-
-;; You need to run cmake & make to generate the .po and .qm files
-(defun i18n-hello-world ()
-  "i18n hello world"
-  (qt:with-app
-    (qt:with-translator "hello-world"
-      (let ((widget (make-instance 'qt:label)))
-        (setf (qt:property widget 'window-title)
-              (qt:tr "Lisp Qt Example" "hello-world"))
-        (cxx:set-text widget
-                      (format nil (qt:tr "<h1>Hello world</h1>
-
-You are running ~A version ~A on a ~A ~A")
-                              (lisp-implementation-type)
-                              (lisp-implementation-version)
-                              (software-type)
-                              (software-version)))
-        (cxx:show widget)
-        (qt:exec)))))
diff -rN -u old-qt.gui/examples/package.lisp new-qt.gui/examples/package.lisp
--- old-qt.gui/examples/package.lisp	2014-11-25 11:01:46.000000000 +0100
+++ new-qt.gui/examples/package.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,15 +0,0 @@
-(defpackage #:qt-examples
-  (:use #:cl)
-  (:export #:hello-world
-           #:i18n-hello-world
-           #:hello-world-quit
-           #:hello-world-gc
-
-           #:class-browser
-
-           #:tick-tack-toe
-           #:repl
-
-           #:launcher
-           
-           #:load-ui-file))
diff -rN -u old-qt.gui/qt.mbd new-qt.gui/qt.mbd
--- old-qt.gui/qt.mbd	2014-11-25 11:01:47.000000000 +0100
+++ new-qt.gui/qt.mbd	1970-01-01 01:00:00.000000000 +0100
@@ -1,66 +0,0 @@
-;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
-
-;;; SYSDEF.CMAKE
-(defpackage :sysdef.cmake
-  (:use :cl :sysdef)
-  (:export :cmake-file :cmake-library))
-
-(in-package :sysdef.cmake)
-(defclass sysdef.cmake:cmake-file (source-file)
-  ()
-  (:default-initargs :type "txt"))
-
-(defclass sysdef.cmake:cmake-library (component)
-  ())
-;;; end SYSDEF.CMAKE
-
-(in-package :sysdef-user)
-(eval-when (:compile-toplevel :load-toplevel :execute)
-  (use-package :sysdef.cmake))
-
-(define-system :qt ()
-  (:version 0 0 1)
-  (:documentation "Smoke Qt bindings.")
-  (:keywords "GUI" "Qt")
-  (:author "Tobias Rautenkranz")
-  (:components 
-   ("CMakeLists" sysdef.cmake:cmake-file)
-   ("src" module
-          (:needs "CMakeLists")
-          (:components
-           ("CMakeLists.txt" static-file)
-           "package"
-           ("lib" module
-                  (:needs "package")
-                  (:components 
-                   ("libqt-smoke-extra" sysdef.cmake:cmake-library)
-
-                   ("CMakeLists.txt" static-file)
-                   ("qt-smoke.cpp" static-file)
-                   ("lisp-object.h" static-file)
-                   ("lisp-object.cpp" static-file)
-                   ("qstring.cpp" static-file)
-                   ("qstringlist.cpp" static-file)))
-
-           ("qt" (:needs "package" "lib"))
-           ("object" (:needs "qt"))
-           ("application" (:needs "qt"))
-           ("qstring" (:needs "qt"))
-           ("msg-handler" (:needs "lib"))
-           ("painter" (:needs "qt"))
-           ("timer" (:needs "qt"))
-           ("i18n" (:needs "qt"))
-	   ("lisp-object" (:needs "qt" "lib"))
-           ("signal-slot" module
-                          (:needs "lisp-object")
-                          (:serial t)
-                          (:components
-                           "signal-slot"
-                           "translate"
-                           "signal"
-                           "slot"
-                           "connect"))
-           ("string-list" (:needs "qt" "lib" "qstring"))
-           ("variant" (:needs "qt" "qstring" "lisp-object"))
-           ("properties" (:needs "variant")))))
-  (:needs :smoke :sysdef.cmake :cffi))
diff -rN -u old-qt.gui/src/CMakeLists.txt new-qt.gui/src/CMakeLists.txt
--- old-qt.gui/src/CMakeLists.txt	2014-11-25 11:01:46.000000000 +0100
+++ new-qt.gui/src/CMakeLists.txt	1970-01-01 01:00:00.000000000 +0100
@@ -1 +0,0 @@
-add_subdirectory(lib)
diff -rN -u old-qt.gui/src/application.lisp new-qt.gui/src/application.lisp
--- old-qt.gui/src/application.lisp	2014-11-25 11:01:46.000000000 +0100
+++ new-qt.gui/src/application.lisp	2014-11-25 11:01:47.000000000 +0100
@@ -1,99 +1,60 @@
-(in-package :qt)
+(in-package :cl-smoke.qt.gui)
 
-(declaim (optimize (debug 3)))
-
-(defvar *app*)
 (defvar *widgets* nil)
 
-(defun app ()
-  "Returns the APPLICATION (or CORE-APPLICATION) object,
-within a WITH-APP."
-  (assert (app-p)
-          (*app*))
-  *app*)
-
-(defun app-p ()
-  "Returns t when the APPLICATION object exists and nil otherwise."
-  (boundp '*app*))
-
-
-(let ((argv (null-pointer))
-      (argc (null-pointer)))
-  (declare (cffi:foreign-pointer argv argc))
-  (defun ensure-app (&optional 
-                     (application 'application)
-                     (args #+sbcl sb-ext:*posix-argv*
-                           #-sbcl (list (lisp-implementation-type))))
-    "Constructs the global application object, when there is none,
-with the command line arguments ARGS.
-
-Returns the application object a first value and
-true when a new application was created and false otherwise."
-    (assert (not (null args))
-            (args)
-            "No program name supplied.")
-    (if (app-p)
-        (progn
-          (assert (typep (app) (find-class application))
-                  (application)
-                  "The existing application object ~A is
-not of type ~A." (app) (find-class application))
-          (values (app) nil))
-        (progn
-;          (assert (null-pointer-p (smoke::pointer (core-application.instance))))
-            (foreign-free argv)
-            (foreign-free argc)
-
-          (setf argv (foreign-alloc :string :initial-contents args))
-          (setf argc (foreign-alloc :int :initial-element (length args)))
-          (values (qt:new "QApplication" "QApplication$?" argc argv) t))))
-  (defun kill-app ()
-    (cxx:quit (app))
-    (when (typep (app) (find-class 'qt:application))
-      (application.close-all-windows))
-    (setf *widgets* nil)
-    (trivial-garbage:cancel-finalization (app))
-    ;(smoke::remove-object (smoke::pointer (app)))
-    (smoke::delete-pointer (smoke::pointer (app)) (class-of (app)))
-    (setf (slot-value (app) 'pointer) (null-pointer))
-;    (foreign-free argc)
-    (setf argc (null-pointer))
-;    (foreign-free argv)
-    (setf argv (null-pointer))
-    (makunbound '*app*)))
-
-(defmacro with-application ((ensure-app remove-app) &body body)
-  `(progn (setf *app* ,ensure-app)
-          (unwind-protect
-               (progn
-                 ,@body))))
+(defmethod cl-smoke.qt.core:delete-app :around ((application qt:application))
+  (qt:application.close-all-windows)
+  ;; widgets are only valid as long, as an application object
+  ;; exists.  QApplication::~QApplication() deletes all widgets in
+  ;; QApplication::allWidgets().
+  ;; 
+  ;; see: qt4/src/gui/kernel/qapplication.cpp
+  (loop for widget across (qt:application.all-widgets) do
+       (tg:cancel-finalization widget))
+  ;; QPaintDevices are only valid when a application object exists.
+  (loop for object being the hash-values of smoke::*object-map* do
+       (when (typep object 'qt:paint-device)
+         (delete-object object)))
+  ;; Finalize other stuff before deleting the QApplication,
+  ;; e.g. QGraphicsScene
+  (tg:gc :full t)
+  (call-next-method)
+  (setf *widgets* nil))
 
-(defmacro with-app (&body body)
+(defmacro qt:with-app (options &body body)
   "Ensures that a APPLICATION instance exists, 
 evaluates BODY and executes the APPLICATION instance after BODY.
 The instance can be accessed with:
-APP.
+QT:APP.
 
 Can be nested.
 
 When a APPLICATION was created, it will be deleted when returning
 from BODY."
-  `(with-application ((ensure-app 'application) (kill-app))
-                      ,@body))
-
-(defmacro with-core-app (&body body)
-  `(with-application ((ensure-app 'core-application) (kill-app))
-                      ,@body))
-  
-
-(defun exec (&rest widgets)
-  "Executes APP."
-  (setf *widgets* (append widgets *widgets*))
-  (restart-bind ((abort-app #'(lambda ()
-                                (application.close-all-windows)
-                                (cxx:quit (app))
-                                (invoke-restart (find-restart 'continue)))
-                   :report-function
-                   #'(lambda (stream)
-                       (format stream "Return from the application event loop."))))
-    (cxx:exec (app))))
+  (assert (null options)
+          (options)
+          "Currently no options can be passed to QT:WITH-APP.")
+  `(cl-smoke.qt.core:with-application ((cl-smoke.qt.core:ensure-app 'qt:application)
+                                        (cl-smoke.qt.core:kill-app))
+     ,@body))
+
+(defun qt:exec ()
+  "Executes APP. When QT:*EXEC-P* is false it returns immediately
+and transfers the ownership of the top-level widgets to the qt:application
+instance."
+  (if qt:*exec-p*
+      (restart-bind ((qt::abort-app #'(lambda ()
+                                        (cxx:quit (qt:app))
+                                        (invoke-restart (find-restart 'continue)))
+                       :report-function
+                       #'(lambda (stream)
+                           (format stream "Return from the application event loop."))
+                       :test-function
+                       #'(lambda (condition)
+                           (declare (ignore condition))
+                           (and (qt:app-p)
+                                (find-restart 'continue)))))
+        (let ((qt:*exec-p* nil))
+          (cxx:exec (qt:app))))
+      (when (typep (qt:app) 'qt:application)
+        (setf *widgets* (qt:application.top-level-widgets)))))
diff -rN -u old-qt.gui/src/i18n.lisp new-qt.gui/src/i18n.lisp
--- old-qt.gui/src/i18n.lisp	2014-11-25 11:01:46.000000000 +0100
+++ new-qt.gui/src/i18n.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,42 +0,0 @@
-(in-package :qt)
-
-(defun tr (message &optional context)
-  "Returns the translated MESSAGE for CONTEXT or
-a string STRING-EQUAL to MESSAGE when no translation was found.
-
-Translations can be loaded with WITH-TRANSLATOR."
-  (qt:core-application.translate (or context "") message))
-
-(defmacro with-installed-translator (translator &body body)
-  `(unwind-protect
-       (progn
-         (cxx:install-translator (qt:app) ,translator)
-         ,@body)
-     (cxx:remove-translator (qt:app) ,translator)))
-
-(defmacro with-translator (base-name &body body)
-  "Loads the translations in the BASE-NAME_LANGCODE.qm file.
-
-Must be in a WITH-APP."
-  (let ((translator (gensym)))
-    `(let ((,translator (make-instance 'translator)))
-       (unless (cxx:load ,translator (format nil "~A_~A"
-                                             ,base-name
-                                             (cxx:name (qt:locale.system))))
-         (cerror "Ignore" "Loading the translations ~A for ~A failed."
-                 ,base-name (cxx:name (qt:locale.system))))
-       (with-installed-translator ,translator
-         ,@body))))
-
-(defmacro with-libqt-translator (&body body)
-  "Loads the translations for the Qt library.
-
-Must be in a WITH-APP."
-  (let ((translator (gensym)))
-    `(let ((,translator (make-instance 'translator)))
-       (unless (cxx:load ,translator (format nil "qt_~A"
-                                             (cxx:name (qt:locale.system)))
-                         (qt:library-info.location qt:library-info.+translations-path+))
-         (cerror "Ignore" "Loading the Qt library translations failed."))
-       (with-installed-translator ,translator
-         ,@body))))
diff -rN -u old-qt.gui/src/lib/CMakeLists.txt new-qt.gui/src/lib/CMakeLists.txt
--- old-qt.gui/src/lib/CMakeLists.txt	2014-11-25 11:01:47.000000000 +0100
+++ new-qt.gui/src/lib/CMakeLists.txt	1970-01-01 01:00:00.000000000 +0100
@@ -1,7 +0,0 @@
-find_package(Qt4)
-set(QT_DONT_USE_QTGUI true)
-include(${QT_USE_FILE})
-
-set(QT_SMOKE_SOURCES qt-smoke.cpp qstring.cpp qstringlist.cpp lisp-object.cpp)
-add_library(qt-smoke-extra MODULE ${QT_SMOKE_SOURCES})
-target_link_libraries(qt-smoke-extra ${QT_LIBRARIES})
diff -rN -u old-qt.gui/src/lib/lisp-object.cpp new-qt.gui/src/lib/lisp-object.cpp
--- old-qt.gui/src/lib/lisp-object.cpp	2014-11-25 11:01:46.000000000 +0100
+++ new-qt.gui/src/lib/lisp-object.cpp	1970-01-01 01:00:00.000000000 +0100
@@ -1,179 +0,0 @@
-#include "lisp-object.h"
-
-#include <QtGlobal>
-#include <QtDebug>
-
-namespace cl_smoke {
-namespace qt {
-
-/** @struct lisp_object::data
- * @internal
- * Holds a reference ID for a lisp object and calls
- * the destructor callback when it is deleted.
- */
-
-/** @typedef lisp_object::destructor
- * Destructor.
- * @param id The ID
- */
-
-lisp_object::destructor lisp_object::destruct = NULL;
-
-
-/** Constructor. */
-lisp_object::data::data()
-: id(id),
-  is_set(false)
-{ }
-
-/** Constructor.
- * @param id The ID.
- */
-lisp_object::data::data(int id)
-: id(id),
-  is_set(true)
-{ }
-
-/** Destructor. */
-lisp_object::data::~data()
-{
-	Q_ASSERT_X(lisp_object::destruct, __func__,
-			"call setup_lisp_object() first.");
-
-	if (this->is_set)
-		(*lisp_object::destruct)(this->id);
-}
-
-/** @class lisp_object
- * @brief Holds a reference ID to a lisp object. 
- *
- * The registered destructor callback is called when
- * the last instance for a specific lisp object is deleted.
- *
- * Used for lisp objects in QVariants and signal/slots.
- */
-
-/** Constructor. */
-lisp_object::lisp_object()
-	: d(new data())
-{ }
-
-/** Constructor.
- * @param id the ID
- */
-lisp_object::lisp_object(int id)
-	: d(new data(id))
-{ }
-
-/** Constructor.
- * @param other the lisp_object to copy
- */
-lisp_object::lisp_object(const lisp_object& other)
-	: d(other.d)
-{ }
-
-/** @fn lisp_object::id() const
- * Gets the ID.
- *
- * @return the ID
- */
-
-/** @fn lisp_object::set() const
-  * Determines werter the ID is set.
-  *
-  * @return @c true when the id is set and @c false otherwise.
-  */
-
-/** Sets a new ID.
- * @param id the ID
- */
-void
-lisp_object::set_id(int id)
-{
-	Q_ASSERT(this->set() ? id != this->id() : true);
-
-	d = new data(id);
-}
-
-} // namespace qt
-} // namespace cl_smoke
-
-using namespace cl_smoke::qt;
-
-/** Initialize the lisp_object.
- * @relates cl_smoke::qt::lisp_object
- * @param destruct destructor callback
- *
- * @return the QMetaType ID of lisp_object
- */
-int
-qt_smoke_setup_lisp_object(void* destruct)
-{
-	Q_ASSERT(destruct != NULL);
-	lisp_object::destruct = reinterpret_cast<lisp_object::destructor>(destruct);
-
-	return qRegisterMetaType<lisp_object>();
-}
-
-/** Gets the ID of @a object.
- * @relates cl_smoke::qt::lisp_object
- * @param object the lisp_object.
- *
- * @return the ID
- */
-int
-qt_smoke_lisp_object_id(const void* object)
-{
-	return static_cast<const lisp_object*>(object)->id();
-}
-
-
-/** Determines werter the ID of @a object is set.
- * @relates cl_smoke::qt::lisp_object
- * @param object the object
- *
- * @return @c true when the ID is set and @c false otherwise.
- */
-int
-qt_smoke_lisp_object_set(const void* object)
-{
-	return static_cast<const lisp_object*>(object)->set();
-}
-
-/** Makes a new lisp_object.
- * @relates cl_smoke::qt::lisp_object
- * @param id the ID
- *
- * @return A new lisp_object instance.
- */
-void*
-qt_smoke_make_lisp_object(int id)
-{
-	return new lisp_object(id);
-}
-
-/** Deletes a lisp_object.
- * @relates cl_smoke::qt::lisp_object
- * @param object the lisp_object
- */
-void*
-qt_smoke_free_lisp_object(void* object)
-{
-	delete static_cast<lisp_object*>(object);
-}
-
-#include <QVariant>
-/** Gets the lisp_object of a QVariant.
- * @relates cl_smoke::qt::lisp_object
- * @param variant the QVariant
- * 
- * @return a new lisp_object.
- */
-void*
-qt_smoke_lisp_object_value(const void* variant)
-{
-	const QVariant* qvariant = static_cast<const QVariant*>(variant);
-	Q_ASSERT(QVariant::UserType == qvariant->type());
-
-	new lisp_object(qvariant->value<lisp_object>());
-}
diff -rN -u old-qt.gui/src/lib/lisp-object.h new-qt.gui/src/lib/lisp-object.h
--- old-qt.gui/src/lib/lisp-object.h	2014-11-25 11:01:47.000000000 +0100
+++ new-qt.gui/src/lib/lisp-object.h	1970-01-01 01:00:00.000000000 +0100
@@ -1,82 +0,0 @@
-#ifndef LISP_OBJECT_H
-#define LISP_OBJECT_H
-
-#include <QMetaType>
-#include <QSharedData>
-#include <QExplicitlySharedDataPointer>
-#include <smoke.h>
-
-
-extern "C"
-{
-	int
-	qt_smoke_setup_lisp_object(void* destruct);
-
-	int
-	qt_smoke_lisp_object_id(const void* object);
-
-	int
-	qt_smoke_lisp_object_set(const void* object);
-
-	void*
-	qt_smoke_make_lisp_object(int id);
-
-	void*
-	qt_smoke_free_lisp_object(void* object);
-
-	void*
-	qt_smoke_lisp_object_value(const void* variant);
-}
-
-namespace cl_smoke {
-namespace qt {
-
-class lisp_object
-{
-	public:
-		typedef void (*destructor)(int id);
-
-		lisp_object();
-
-		lisp_object(int id);
-
-		lisp_object(const lisp_object& other);
-
-		inline int
-		id() const
-		{ Q_ASSERT(this->set()); return d->id; }
-
-		void
-		set_id(int id);
-
-		inline bool
-		set() const
-		{ return d->is_set; }
-
-		friend int
-		::qt_smoke_setup_lisp_object(void* destruct);
-
-	private:
-		struct data : public QSharedData
-		{
-			data();
-			data(int id);
-			~data();
-			int id;
-			bool is_set;
-
-			private:
-			Q_DISABLE_COPY(data)
-		};
-
-		QExplicitlySharedDataPointer<data> d;
-
-		static destructor destruct;
-};
-
-} // namespace qt
-} // namespace cl_smoke
-
-Q_DECLARE_METATYPE(cl_smoke::qt::lisp_object);
-
-#endif // LISP_OBJECT_H
diff -rN -u old-qt.gui/src/lib/qstring.cpp new-qt.gui/src/lib/qstring.cpp
--- old-qt.gui/src/lib/qstring.cpp	2014-11-25 11:01:47.000000000 +0100
+++ new-qt.gui/src/lib/qstring.cpp	1970-01-01 01:00:00.000000000 +0100
@@ -1,44 +0,0 @@
-#include <QString>
-#include <QtDebug>
-
-/** @file
- * @brief QString conversion. */
-
-extern "C" {
-
-/** Converts a QString to a QByteArray.
- * @param qstring Pointer to a QString
- *
- * @return a pointer to a newly allocated char array. 
- */
-void*
-qt_smoke_qstring_to_byte_array(const void* qstring)
-{
-	Q_ASSERT(qstring);
-	const QString* string = static_cast<const QString*>(qstring);
-
-	return new QByteArray(string->toLocal8Bit());
-}
-
-/** Frees an QString.
- * @param qstring the QString to free
- */
-void
-qt_smoke_free_qstring(void* qstring)
-{
-	delete static_cast<QString*>(qstring);
-}
-
-/** Converts a string to a QString.
- * @param data a char array
- * @param length the length of @a data
- *
- * @return a newly allocated QString
- */
-void*
-qt_smoke_string_to_qstring(const char* data, int length)
-{
-	return new QString(QString::fromLocal8Bit(data, length));
-}
-
-} // extern "C"
diff -rN -u old-qt.gui/src/lib/qstringlist.cpp new-qt.gui/src/lib/qstringlist.cpp
--- old-qt.gui/src/lib/qstringlist.cpp	2014-11-25 11:01:47.000000000 +0100
+++ new-qt.gui/src/lib/qstringlist.cpp	1970-01-01 01:00:00.000000000 +0100
@@ -1,69 +0,0 @@
-#include <QStringList>
-#include <QtDebug>
-#include <cstring>
-
-/** @file
- * @brief QStringList conversion. */
-
-extern "C" {
-
-/** Returns the number of items of @a string_list.
- * @param string_list the QStringList
- *
- * @return the number of items
- */
-int
-qt_smoke_string_list_size(const void* string_list)
-{
-	Q_ASSERT(string_list);
-	return static_cast<const QStringList*>(string_list)->size();
-}
-
-/** Returns the byte array of @a string_list at position @a index.
- * @param string_list the QStringList
- * @param index the index of the string
- *
- * @return a new allocated byte-array
- */
-void*
-qt_smoke_string_list_at(const void* string_list, int index)
-{
-	Q_ASSERT(string_list);
-	const QStringList* list = static_cast<const QStringList*>(string_list);
-
-	Q_ASSERT(0 <= index && index < list->size());
-		
-	return new QByteArray(list->at(index).toLocal8Bit());
-}
-
-/** Free a QStringList.
- * @param string_list the QStringList to free
- */
-void
-qt_smoke_free_string_list(void* string_list)
-{
-	delete static_cast<QStringList*>(string_list);
-}
-
-/** Allocates a new QStringList.
- *
- * @return a new QStringList
- */
-void*
-qt_smoke_make_string_list()
-{
-	return new QStringList();
-}
-
-/** Appends @a string to @a string_list
- * @param string_list the QStringList
- * @param data the string
- * @param length the length of @a data
- */
-void
-qt_smoke_string_list_append(void* string_list, const char* data, int length)
-{
-	static_cast<QStringList*>(string_list)->append(QString::fromLocal8Bit(data, length));
-}
-
-} // extern "C"
diff -rN -u old-qt.gui/src/lib/qt-smoke.cpp new-qt.gui/src/lib/qt-smoke.cpp
--- old-qt.gui/src/lib/qt-smoke.cpp	2014-11-25 11:01:47.000000000 +0100
+++ new-qt.gui/src/lib/qt-smoke.cpp	1970-01-01 01:00:00.000000000 +0100
@@ -1,26 +0,0 @@
-#include <qnamespace.h>
-#include <QEvent>
-#include <QtDebug>
-
-/** @file
- * @brief Qt support functions */
-
-extern "C" {
-
-/** Registers a callback to be invoked for every QEvent.
- * @see QCoreApplication::notifyInternal
- *
- * @param callback the callback
- * 
- * @return @c true on success and @c false when the callback table is full.
- */
-int
-qt_smoke_register_event_notify(void* callback)
-{
-	Q_ASSERT(callback);
-
-	return QInternal::registerCallback(QInternal::EventNotifyCallback,
-			reinterpret_cast<qInternalCallback>(callback));
-}
-
-} // extern "C"
diff -rN -u old-qt.gui/src/lisp-object.lisp new-qt.gui/src/lisp-object.lisp
--- old-qt.gui/src/lisp-object.lisp	2014-11-25 11:01:46.000000000 +0100
+++ new-qt.gui/src/lisp-object.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,62 +0,0 @@
-(in-package :qt)
-(declaim (optimize (debug 3)))
-
-(defvar *cxx-lisp-objects* (make-hash-table)
-  "Objects that are currently passed in a C++ class.")
-
-(let ((id 0))
-  (defun gen-cxx-lisp-object-id ()
-    "Returns a new unique ID."
-    (incf id)))
-
-(defcfun qt-smoke-setup-lisp-object :int
-  (destruct :pointer))
-
-(defcfun qt-smoke-lisp-object-id :int
-  (object :pointer))
-
-(defcfun qt-smoke-lisp-object-set :int
-  (object :pointer))
-
-(defcfun qt-smoke-make-lisp-object :pointer
-  (id :int))
-
-(defcfun qt-smoke-free-lisp-object :void
-  (object :pointer))
-
-(defcallback destruct-cxx-lisp-object :void
-    ((id :int))
-  (remhash id *cxx-lisp-objects*))
-
-(defvar *cxx-lisp-object-metatype*)
-
-(eval-when (:load-toplevel)
-  (setf *cxx-lisp-object-metatype*
-        (qt-smoke-setup-lisp-object (callback destruct-cxx-lisp-object)))
-  (assert (>= *cxx-lisp-object-metatype*
-              (smoke::value meta-type.+user+))
-          (*cxx-lisp-object-metatype*)
-          "setup of lisp-object failed"))
-
-(defun make-cxx-lisp-object (object)
-  "Constructs a C++ object wrapper for OBJECT."
-  (let ((id (gen-cxx-lisp-object-id)))
-    (setf (gethash id *cxx-lisp-objects*) object)
-    (qt-smoke-make-lisp-object id)))
-
-(defun free-cxx-lisp-object (pointer)
-  "Deletes the lisp_object at POINTER."
-  (qt-smoke-free-lisp-object pointer))
-;;  (qmetatype.destroy *cxx-lisp-object-metatype* pointer)) ;; FIXME use this?
-
-(defun translate-cxx-lisp-object (pointer)
-  "Returns the object of the cxx-lisp-object at POINTER.
-
-When beeing received as an argument by a slot,
-the object must not be deallocated."
-  (multiple-value-bind (value present-p)
-      (gethash (qt-smoke-lisp-object-id pointer)
-               *cxx-lisp-objects*)
-    (assert present-p (value present-p)
-            "No object for ~A in ~A" pointer *cxx-lisp-objects*)
-    value))
diff -rN -u old-qt.gui/src/msg-handler.lisp new-qt.gui/src/msg-handler.lisp
--- old-qt.gui/src/msg-handler.lisp	2014-11-25 11:01:46.000000000 +0100
+++ new-qt.gui/src/msg-handler.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,26 +0,0 @@
-(in-package :qt)
-
-(cffi:defcenum qt-msg-type
-  (:debug-message)
-  (:warning-message)
-  (:critical-message)
-  (:fatal-message))
-
-(defcallback qt-msg-handler :void
-    ((type qt-msg-type)
-     (message :string))
-  (ecase type
-    (:debug-message
-     (write-string "qDebug: " *debug-io*)
-     (write-line message *debug-io*))
-    (:warning-message (warn message))
-    (:critical-message (cerror "Ignore" "~A" message))
-    (:fatal-message (error message))))
-
-(defun register-msg-handler ()
-  (with-foreign-object (handler :pointer)
-    (setf (mem-ref handler :pointer) (callback qt-msg-handler))
-    (qt:q-install-msg-handler handler)))
-
-(eval-when (:load-toplevel)
-  (register-msg-handler))
diff -rN -u old-qt.gui/src/object.lisp new-qt.gui/src/object.lisp
--- old-qt.gui/src/object.lisp	2014-11-25 11:01:47.000000000 +0100
+++ new-qt.gui/src/object.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,190 +0,0 @@
-(in-package :qt)
-(declaim (optimize (debug 3)))
-
-(let ((object (make-instance 'object)))
-  (defmethod cxx:static-meta-object ((class (eql (find-class 'object))) &rest args)
-    "No OBJECT.STATIC-META-OBJECT (r558420)."
-    (declare (ignore args))
-    (cxx:meta-object object))
-  (defmethod cxx:static-meta-object ((class smoke::smoke-wrapper-class) &rest args)
-    (declare (ignore args))
-    (cxx:static-meta-object (smoke::find-smoke-class class))))
-
-(defmethod documentation :around ((class smoke::smoke-standard-class)
-                                  (doc-type t))
-  (if (and (subtypep class (find-class 'object))
-           (not (subtypep class (find-class 'smoke::smoke-wrapper-class))))
-      (format nil "~@[~A~%~]Properties:~%~T~{~<~%~T~0,75:; ~(~A~)~>~}
-
-Signals:
-~{~T~A~%~}
-Slots:
-~{~T~A~%~}"
-              (call-next-method) (sort (class-properties class) #'string<=)
-              (sort (class-signals class) #'string<=)
-              (sort (class-slots class) #'string<=))
-      (call-next-method)))
-
-(defun meta-object-methods (meta-object &optional (direct-only nil))
-  (loop for index from (if direct-only (cxx:method-offset meta-object) 0)
-     below (cxx:method-count meta-object)
-     collect (cxx:method meta-object index)))
-
-
-(defun meta-object-signals (meta-object)
-  (mapcar #'cxx:signature
-          (remove-if-not #'(lambda (m) (enum= qt:meta-method.+signal+
-                                                  (cxx:method-type m)))
-                         (meta-object-methods meta-object))))
-
-(defun class-signals (class)
-  (meta-object-signals (cxx:static-meta-object class)))
-
-(defun meta-object-slots (meta-object)
-  (mapcar #'cxx:signature
-          (remove-if-not #'(lambda (m) (enum= qt:meta-method.+slot+
-                                                  (cxx:method-type m)))
-                         (meta-object-methods meta-object))))
-
-
-(defun class-slots (class)
-  (meta-object-slots (cxx:static-meta-object class)))
-
-
-(defvar *children* (make-hash-table)
-  "A list of custom subclasses of QObject which have a parent
-and therefor must not be garbage collected.")
-
-(defmethod initialize-instance :after ((object object)
-                                        &key pointer &allow-other-keys)
-  "Registers the object to the parent when a parent was set in the constructor
-and the objects metaclass is SMOKE-WRAPPER-CLASS."
-  (when (and (null pointer)
-             (null-pointer-p (smoke::pointer object)))
-    (error "Object ~A has not been constructed" object))
-  (when (and (null pointer)
-             (not (null-pointer-p (smoke::pointer object)))
-;             (typep (class-of object) 'smoke::smoke-wrapper-class)
-             (not (null-pointer-p (smoke::pointer (cxx:parent object)))))
-    (setf (gethash (smoke::pointer object) *children*) object)))
-
-(define-condition wrapper-gc (storage-condition)
-  ((class-name :initarg :class-name
-               :documentation "The class name of the gc'ed object.")
-   (pointer :initarg :pointer))
-  (:report (lambda (condition stream)
-             (format stream "The object ~A ~A of type smoke-wrapper-class
-has a parent but got garbage collected."
-                     (slot-value condition 'class-name)
-                     (slot-value condition 'pointer)))))
-
-(let ((get-parent (smoke::make-smoke-method (smoke::make-smoke-class
-                                             *qt-smoke*
-                                             "QObject")
-                                            "parent"))
-      ;; FIXME this leaks memory when QCoreApplication::exec is never called,
-      ;;  beause then, deleteLater has no effect.
-      (delete-later (smoke::make-smoke-method (smoke::make-smoke-class
-                                               *qt-smoke*
-                                               "QObject")
-                                              "deleteLater")))
-  (defmethod smoke::make-finalize ((object object))
-    "Delete the qt:object OBJECT,
- by calling cxx:delete-later iff it has no parent."
-    (let ((pointer (pointer object))
-          (name (class-name (class-of object)))
-          (next (call-next-method)))
-      (if (typep (class-of object) 'smoke::smoke-wrapper-class)
-          #'(lambda ()
-              (handler-case 
-                  (if (null-pointer-p (smoke::pointer-call get-parent pointer))
-                      (smoke::pointer-call delete-later pointer)
-                      (error (make-condition 'wrapper-gc :class-name name
-                                             :pointer pointer)))
-                (condition (condition)
-                  (format *debug-io* "error: wrap finalize ~A ~A~%" name
-                          condition))))
-          #'(lambda ()
-              (handler-case 
-                  (progn
-                  (when (null-pointer-p (smoke::pointer-call get-parent pointer))
-                    (funcall next)))
-                (condition (condition)
-                  (format *debug-io* "error: qfinalize ~A ~A ~A~%" name
-                          pointer
-                          condition)))))))
-                                        ;(smoke::pointer-call delete-later pointer)))))))
-  )
-(defun cxx-gc ()
-  "Delete the C++ object that have been queued for deletion when
-QT:CORE-APPLICATION.EXEC is run."
-  (core-application.send-posted-events 
-   (make-instance 'object :pointer (null-pointer))
-event.+deferred-delete+))
-
-
-;(defmethod upcast-object ((objeckt qobject))
-;  (let ((class-name (cxx:classname (cxx:metaobject object))))
-;    (if (string= class-name (name (get-class object)))
-;        object
-;        (let ((real-class (lispify class-name)))
-;;FIXME get smoke module from class name
-;        (make-instance
-;         :pointer upcast (object class))))))))
-        
-     
-;(defmethod upcast-object ((event qevent))
-;  (case (cxx:type event)
-;    (#.qevent.+childadded+
-
-;;;
-;;; The event-notify callback get called by QCoreApplication,
-;;; on notification of an event.
-;;;
-;;; The DATA argument is an array of size three, containing the pointers:
-;;;  void* receiver
-;;;  void* event
-;;;  void* result
-;;; in that order.
-;;; 
-;;; Returning true marks the event as handled; false on the other hand
-;;; leaves the event processing unchanged.
-;;;
-;;; See: QCoreApplication::notifyInternal(QObject *receiver, QEvent *event)
-
-(cffi:defcallback event-notify smoke:cxx-bool
-    ((data :pointer))
-  (declare (optimize (speed 3)))
-  (let ((event (make-instance 'event :pointer (cffi:mem-aref data :pointer 1)
-                              :owned-p nil)))
-    (enum-case (cxx:type event)
-      (event.+child-added+
-       (let* ((child-event (make-instance 'child-event
-                                          :pointer
-                                          (smoke::upcast event (find-class 'child-event))
-                                          :owned-p nil))
-              (child (smoke::get-object
-                      (smoke::pointer (cxx:child child-event)))))
-;         (when (and child
-;                    (typep (class-of child)
-;                           'smoke::smoke-wrapper-class))
-         (when child
-           (setf (gethash (smoke::pointer child) *children*) child))))
-      (event.+child-removed+
-       (let* ((child-event (make-instance 'child-event
-                                          :pointer (smoke::upcast event
-                                                                  (find-class 'child-event))
-                                          :owned-p nil)))
-         (remhash (smoke::pointer (cxx:child child-event)) *children*)))))
-  nil)
-    
-(cffi:defcfun qt-smoke-register-event-notify :boolean
-  (event-notify :pointer))
-
-(defun register-event-notify ()
-  (let ((ret (qt-smoke-register-event-notify (cffi:callback event-notify))))
-    (unless ret
-      (error "The event-notify callback table is full."))))
-
-(eval-when (:load-toplevel)
- (register-event-notify))
diff -rN -u old-qt.gui/src/ownership.lisp new-qt.gui/src/ownership.lisp
--- old-qt.gui/src/ownership.lisp	1970-01-01 01:00:00.000000000 +0100
+++ new-qt.gui/src/ownership.lisp	2014-11-25 11:01:47.000000000 +0100
@@ -0,0 +1,82 @@
+(in-package :cl-smoke.qt.gui)
+
+;; undo-stack
+(define-takes-ownership cxx:push ((undo-stack qt:undo-stack) undo-command)
+  undo-command)
+
+
+#|
+;; FIXME TODO
+;; application
+(define-takes-ownership cxx:set-style ((application application) (style style))
+  ;; NOT QString style
+  style) ;; STATIC 
+
+
+;; core-application
+(define-takes-ownership cxx:post-event ((app core-application) receiver (event event))
+  event) ;; STATIC
+(define-takes-ownership cxx:post-event ((app core-application) receiver event priority)
+  event) ;; STATIC
+|#
+
+;; AbstractFileEngine::beginEntryList return value
+
+;; grid-layout
+(define-takes-ownership cxx:add-item ((layout qt:grid-layout) (item qt:layout-item)
+                                      row column)
+  item)
+(define-takes-ownership cxx:add-item ((layout qt:grid-layout) (item qt:layout-item)
+                                      row column row-span)
+  item)
+(define-takes-ownership cxx:add-item ((layout qt:grid-layout) (item qt:layout-item)
+                                      row column row-span colum-span)
+  item)
+(define-takes-ownership cxx:add-item ((layout qt:grid-layout) (item qt:layout-item)
+                                      row column row-span colum-span aligment)
+  item)
+
+(define-takes-ownership cxx:add-item ((layout qt:layout) (item qt:layout-item))
+  item)
+
+;; QIcon::QIcon(QIconEngine* engine)
+
+(define-takes-ownership cxx:register-editor ((factory qt:item-editor-factory)
+                                             type creator)
+  creator)
+
+
+(define-takes-ownership cxx:set-child ((this qt:standard-item) row colum item)
+  item)
+(define-takes-ownership cxx:set-child ((this qt:standard-item) row item)
+  item)
+(define-takes-ownership cxx:set-horizontal-header-item ((this qt:standard-item-model)
+                                                        column item)
+  item)
+(define-takes-ownership cxx:set-vertical-header-item ((this qt:standard-item-model)
+                                                        row item)
+  item)
+(define-takes-ownership cxx:set-item ((this qt:standard-item-model)
+                                       row column item)
+  item)
+(define-takes-ownership cxx:set-item ((this qt:standard-item-model)
+                                       row item)
+  item)
+(define-takes-ownership cxx:set-item-prototype ((this qt:standard-item-model)
+                                                item)
+  item)
+
+;; FIXME graphic-item has a lot more.
+(define-takes-ownership cxx:add-item ((this qt:graphics-scene) item)
+  item)
+
+;; Allocates return value
+;; QLineEdit::createStandardContextMenu()
+
+;; parent
+;; QListwidgetitem
+
+
+;; Releases ownership
+;;QList<QStandardItem *> QStandardItemModel::takeColumn ( int column )
+;; etc
diff -rN -u old-qt.gui/src/package.lisp new-qt.gui/src/package.lisp
--- old-qt.gui/src/package.lisp	2014-11-25 11:01:47.000000000 +0100
+++ new-qt.gui/src/package.lisp	2014-11-25 11:01:47.000000000 +0100
@@ -1,42 +1,2 @@
-(defpackage :qt
-  (:use :cl :asdf :smoke :cffi :bordeaux-threads :cxx-support)
-  (:export #:new
-           #:call
-
-           #:app
-           #:app-p
-           #:exec
-           #:with-app
-           #:with-core-app
-
-           #:with-painter
-           #:single-shot
-           #:do-delayed-initialize
-           
-           #:tr
-           #:with-translator
-           #:with-libqt-translator 
-
-           #:qmethod
-           #:qsignal
-           #:qslot
-
-           #:property
-           #:property-p
-           #:properties
-           #:class-properties
-           #:class-direct-properties
-
-           #:from-variant
-           #:make-variant
-           #:make-lisp-variant
-
-           #:connect
-           #:get-slot
-           #:get-signal
-           #:make-slot
-           #:make-signal
-           #:connect-signal
-           #:connect-function
-           #:sender))
-
+(defpackage :cl-smoke.qt.gui
+  (:use :cl :smoke :cffi :bordeaux-threads :cxx-support :alexandria))
diff -rN -u old-qt.gui/src/painter.lisp new-qt.gui/src/painter.lisp
--- old-qt.gui/src/painter.lisp	2014-11-25 11:01:46.000000000 +0100
+++ new-qt.gui/src/painter.lisp	2014-11-25 11:01:47.000000000 +0100
@@ -1,16 +1,22 @@
-(in-package :qt)
+(in-package :cl-smoke.qt.gui)
 
-(defmacro with-painter ((painter paint-device) &body body)
+(defmacro qt:with-painter ((painter &optional paint-device) &body body)
   "Binds a PAINTER instance for PAINT-DEVICE to PAINTER
- during the evaulation of BODY.
+ during the evaluation of BODY. Or when PAINT-DEVICE is not
+specified, saves and restored the state of PAINTER around BODY.
 
-Makes sure the painter ends after BODY; thus prevening problems with 
-still active and not yet garbage collected painters."
-  `(let ((,painter (make-instance 'painter :args (list ,paint-device))))
-     (assert (cxx:is-active ,painter)
-             (,painter)
-             "Painter ~A for ~A is not active"
-             ,painter ,paint-device)
-     (unwind-protect
-          (progn ,@body)
-       (cxx:end ,painter))))
+Makes sure the painter ends after BODY; thus preventing problems with 
+still active and not yet garbage collected painters in CXX:PAINT-EVENT."
+  (if paint-device
+      `(let ((,painter (make-instance 'qt:painter :arg0 ,paint-device)))
+         (assert (cxx:is-active ,painter)
+                 (,painter)
+                 "Painter ~A for ~A is not active"
+                 ,painter ,paint-device)
+         (unwind-protect
+              (progn ,@body)
+           (cxx:end ,painter)))
+      `(progn (cxx:save ,painter)
+              (unwind-protect
+                   (progn ,@body)
+                (cxx:restore ,painter)))))
diff -rN -u old-qt.gui/src/properties.lisp new-qt.gui/src/properties.lisp
--- old-qt.gui/src/properties.lisp	2014-11-25 11:01:47.000000000 +0100
+++ new-qt.gui/src/properties.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,50 +0,0 @@
-(in-package :qt)
-
-(defun reverse-lispify (symbol)
-  "Converts the name of symbol to C++ style."
-  (smoke::lisp-to-cxx (symbol-name symbol)))
-
-(defun property-name (name)
-  "The property name is a string or a to camelCase converted symbol."
-  (typecase name
-    (string name)
-    (symbol (reverse-lispify name))))
-
-(defun property (object name)
-  "Returns the property NAME of OBJECT."
-  (from-variant (cxx:property object (property-name name))))
-
-(defun (setf property) (new-value object name)
-    (cxx:set-property object (property-name name)
-     (make-instance 'qt:variant
-                    :args (list new-value)))
-  new-value)
-
-(defun property-p (object name)
-  "Returns T when NAME is a property of OBJECT and NIL otherwise."
-  (valid-p (cxx:property object (property-name name))))
-
-(defun meta-object-properties (meta-object &optional (all t))
-  "Returns a list of the properties of META-OBJECT."
-  (loop for index from (if all 0 (cxx:property-offset meta-object))
-     below (cxx:property-count meta-object)
-     collect (smoke::lispify (cxx:name (cxx:property meta-object index)))))
-
-(defgeneric class-properties (class)
-  (:documentation "Returns a list of the properties of CLASS.")
-  (:method ((class class))
-    (meta-object-properties (cxx:static-meta-object class)))
-  (:method ((symbol symbol))
-    (class-properties (find-class symbol))))
-
-(defgeneric class-direct-properties (class)
-  (:documentation "Returns a list of the properties of CLASS.")
-  (:method ((class class))
-    (meta-object-properties (cxx:static-meta-object class) nil))
-  (:method ((symbol symbol))
-    (class-direct-properties (find-class symbol))))
-
-(defun properties (object)
-  "Returns a list of the properties of OBJECT."
-  (warn "FIXME: dynamicPropertyNames not implemented")
-  (meta-object-properties (cxx:meta-object object)))
diff -rN -u old-qt.gui/src/qstring.lisp new-qt.gui/src/qstring.lisp
--- old-qt.gui/src/qstring.lisp	2014-11-25 11:01:47.000000000 +0100
+++ new-qt.gui/src/qstring.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,59 +0,0 @@
-(in-package :qt)
-
-(defcfun qt-smoke-string-to-qstring :pointer
-  (data :string)
-  (length :int))
-
-(defcfun qt-smoke-free-qstring :void
-  (string :pointer))
-
-(defcfun qt-smoke-qstring-to-byte-array :pointer
-  (qstring :pointer))
-
-(define-foreign-type qstring ()
-  ()
-  (:actual-type :pointer))
-
-(defun setup-type-map ()
-  (smoke::add-type "QString" 'qstring)
-  (smoke::add-type "const QString&" 'qstring))
-
-(eval-when (:load-toplevel :execute)
-  (setup-type-map))
-
-;;; make sure, that you have configured slime corretly.
-;;; e.g.
-;;; (string #\U9999) crashed slime for me. Adding
-;;; (set-language-environment "UTF-8")
-;;; (setq slime-net-coding-system 'utf-8-unix)
-;;; to .emacs helps.
-(eval-when (:compile-toplevel :load-toplevel :execute)
-  (text-codec.set-codec-for-cstrings
-   (text-codec.codec-for-name (string *default-foreign-encoding*)))
-  (text-codec.set-codec-for-locale
-   (text-codec.codec-for-name (string *default-foreign-encoding*))))
-
-
-(define-parse-method qstring ()
-  (make-instance 'qstring))
-
-(defmethod translate-to-foreign (string (type qstring))
-  (with-foreign-string ((data length) string :null-terminated-p nil)
-    (qt-smoke-string-to-qstring data length)))
-
-(let ((method (smoke::make-smoke-method (find-class 'byte-array)
-                                        "data")))
-  (defmethod cxx:data ((array byte-array) &rest args)
-    (declare (ignore args))
-    (values ;; Discarge second return value (length of string)
-     (foreign-string-to-lisp (smoke::pointer-call method
-                                                  (smoke::pointer array))
-                             :count (cxx:size array)))))
-
-(defmethod translate-from-foreign (string (type qstring))
-  (cxx:data (make-instance 'byte-array
-                           :pointer (qt-smoke-qstring-to-byte-array string))))
-
-(defmethod free-translated-object (pointer (type qstring) param)
-  (declare (ignore param))
-  (qt-smoke-free-qstring pointer))
diff -rN -u old-qt.gui/src/qt.gui.lisp new-qt.gui/src/qt.gui.lisp
--- old-qt.gui/src/qt.gui.lisp	1970-01-01 01:00:00.000000000 +0100
+++ new-qt.gui/src/qt.gui.lisp	2014-11-25 11:01:47.000000000 +0100
@@ -0,0 +1,32 @@
+;;; Copyright (C) 2009, 2010 Tobias Rautenkranz <tobias@rautenkranz.ch>
+;;;
+;;; This program is free software: you can redistribute it and/or modify
+;;; it under the terms of the GNU General Public License as published by
+;;; the Free Software Foundation, either version 3 of the License, or
+;;; (at your option) any later version.
+;;;
+;;; This program is distributed in the hope that it will be useful,
+;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;;; GNU General Public License for more details.
+;;;
+;;; You should have received a copy of the GNU General Public License
+;;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+;;;
+;;; As a special exception, the copyright holders of this library give you
+;;; permission to link this library with independent modules to produce an
+;;; executable, regardless of the license terms of these independent
+;;; modules, and to copy and distribute the resulting executable under
+;;; terms of your choice, provided that you also meet, for each linked
+;;; independent module, the terms and conditions of the license of that
+;;; module. An independent module is a module which is not derived from or
+;;; based on this library. If you modify this library, you may extend this
+;;; exception to your version of the library, but you are not obligated to
+;;; do so. If you do not wish to do so, delete this exception statement
+;;; from your version.
+
+(in-package :cl-smoke.qt.gui)
+
+(define-smoke-module :cl-smoke.qt libsmokeqtgui
+  (*qt-gui-smoke* "qtgui_Smoke")
+  (init-qt-gui-smoke "init_qtgui_Smoke"))
diff -rN -u old-qt.gui/src/qt.lisp new-qt.gui/src/qt.lisp
--- old-qt.gui/src/qt.lisp	2014-11-25 11:01:47.000000000 +0100
+++ new-qt.gui/src/qt.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,33 +0,0 @@
-(in-package :qt)
-
-(eval-when (:load-toplevel :compile-toplevel :execute)
-  (define-foreign-library libsmokeqt
-    (:unix "libsmokeqt.so.2")
-    (t (:default "libsmokeqt")))
-
-  (use-foreign-library libsmokeqt)
-
-  (use-foreign-library libqt-smoke-extra)
-  
-  (defcvar "qt_Smoke" :pointer
-    "The Smoke Qt binding")
-
-  (defcfun (init-qt-smoke "_Z13init_qt_Smokev") :void)
-
-  (defvar *qt-binding* (null-pointer))
-
-  (init-qt-smoke))
-
-(eval-when (:load-toplevel :compile-toplevel)
-  (when (null-pointer-p *qt-binding*)
-    (setf *qt-binding* (init *qt-smoke*))))
-  ;(make-smoke-classes *qt-smoke*))
-
-(define-methods *qt-smoke*)
-
-
-(defun new (class-name method-name &rest args)
-  (apply #'new-object *qt-binding* class-name method-name args))
-
-(defun static-call (class-name method-name &rest args)
-  (apply #'smoke::static-call *qt-smoke* class-name method-name args))
diff -rN -u old-qt.gui/src/signal-slot/connect.lisp new-qt.gui/src/signal-slot/connect.lisp
--- old-qt.gui/src/signal-slot/connect.lisp	2014-11-25 11:01:46.000000000 +0100
+++ new-qt.gui/src/signal-slot/connect.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,168 +0,0 @@
-(in-package :qt)
-
-(defgeneric connect (qsignal slot &optional type)
-  (:documentation "Connects a signal to a slot."))
-
-(defgeneric disconnect (qsignal slot)
-  (:documentation "Disconnects a connection."))
-
-(defgeneric disconnect-all (qsignal)
-  (:documentation "Disconnects all connections of QSIGNAL."))
-
-(defun check-argument-types (signal-arguments slot-arguments)
-  (assert (= (length signal-arguments) (length slot-arguments)))
-  (loop for signal-arg in signal-arguments
-     for slot-arg in slot-arguments do
-     (assert (subtypep signal-arg slot-arg))))
-
-;;FIXME check argument-types
-(defmethod connect ((qsignal qsignal) (qslot qslot) &optional type)
-  (assert (or (slot-boundp (signal-object qsignal) 'argument-types)
-              (slot-boundp qslot 'arguments))
-          ((slot-value (signal-object qsignal) 'argument-types)
-           (slot-value qslot 'arguments))
-          "Argument types must be specified for at least on of
-~A and ~A." qsignal qslot)
-  (when (not (slot-boundp (signal-object qsignal) 'argument-types))
-    (setf (argument-types (signal-object qsignal))
-          (arguments qslot)))
-  (when (not (slot-boundp qslot 'arguments))
-    (setf  (slot-value qslot 'arguments)
-           (argument-types (signal-object qsignal))))
-  (check-argument-types (argument-types (signal-object qsignal))
-                        (arguments qslot))
-  (unless (connect-id (signal-object qsignal) (id (signal-object qsignal))
-                      qslot (id qslot)
-                      type
-                      (types (arguments qslot)))
-    (cerror "Failed to connect ~S to ~S." qsignal qslot)))
-
-(defmethod connect ((sender qsignal) (function function) &optional type)
-  (let ((slot (make-instance 'qslot
-                             :args (list (signal-object sender))
-                             :slot-function function)))
-    (unless (connect-id (signal-object sender) (id (signal-object sender))
-                        slot (id slot)
-                        type 
-                        (types (arguments sender)))
-      (cerror "Failed to connect the function ~S to the signal ~S."
-              function sender))))
-
-(defclass qt-signal-slot-name ()
-  ((name :initarg :name
-       :reader name)))
-
-(defclass qt-signal (qt-signal-slot-name)
-  ((sender :initarg :sender
-           :reader qsender))
-  (:documentation "Qt C++ signal."))
-
-(defclass qt-slot (qt-signal-slot-name)
-  ((receiver :initarg :receiver
-             :reader receiver))
-  (:documentation "Qt C++ slot."))
-
-(defun get-slot (receiver name)
-  "Returns the slot of RECEIVER with NAME."
-  (make-instance 'qt-slot :receiver receiver :name name))
-
-(defun get-signal (sender name)
-  "Returns the signal NAME of SENDER."
-  (make-instance 'qt-signal :sender sender :name name))
-   
-(defmethod connect ((qt-signal qt-signal) (qt-slot qt-slot) &optional type)
-  (unless (object.connect (qsender qt-signal) (qsignal (name qt-signal))
-                          (receiver qt-slot) (qslot (name qt-slot))
-                          (or type +auto-connection+))
-    (cerror "Failed to connect ~A ~A to ~A ~A."
-            (qsender qt-signal) (name qt-signal)
-            (receiver qt-slot) (name qt-slot))))
-
-(defmethod disconnect ((qt-signal qt-signal) (qt-slot qt-slot))
-  (unless (object.disconnect (qsender qt-signal) (qsignal (name qt-signal))
-                             (receiver qt-slot) (qslot (name qt-slot)))
-    (cerror "Failed to disconnect ~A ~A from ~A ~A."
-            (receiver qt-slot) (name qt-slot)
-            (qsender qt-signal) (name qt-signal))))
-
-(defmethod disconnect-all ((sender object))
-  (unless (object.disconnect sender 0 0 0)
-    (cerror "Failed to disconnect everything connected to ~A."
-            sender)))
-
-       
-(defmethod connect ((qt-signal qt-signal) (function function) &optional type)
-  (let* ((signal-id (find-signal-id (qsender qt-signal) (name qt-signal)))
-         (slot (make-instance 'qslot
-                              ;; Set the sender as the slots parent,
-                              ;; to ensure it does not get gc'ed.
-                              ;; FIXME: unset parent on disconnect
-                              ;;   this no not critical beause the slot object
-                              ;;   is hidden from the user, who thus can not
-                              ;;   connect it to other signals.
-                              :args (list (qsender qt-signal))
-                              :slot-function function
-                              :argument-types
-                              (method-arguments-type
-                               (cxx:meta-object (qsender qt-signal))
-                               signal-id))))
-    (if (connect-id (qsender qt-signal) signal-id
-                    slot (id slot)
-                    type (types (arguments slot)))
-        (cxx:connect-notify (qsender qt-signal)
-                            (name qt-signal))
-        (cerror "Ignore" "Failed to connect the signal ~S of ~S to the function ~S."
-                (name qt-signal) (qsender qt-signal) function))))
-  
-(defmethod connect ((qt-signal qt-signal) (slot qslot) &optional type)
-  (let ((signal-id (find-signal-id (qsender qt-signal) (name qt-signal))))
-    (if (slot-boundp slot 'arguments)
-        (check-argument-types (method-arguments-type (cxx:meta-object
-                                                      (qsender qt-signal))
-                                                     signal-id)
-                              (arguments slot))
-        (setf (slot-value slot 'arguments)
-              (method-arguments-type (cxx:meta-object (qsender qt-signal))
-                                     signal-id)))
-    (if (connect-id (qsender qt-signal) signal-id
-                    slot (id slot)
-                    type (types (arguments slot)))
-        (cxx:connect-notify (qsender qt-signal)
-                            (name qt-signal))
-        (cerror "Ignore" "Failed to connect the signal ~S of ~S to the slot ~S."
-                (name qt-signal) (qsender qt-signal) slot))))
-
-(defmethod connect ((qsignal qsignal) (slot qt-slot) &optional type)
-  (let ((slot-id (find-slot-id (receiver slot) (name slot))))
-    (if (slot-boundp (signal-object qsignal) 'argument-types)
-        (check-argument-types (argument-types (signal-object slot))
-                              (method-arguments-type (cxx:meta-object
-                                                      (receiver slot))
-                                                     slot-id))
-        (setf (argument-types (signal-object qsignal))
-              (method-arguments-type (cxx:meta-object (receiver slot))
-                                      slot-id)))
-    (unless (connect-id (signal-object qsignal) (id (signal-object qsignal))
-                        (receiver slot) slot-id
-                        type
-                        (types (argument-types (signal-object qsignal))))
-      (cerror "Failed to connect ~S to ~S." qsignal slot))))
-    
-
-(defun connect-id (sender signal-id receiver slot-id type types)
-  (static-call "QMetaObject" "connect#$#$$$"
-               sender
-               signal-id
-               receiver
-               slot-id
-               (if (null type)
-                   (value +auto-connection+)
-                   (value type))
-               types))
-
-(defun disconnect-id (sender signal-id receiver slot-id)
-  (static-call "QMetaObject" "disconnect#$#$"
-                       sender
-                       signal-id
-                       receiver
-                       slot-id))
diff -rN -u old-qt.gui/src/signal-slot/signal-slot.lisp new-qt.gui/src/signal-slot/signal-slot.lisp
--- old-qt.gui/src/signal-slot/signal-slot.lisp	2014-11-25 11:01:46.000000000 +0100
+++ new-qt.gui/src/signal-slot/signal-slot.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,35 +0,0 @@
-(in-package :qt)
-
-
-(defclass funcallable-smoke-class (closer-mop:funcallable-standard-class
-                                   smoke::smoke-wrapper-class)
-  ())
-
-(defmethod closer-mop:validate-superclass ((class funcallable-smoke-class)
-                                           (superclass closer-mop:funcallable-standard-class))
-  t)
-
-(defgeneric id (method))
-
-(defun munged-name-p (name)
-  "Returns true when NAME is a METHOD, SLOT or SIGNAL."
-  (and (> (length name) 0)
-       (case (aref name 0)
-         ((#\0 #\1 #\2) t)
-         (t nil))))
-
-(defun qmethod (name)
-  "Equivalent of the METHOD(a) CPP macro."
-  (assert (not (munged-name-p name)))
-  (format nil "0~A" name))
-
-(defun qslot (name)
-  "Equivalent of the SLOT(a) CPP macro."
-  (assert (not (munged-name-p name)))
-  (format nil "1~A" name))
-
-(defun qsignal (name)
-  "Equivalent of the SIGNAL(a) CPP macro."
-  (assert (not (munged-name-p name)))
-  (format nil "2~A" name))
-
diff -rN -u old-qt.gui/src/signal-slot/signal.lisp new-qt.gui/src/signal-slot/signal.lisp
--- old-qt.gui/src/signal-slot/signal.lisp	2014-11-25 11:01:46.000000000 +0100
+++ new-qt.gui/src/signal-slot/signal.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,160 +0,0 @@
-(in-package :qt)
-(declaim (optimize (debug 3)))
-
-(defclass qsignal-mixin ()
-  ((signal-object :accessor signal-object
-                  :initarg :signal-object
-                  :initform (make-instance 'signal-object)))
-  (:documentation "in SB-PCL you can not have both
-FUNCALLABLE-STANDARD-CLASS and STANDARD-CLASS,
-thus QSIGNAL is split in three classes.
-
-See: 
- http://www.sbcl.org/manual/Metaobject-Protocol.html#index-validate_002dsuperclass-164"))
-  
-(defclass signal-object (object)
-  ((argument-types :accessor argument-types
-                   :initarg :argument-types
-                   :documentation "List of the argument types"))
-  (:documentation "Qt Signal object.")
-  (:metaclass cxx:class))
-
-#+cmu (defmethod closer-mop:validate-superclass ((class closer-mop:funcallable-standard-class)
-                                           (superclass standard-class))
-  t)
-
-(defclass qsignal (closer-mop:funcallable-standard-object qsignal-mixin)
-  ()
-  (:metaclass closer-mop:funcallable-standard-class)
-  (:documentation "A funcallable Qt signal.
-The argument types can be supplied by the :METHOD-TYPES initarg.
-Calling an instance emits the signal."))
-
-(defun make-signal (&rest argument-types)
-  "Returns a funcallable signal. When ARGUMENT-TYPES are not
-specified, they are determined when the first connection is made."
-  (if argument-types
-    (make-instance 'qsignal :argument-types argument-types)
-    (make-instance 'qsignal)))
-
-(defmethod id ((qsignal signal-object))
-  (cxx:method-count (cxx:meta-object qsignal)))
-
-(defmethod initialize-instance :after ((object qsignal) &rest initargs
-                                       &key (argument-types nil arg-types-p)
-                                       &allow-other-keys)
-  (declare (ignore initargs))
-  (when arg-types-p
-    (setf (argument-types (signal-object object))
-          argument-types))
-  (closer-mop:set-funcallable-instance-function object
-                                                #'(lambda (&rest args)
-                                                    (apply #'emit (signal-object object) args))) 
-  )
-
-(defun find-slot-id (receiver slot)
-  "Returns the ID of RECEIVER from SLOT."
-  (let ((id (cxx:index-of-slot (cxx:meta-object receiver)
-                               (cxx:data (meta-object.normalized-signature slot)))))
-    (when (< id 0)
-      (error "No slot ~S for class ~S.
-The valid slots are: ~{~<~%~T~0,75:;~A ~>~}"
-             slot (class-of receiver)
-             (class-slots (class-of receiver))))
-    id))
-
-(defun connect-signal (qsignal receiver slot &optional (type 0))
-  "Connects a signal to a slot. Returns T on success and NIL otherwise."
-  
-  (let ((qsignal (signal-object qsignal))
-        (slot-id (find-slot-id receiver slot)))
-    (when (not (slot-boundp qsignal 'argument-types))
-      (setf (argument-types qsignal)
-            (method-arguments-type (cxx:meta-object receiver)
-                                   slot-id)))
-    (assert (>= slot-id 0)
-            ()
-            "No slot ~S for class ~S."
-            slot (class-name receiver))
-    (assert (static-call "QMetaObject" "connect#$#$$$"
-                         qsignal
-                         (id qsignal)
-                         receiver
-                         slot-id
-                         type
-                         ;; QMetaObject::connect is responsible for freeing
-                         ;; the types array.
-                         (types (method-arguments-type
-                                 (cxx:meta-object receiver)
-                                 slot-id)))
-            ()
-            "Failed to connect ~S to the slot ~S of ~S."
-            qsignal slot receiver)))
-
-(defun disconnect-signal (qsignal receiver slot)
-  (let ((qsignal (signal-object qsignal))
-        (slot-id (cxx:index-of-slot (cxx:meta-object receiver)
-                                  (cxx:data
-                                   (meta-object.normalized-signature slot)))))
-    (assert (>= slot-id 0)
-            ()
-            "No slot ~S for class ~S."
-            slot (class-name receiver))
-    (assert (static-call "QMetaObject" "disconnect#$#$"
-                         qsignal
-                         (id qsignal)
-                         receiver
-                         slot-id)
-            ()
-            "Failed to disconnect ~S to the slot ~S of ~S."
-            qsignal slot receiver)))
-
-(defmethod smoke::push-lisp-object (stack object class)
-  (let ((cxx-object (make-cxx-lisp-object object)))
-    (smoke::push-cleanup stack
-
-                         #'(lambda ()
-                             (qt-smoke-free-lisp-object cxx-object)))
-    (smoke::push-stack2 stack
-                        cxx-object
-                        0)))
-                        
-
-(defun emit (qsignal &rest arguments)
-  "Emits the signal QSIGNAL."
-;;; The first element of args would be used for the return value
-;;; by QMetaObject::invokeMethod(), but for signal-slot connection
-;;; it is ignored.
-  (smoke::with-stack (stack arguments
-                            (argument-types qsignal))
-    (cffi:with-foreign-object (args :pointer (1+ (length arguments)))
-      (loop for i from 1 to (smoke::size stack)
-         for type in (argument-types qsignal)
-         do
-         (setf (mem-aref args :pointer i)
-               (if (or (not (typep type (find-class 'smoke::smoke-type)))
-                       (= 0 (smoke::type-id type))
-                       (= 13 (smoke::type-id type)))
-                   (foreign-slot-value
-                    (mem-aref (pointer stack)
-                              'smoke::smoke-stack-item
-                              i)
-                    'smoke::smoke-stack-item 'smoke::voidp)
-                   (foreign-slot-pointer
-                    (mem-aref (pointer stack)
-                              'smoke::smoke-stack-item
-                              i)
-                    'smoke::smoke-stack-item 'smoke::voidp))))
-      (setf (mem-aref args :pointer 0)
-            (null-pointer))
-      (smoke::static-call *qt-smoke* "QMetaObject" "activate##$?"
-                          qsignal
-                          (cxx:meta-object qsignal)
-                          (id qsignal)
-                          args))))
-
-(defmethod disconnect-all ((qsignal qsignal))
-  (unless (disconnect-id (signal-object qsignal)
-                         (id (signal-object qsignal))
-                         0
-                         0)))
diff -rN -u old-qt.gui/src/signal-slot/slot.lisp new-qt.gui/src/signal-slot/slot.lisp
--- old-qt.gui/src/signal-slot/slot.lisp	2014-11-25 11:01:47.000000000 +0100
+++ new-qt.gui/src/signal-slot/slot.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,84 +0,0 @@
-(in-package :qt)
-(declaim (optimize (debug 3)))
-
-(defclass qslot (object)
-  ((arguments :reader arguments :initarg :argument-types
-              :documentation "List of the argument types for the slot.")
-   (function :reader slot-function :initarg :slot-function
-             :initform (error "no function specified")
-             :documentation "The function called when the slot is invoked."))
-  (:metaclass smoke::smoke-wrapper-class)
-  (:documentation "A Qt slot that calls its associated function"))
-
-(defun make-slot (function &optional (arguments nil arguments-p))
-  "Returns a slot that calls FUNCTION when it receives a signal."
-  (if arguments-p
-      (make-instance 'qslot
-                     :slot-function function
-                     :argument-types arguments)
-      (make-instance 'qslot
-                     :slot-function function)))
-
-(defmethod id ((slot qslot))
- (cxx:method-count (cxx:meta-object slot)))
-
-(defparameter *sender* nil)
-(defmacro sender ()
-  "Returns the sender that invoked the slot."
-  `*sender*)
-
-(defun method-argument-count (metaobject index)
-  "Returns the number of arguments for the method INDEX of METAOBJECT."
-  (let ((signature (cxx:signature (cxx:method metaobject index))))
-    (setf signature (subseq signature (1+ (position #\( signature))
-                            (position #\) signature :from-end t)))
-    (if (= 0 (length signature))
-        0
-        (1+ (count #\, signature)))))
-
-(defmethod cxx::qt-metacall ((slot qslot) &rest args
-                             &aux (a (third args)))
-  "Invoke the slots function when it is called. The return value
-of the invoked slot function is ignored."
-  (let ((id (call-next-method)))
-    (if (< id 0)
-        id
-        (if (enum= (first args) meta-object.+invoke-meta-method+)
-            (progn
-              (case id
-                (0 (let ((*sender* (cxx:sender slot)))
-                     (apply (slot-function slot)
-                            (arguments-to-lisp a (arguments slot))))))
-              (1- id))
-            id))))
-
-(defun find-signal-id (sender signal)
-  "Returns the ID of SIGNAL from SENDER."
-  (let ((id (cxx:index-of-signal (cxx:meta-object sender)
-                      (cxx:data (meta-object.normalized-signature signal)))))
-    (when (< id 0)
-      (error "No signal ~S for class ~S."
-             signal (class-of sender)))
-    id))
-
-(defun connect-function (sender signal function &optional (type 0))
-  "Connects FUNCTION to the SIGNAL of SENDER.
-The return value of FUNCTION is ignored."
-  (let* ((signal-id (find-signal-id sender signal))
-         (slot (make-instance 'qslot
-                              :args (list sender)
-                              :slot-function function
-                              :argument-types (method-arguments-type
-                                               (cxx:meta-object sender)
-                                               signal-id))))
-    (let ((ret (static-call "QMetaObject" "connect#$#$$$"
-                            sender
-                            signal-id
-                            slot
-                            (id slot)
-                            type
-                            (types (arguments slot)))))
-      (if ret
-        (cxx:connect-notify sender signal)
-        (cerror "Failed to connect the signal ~S of ~S to the function ~S."
-                signal sender function)))))
diff -rN -u old-qt.gui/src/signal-slot/translate.lisp new-qt.gui/src/signal-slot/translate.lisp
--- old-qt.gui/src/signal-slot/translate.lisp	2014-11-25 11:01:47.000000000 +0100
+++ new-qt.gui/src/signal-slot/translate.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,104 +0,0 @@
-(in-package :qt)
-
-(defun method-argument-count (metaobject index)
-  "Returns the number of arguments the method INDEX of METAOBJECT."
-  (let ((signature (cxx:signature (cxx:method metaobject index))))
-    (setf signature (subseq signature (1+ (position #\( signature))
-                            (position #\) signature :from-end t)))
-    (if (= 0 (length signature))
-        0
-        (1+ (count #\, signature)))))
-
-(defun find-type (name &optional start end)
-  (smoke::make-smoke-type *qt-smoke* (subseq name start end)))
-    
-(defun method-arguments-type (metaobject index)
-  "Returns a type name list for the arguments of method INDEX of METAOBJECT."
-  (let* ((signature (cxx:signature (cxx:method metaobject index)))
-         (arguments (subseq signature (1+ (position #\( signature))
-                            (position #\) signature :from-end t)))
-         (argument-types ())
-         (last-pos (length arguments)))
-    (loop as pos = (position #\, arguments :from-end t :end last-pos)
-       while pos
-       do
-       (push (find-type arguments (1+ pos) last-pos) argument-types)
-       (setf last-pos pos))
-    (when (> last-pos 0)
-      (push (find-type arguments 0 last-pos) argument-types))))
-
-
-(defun arguments-to-lisp2 (argument types values)
-  (if (null types)
-      values
-      (arguments-to-lisp2 (inc-pointer argument (foreign-type-size :pointer))
-                          (rest types)
-                          (nconc values
-                                 (list 
-                                  (typecase (first types)
-                                    (smoke::smoke-type
-                                     (pointer-to-lisp (mem-ref argument :pointer)
-                                                      (first types)))
-                                     
-                                    (t
-                                     (translate-cxx-lisp-object
-                                      (mem-ref argument :pointer)))))))))
-
-(defun pointer-to-lisp (pointer type)
-  (if (smoke::class-p type)
-      (smoke::object-to-lisp (mem-ref pointer :pointer) type)
-      (ecase (smoke::type-id type)
-        (0 (let ((cffi-type (smoke::get-type (name type))))
-             (if (null cffi-type)
-                 (progn 
-                   pointer)
-                 (convert-from-foreign pointer
-                                       cffi-type))))
-        (1 (mem-ref pointer 'cxx-bool))
-        (2 (code-char (mem-ref pointer :char)))
-        (3 (code-char (mem-ref pointer :unsigned-char)))
-        (4 (code-char (mem-ref pointer :short)))
-        (5 (code-char (mem-ref pointer :unsigned-short)))
-        (6 (mem-ref pointer :int))
-        (7 (mem-ref pointer :unsigned-int))
-        (8 (mem-ref pointer :long))
-        (9 (mem-ref pointer :unsigned-long))
-        (10 (mem-ref pointer :float))
-        (11 (mem-ref pointer :double))
-        (12 (make-instance 'enum
-                           :value (mem-ref pointer :long)
-                           :type type)))))
-     
-       
-(defun arguments-to-lisp (arguments types)
-  (arguments-to-lisp2 (inc-pointer arguments ;; index 0 is for the return value
-                                   (foreign-type-size :pointer))
-                      types ()))
-
-
-(defun get-type (smoke-type)
-  (typecase smoke-type
-    (smoke::smoke-standard-object
-     (if (smoke::pointer-p smoke-type)
-         (error "FOO");;qmetatype.+voidstar+
-         (let ((type (meta-type.type (smoke::name smoke-type))))
-           (assert (/= 0 type)
-                   (type)
-                   "The type ~S has no QMetaType."
-                   (smoke::name smoke-type))
-           type)))
-    (t
-     *cxx-lisp-object-metatype*)))
-     
-
-(defun types (smoke-types)
-  ;;FIXME free TYPES on error.
-  (let ((types (cffi:foreign-alloc :int :count (1+ (length smoke-types))))
-        (index 0))
-    (dolist (type smoke-types)
-      (setf (cffi:mem-aref types :int index)
-            (get-type type))
-      (incf index))
-    (setf (cffi:mem-aref types :int index)
-          0)
-    types))
diff -rN -u old-qt.gui/src/string-list.lisp new-qt.gui/src/string-list.lisp
--- old-qt.gui/src/string-list.lisp	2014-11-25 11:01:47.000000000 +0100
+++ new-qt.gui/src/string-list.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,51 +0,0 @@
-(in-package :qt)
-
-(defcfun qt-smoke-string-list-size :int
-  (string-list :pointer))
-
-(defcfun qt-smoke-string-list-at :pointer
-  (string-list :pointer)
-  (index :int))
-
-(defcfun qt-smoke-free-string-list :void
-  (string-list :pointer))
-
-(defcfun qt-smoke-make-string-list :pointer)
-
-(defcfun qt-smoke-string-list-append :void
-  (string-list :pointer)
-  (string :pointer)
-  (length :int))
-
-(define-foreign-type string-list ()
-  ()
-  (:actual-type :pointer))
-
-(eval-when (:load-toplevel)
-  (smoke::add-type "QStringList" 'string-list)
-  (smoke::add-type "const QStringList&" 'string-list))
-
-
-(define-parse-method string-list ()
-  (make-instance 'string-list))
-
-(defmethod translate-to-foreign (sequence (type string-list))
-  (let ((string-list (qt-smoke-make-string-list)))
-    (map nil #'(lambda (string)
-                 (with-foreign-string ((data length) string :null-terminated-p nil)
-                   (qt-smoke-string-list-append string-list data length)))
-         sequence)
-    string-list))
-
-
-(defmethod translate-from-foreign (string-list (type string-list))
-  (let ((vector (make-array (qt-smoke-string-list-size string-list))))
-    (dotimes (index (length vector) vector)
-      (setf (aref vector index)
-            (cxx:data (make-instance 'qt:byte-array
-                                     :pointer (qt-smoke-string-list-at
-                                               string-list index)))))))
-
-(defmethod free-translated-object (string-list (type string-list) param)
-  (declare (ignore param))
-  (qt-smoke-free-string-list string-list))
diff -rN -u old-qt.gui/src/timer.lisp new-qt.gui/src/timer.lisp
--- old-qt.gui/src/timer.lisp	2014-11-25 11:01:47.000000000 +0100
+++ new-qt.gui/src/timer.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,29 +0,0 @@
-(in-package :qt)
-
-(defclass single-shot-timer (qt:object)
-  ((function :initarg :function)
-   (timer-id))
-  (:metaclass cxx:class))
-
-(defvar *single-shot-timers* nil)
-
-(defun single-shot (function &optional (timeout 0))
-  "Run FUNCTION after TIMEOUT seconds, or as soon as all window events
-have been processed when TIMEOUT is 0."
-  (let ((timer (make-instance 'single-shot-timer
-                              :function function)))
-    (setf (slot-value timer 'timer-id)
-          (cxx:start-timer timer (floor timeout 100)))
-    (push timer *single-shot-timers*)))
-
-(defmacro do-delayed-initialize (&body body)
-  "Run body when the event loop starts.
-
-http://techbase.kde.org/Development/Tutorials/Common_Programming_Mistakes#Delayed_Initialization"
-  `(single-shot #'(lambda () ,@body)))
-
-(defmethod cxx:timer-event ((timer single-shot-timer) &rest args)
-  (declare (ignore args))
-  (cxx:kill-timer timer (slot-value timer 'timer-id))
-  (funcall (slot-value timer 'function))
-  (remove timer *single-shot-timers*))
diff -rN -u old-qt.gui/src/translations.lisp new-qt.gui/src/translations.lisp
--- old-qt.gui/src/translations.lisp	1970-01-01 01:00:00.000000000 +0100
+++ new-qt.gui/src/translations.lisp	2014-11-25 11:01:47.000000000 +0100
@@ -0,0 +1,14 @@
+(in-package :cl-smoke.qt.gui)
+
+;; QPoint has a trivial copy ctor and destructor, thus memcpying it
+;; should be fine.
+(cl-smoke.qt.core:define-qvector-translations "QPoint" qt:point)
+(cl-smoke.qt.core:define-qvector-translations "QPointF" qt:point-f)
+
+(cl-smoke.qt.core:define-qvector-translations "unsigned int"
+    (smoke:c-integer :unsigned-int))
+
+(cl-smoke.qt.core::define-qlist-wrapper "QAction*" qt:action "void")
+(cl-smoke.qt.core::define-qlist-wrapper "QGraphicsItem*" qt:graphics-item "void")
+(cl-smoke.qt.core::define-qlist-wrapper "QStandardItem*" qt:standard-item "void")
+(cl-smoke.qt.core::define-qlist-wrapper "QWidget*" qt:widget "void")
diff -rN -u old-qt.gui/src/variant.lisp new-qt.gui/src/variant.lisp
--- old-qt.gui/src/variant.lisp	2014-11-25 11:01:47.000000000 +0100
+++ new-qt.gui/src/variant.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,59 +0,0 @@
-(in-package :qt)
-
-(declaim (optimize (debug 3)))
-
-(defgeneric make-variant (value)
-  (:documentation "Returns a variant for VALUE."))
-
-(defmethod print-object ((variant variant) stream)
-  "Print the type and value of the variant."
-  (if (null-pointer-p (pointer variant))
-      (call-next-method)
-      (print-unreadable-object (variant stream :type t)
-        (format stream "~A~@[ ~S~]" 
-                (cxx:type-name variant)
-                (handler-case (from-variant variant)
-                  (error () nil))))))
-
-(defmethod make-variant (value)
-  "Returns a new VARIANT containing a C++ version of VALUE."
-  (make-instance 'variant :args (list value)))
-
-;; FIXME include in MAKE-VARIANT?
-(defun make-lisp-variant (value)
-  "Returns a new VARIANT that wrapps VALUE."
-  (let ((object (make-cxx-lisp-object value)))
-    (unwind-protect
-         (make-instance 'variant :args (list *cxx-lisp-object-metatype*
-                                             object))
-      (free-cxx-lisp-object object))))
-
-(defcfun qt-smoke-lisp-object-value :pointer
-  (variant :pointer))
-
-(defun valid-p (variant)
-  "Returns true when VARIANT is valid (has a value) and false otherwise."
-  (cxx:is-valid variant))
-
-(defun from-variant (variant)
-  "Returns the value of VARIANT."
-  (ecase (cxx:user-type variant)
-    (#.(value variant.+invalid+)
-     (cerror "Return (VALUES)" "Type of variant ~A is invalid." variant)
-     (values))
-    (#.(value variant.+string+)
-     (cxx:to-string variant))
-    (#.(value variant.+string-list+)
-       (cxx:to-string-list variant))
-    (#.(value variant.+uint+)
-     (cxx:to-uint variant))
-    (#.(value variant.+int+)
-     (cxx:to-int variant))
-    (#.(value variant.+double+)
-     (cxx:to-double variant))
-    (#.*cxx-lisp-object-metatype* ;; FIXME test this!
-     (let* ((lisp-object (qt-smoke-lisp-object-value (smoke::pointer variant)))
-            (value))
-       (setf value (translate-cxx-lisp-object lisp-object))
-       (free-cxx-lisp-object lisp-object)
-       value))))
diff -rN -u old-qt.gui/test.lisp new-qt.gui/test.lisp
--- old-qt.gui/test.lisp	2014-11-25 11:01:46.000000000 +0100
+++ new-qt.gui/test.lisp	2014-11-25 11:01:47.000000000 +0100
@@ -1,25 +1,9 @@
 #|
 exec -a "$0" sbcl --noinform --noprint --disable-debugger --load $0 --end-toplevel-options "$@"
-# do not use --script to allow loading mudballs with ${HOME}/.sbclrc
 # Used for testing on darcs record.
 |#
 
-
-(in-package :sysdef-user)
-
-(defun load-sysdef (pathname system)
-  (load pathname)
-  (setf (mb.sysdef::pathname-of (find-system system)) pathname))
-
-(defun load-sysdef-file (system-name)
-  "Loads a mbd file in the current directory."
-  (load-sysdef (make-pathname :defaults *default-pathname-defaults*
-                                 :name (string-downcase system-name)
-                                 :type "mbd")
-               system-name))
-
-(load-sysdef-file :qt)
-(mb:clean :qt)
-(mb:test :qt)
+(asdf:operate 'asdf:load-op :cl-smoke.qt.gui)
+(asdf:operate 'asdf:test-op :cl-smoke.qt.gui)
 
 (sb-ext:quit)
diff -rN -u old-qt.gui/tests/test.lisp new-qt.gui/tests/test.lisp
--- old-qt.gui/tests/test.lisp	2014-11-25 11:01:46.000000000 +0100
+++ new-qt.gui/tests/test.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1 +0,0 @@
-(mb:test :qt.tests)