Sun Jan 10 09:52:49 CET 2010  Tobias Rautenkranz <tobias@rautenkranz.ch>
  * Split up in qt.gui & cleanup name prefix.
diff -rN -u old-qt.gui/CMakeLists.txt new-qt.gui/CMakeLists.txt
--- old-qt.gui/CMakeLists.txt	2014-10-30 07:41:23.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/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-10-30 07:41:23.000000000 +0100
@@ -0,0 +1,20 @@
+(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 "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-10-30 07:41:23.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-10-30 07:41:23.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.asd new-qt.gui/qt.asd
--- old-qt.gui/qt.asd	2014-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/qt.asd	1970-01-01 01:00:00.000000000 +0100
@@ -1,47 +0,0 @@
-(defpackage qt-system
-  (:use :cl :asdf))
-
-(in-package qt-system)
-
-(asdf:defsystem :qt
-  :name :qt
-  :version (0 0 1)
-  :author "Tobias Rautenkranz"
-  :license "GPL with linking exception"
-  :description "Smoke Qt bindings."
-  :depends-on (:smoke :smoke :cffi :alexandria)
-
-  :components 
-  ((:module "src"
-            :components
-            ((:file "package")
-             (:module "lib" :depends-on ("package"))
-             (:file "qt" :depends-on ("package" "lib"))
-             (:file "ownership" :depends-on ("qt"))
-             (:file "event" :depends-on ("qt"))
-             (:file "object" :depends-on ("qt" "signal-slot" "qstring" "event"))
-             (:file "operator" :depends-on ("qt" "object"))
-             (:file "application" :depends-on ("qt" "properties"))
-             (:file "qstring" :depends-on ("qt"))
-             (:file "list" :depends-on ("qt"))
-             (:file "msg-handler" :depends-on ("lib" "qt"))
-             (:file "painter" :depends-on ("qt"))
-             (:file "timer" :depends-on ("qt"))
-             (:file "i18n" :depends-on ("qt"))
-             (:file "lisp-object" :depends-on ("qt" "lib"))
-             (:module "signal-slot"
-                      :serial t
-                      :depends-on ("lisp-object")
-                      :components
-                      ((:file "signal-slot")
-                       (:file "translate" :depends-on ("signal-slot"))
-                       (:file "signal" :depends-on ("translate"))
-                       (:file "slot" :depends-on ("signal"))
-                       (:file "connect" :depends-on ("slot"))))
-             (:file "string-list" :depends-on ("qt" "lib" "qstring"))
-             (:file "variant" :depends-on ("qt" "qstring" "lisp-object"))
-             (:file "properties" :depends-on ("variant"))))))
-
-(defmethod asdf:perform ((operation test-op) (c (eql (find-system :qt))))
-  (operate 'asdf:load-op :qt.tests)
-  (operate 'asdf:test-op :qt.tests))
diff -rN -u old-qt.gui/src/CMakeLists.txt new-qt.gui/src/CMakeLists.txt
--- old-qt.gui/src/CMakeLists.txt	2014-10-30 07:41:23.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-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/application.lisp	2014-10-30 07:41:23.000000000 +0100
@@ -1,87 +1,18 @@
-(in-package :cl-smoke.qt-impl)
+(in-package :cl-smoke.qt.gui)
 
-(defvar *app*)
 (defvar *widgets* nil)
-(defvar qt:*exec-p* t
-  "Run exec if true and not otherwise.")
 
-(defun qt:app ()
-  "Returns the APPLICATION (or CORE-APPLICATION) object,
-within a WITH-APP."
-  (assert (qt:app-p)
-          (*app*)
-          "No application.")
-  *app*)
-
-(defun qt:app-p ()
-  "Returns t when the APPLICATION object exists and nil otherwise."
-  (boundp '*app*))
-
-(defun ensure-app (&optional 
-                   (application 'qt:application)
-                   (args #+sbcl sb-ext:*posix-argv*
-                         #+ccl  ccl:*command-line-argument-list*
-                         #-(or sbcl ccl) (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 (qt:app-p)
-      (progn
-        (assert (typep (qt:app) (find-class application))
-                (application)
-                "The existing application object ~A is
-not of type ~A." (qt:app) (find-class application))
-        (values (qt:app) nil))
-      (progn
-        (when (not (null-pointer-p (smoke::pointer
-                                    (qt:core-application.instance))))
-          (cerror (format nil "Delete the active application ~A."
-                          (qt:core-application.instance))
-                  "Active application not created by QT:WITH-APP.")
-          (smoke::delete-pointer (smoke::pointer (qt:core-application.instance))
-                                 (find-class 'qt:core-application)))
-        (let* ((argc (smoke:make-auto-pointer
-                      (foreign-alloc :int :initial-element (length args))))
-               (argv (smoke:make-auto-pointer
-                      (foreign-alloc :string :initial-contents args)))
-               (app (make-instance 'qt:application :args (list argc argv))))
-          ;; argc and argv must remain valid during the lifetime of APP.
-          (setf (qt:property app 'cmdline-args) 
-                (qt:make-lisp-variant (list argc argv)))
-          (tg:cancel-finalization app)
-          (values app t)))))
-
-(defun kill-app ()
-  (when (typep (qt:app) '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)))
-  (cxx:quit (qt:app))
-  (setf *widgets* nil)
-  ;; Call the destructor; -> destructed callback is called,
-  ;; (~QApplication() is virtual) which takes care of cleanup on the
-  ;; Lisp side.
-  (smoke::delete-pointer (smoke:pointer (qt:app)) (class-of (qt:app)))
-  (setf (slot-value (qt:app) 'pointer) (null-pointer))
-  (makunbound '*app*))
-
-(defmacro with-application ((ensure-app remove-app) &body body)
-  (let ((cleanup-p (gensym)))
-    `(multiple-value-bind (*app* ,cleanup-p) ,ensure-app
-       (unwind-protect
-            (progn ,@body)
-         (when ,cleanup-p
-           ,remove-app)))))
+(defmethod 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))
+  (call-next-method)
+  (setf *widgets* nil))
 
 (defmacro qt:with-app (options &body body)
   "Ensures that a APPLICATION instance exists, 
@@ -96,16 +27,10 @@
   (assert (null options)
           (options)
           "Currently no options can be passed to QT:WITH-APP.")
-  `(with-application ((cl-smoke.qt-impl::ensure-app 'qt:application) (kill-app))
+  `(cl-smoke.qt.core::with-application ((cl-smoke.qt.core::ensure-app 'qt:application)
+                                        (cl-smoke.qt.core::kill-app))
      ,@body))
 
-(defmacro qt:with-core-app (options &body body)
-  (assert (null options)
-          (options)
-          "Currently no options can be passed to QT:WITH-CORE-APP.")
-  `(with-application ((cl-smoke.qt-impl::ensure-app 'qt:core-application) (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
diff -rN -u old-qt.gui/src/event.lisp new-qt.gui/src/event.lisp
--- old-qt.gui/src/event.lisp	2014-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/event.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,10 +0,0 @@
-(in-package :cl-smoke.qt-impl)
-
-(defun cast-event (event)
-  (enum-case (cxx:type event)
-    ((qt:event.+child-added+ qt:event.+child-removed+
-                             qt:event.+child-polished+)
-     (setf (slot-value event 'smoke::pointer)
-           (smoke::upcast event (find-class 'qt:child-event)))
-     (change-class event 'qt:child-event)))
-  event)
diff -rN -u old-qt.gui/src/i18n.lisp new-qt.gui/src/i18n.lisp
--- old-qt.gui/src/i18n.lisp	2014-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/i18n.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,57 +0,0 @@
-(in-package :cl-smoke.qt-impl)
-
-(defun qt: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 qt:with-translator ((base-name &rest paths) &body body)
-  "Loads the translations in the BASE-NAME_LANGCODE.qm file;
-searching PATHS.
-
-Must be in a WITH-APP."
-  (let ((translator (gensym)))
-    `(let ((,translator (make-instance 'qt:translator)))
-       (unless 
-           (find-if #'(lambda (path)
-                        (cxx:load ,translator
-                                  (format nil "~A_~A" ,base-name
-                                          (cxx:name (qt:locale.system)))
-                                  (namestring path)))
-                    (list ,@paths))
-         (cerror "Ignore" "Loading the translations ~A for ~A failed."
-                 ,base-name (cxx:name (qt:locale.system))))
-       (with-installed-translator ,translator
-         ,@body))))
-
-(defmacro qt: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 'qt: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))))
-
-(defun qt:search-file (name &rest paths)
-  "Searches the file NAME in PATHS and returns its path."
-  (let ((file-path (find-if #'(lambda (path)
-                                (probe-file (merge-pathnames name path)))
-                            paths)))
-    (unless file-path
-      (error "The file ~S not found in the paths ~S" name paths))
-    (merge-pathnames name file-path)))
-
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-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/lib/CMakeLists.txt	1970-01-01 01:00:00.000000000 +0100
@@ -1,20 +0,0 @@
-find_package(Qt4)
-set(QT_DONT_USE_QTGUI true)
-include(${QT_USE_FILE})
-
-include(CheckCXXCompilerFlag)
-check_cxx_compiler_flag("-fvisibility=hidden" CXX_VISIBILITY)
-if(CXX_VISIBILITY)
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden -fvisibility-inlines-hidden")
-endif(CXX_VISIBILITY)
-
-set(QT_SMOKE_SOURCES qt-smoke.cpp qstring.cpp qstringlist.cpp lisp-object.cpp qlist.cpp)
-add_library(qt-smoke-extra MODULE ${QT_SMOKE_SOURCES})
-target_link_libraries(qt-smoke-extra ${QT_LIBRARIES})
-set_target_properties(qt-smoke-extra 
-	PROPERTIES
-	SOVERSION "0.0"
-	VERSION "0.0.1")
-
-install(TARGETS qt-smoke-extra
-	LIBRARY DESTINATION lib)
diff -rN -u old-qt.gui/src/lib/cl_smoke_qt.h new-qt.gui/src/lib/cl_smoke_qt.h
--- old-qt.gui/src/lib/cl_smoke_qt.h	2014-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/lib/cl_smoke_qt.h	1970-01-01 01:00:00.000000000 +0100
@@ -1,14 +0,0 @@
-#ifndef CL_SMOKE_QT_H
-#define CL_SMOKE_QT_H
-
-#if defined _WIN32 || defined __CYGWIN__
-  #define CL_SMOKE_QT_EXPORT __declspec(dllexport)
-#else
-  #if __GNUC__ >= 4
-    #define CL_SMOKE_QT_EXPORT __attribute__((visibility("default")))
-  #else
-    #define CL_SMOKE_QT_EXPORT
-  #endif
-#endif
-
-#endif // CL_SMOKE_QT_H
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-10-30 07:41:23.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(unsigned 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(unsigned 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(unsigned 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
- */
-unsigned 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_is_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(unsigned 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-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/lib/lisp-object.h	1970-01-01 01:00:00.000000000 +0100
@@ -1,83 +0,0 @@
-#ifndef LISP_OBJECT_H
-#define LISP_OBJECT_H
-
-#include <QMetaType>
-#include <QSharedData>
-#include <QExplicitlySharedDataPointer>
-#include <smoke.h>
-
-#include "cl_smoke_qt.h"
-
-extern "C"
-{
-	CL_SMOKE_QT_EXPORT int
-	qt_smoke_setup_lisp_object(void* destruct);
-
-	CL_SMOKE_QT_EXPORT unsigned int
-	qt_smoke_lisp_object_id(const void* object);
-
-	CL_SMOKE_QT_EXPORT int
-	qt_smoke_lisp_object_is_set(const void* object);
-
-	CL_SMOKE_QT_EXPORT void*
-	qt_smoke_make_lisp_object(unsigned int id);
-
-	CL_SMOKE_QT_EXPORT void*
-	qt_smoke_free_lisp_object(void* object);
-
-	CL_SMOKE_QT_EXPORT void*
-	qt_smoke_lisp_object_value(const void* variant);
-}
-
-namespace cl_smoke {
-namespace qt {
-
-class lisp_object
-{
-	public:
-		typedef void (*destructor)(unsigned int id);
-
-		lisp_object();
-
-		lisp_object(unsigned int id);
-
-		lisp_object(const lisp_object& other);
-
-		inline unsigned int
-		id() const
-		{ Q_ASSERT(this->set()); return d->id; }
-
-		void
-		set_id(unsigned 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(unsigned int id);
-			~data();
-			unsigned 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/qlist.cpp new-qt.gui/src/lib/qlist.cpp
--- old-qt.gui/src/lib/qlist.cpp	2014-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/lib/qlist.cpp	1970-01-01 01:00:00.000000000 +0100
@@ -1,16 +0,0 @@
-#include "qlist.h"
-
-/** @file
- * @brief QList conversions. */
-
-#include <QVariant>
-#include <QByteArray>
-
-extern "C" {
-
-DEFINE_QLIST_WRAPPER(QVariant)
-DEFINE_QLIST_WRAPPER_PTR(void)
-DEFINE_QLIST_WRAPPER(QByteArray)
-
-
-} // extern "C"
diff -rN -u old-qt.gui/src/lib/qlist.h new-qt.gui/src/lib/qlist.h
--- old-qt.gui/src/lib/qlist.h	2014-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/lib/qlist.h	1970-01-01 01:00:00.000000000 +0100
@@ -1,89 +0,0 @@
-#ifndef CL_SMOKE_QT_QLIST_H
-#define CL_SMOKE_QT_QLIST_H
-
-#include <QList>
-#include "cl_smoke_qt.h"
-
-/** @file
- */
-
-/** Defines a C wrapper for the QList<@a TYPE>.
- * @param TYPE the type of the elements of the QList
- */
-#define DEFINE_QLIST_WRAPPER(TYPE) \
-	DEFINE_QLIST_WRAPPER_3(TYPE, TYPE, VALUE)
-
-/** Defines a C wrapper for the QList<@a TYPE*>,
- * where @a TYPE is the of the pointer.
- *
- * @param NAME the name used for the wrapper functions.
- * @param TYPE the type of the elements
- */
-#define DEFINE_QLIST_WRAPPER_PTR(TYPE) \
-	DEFINE_QLIST_WRAPPER_3(TYPE, TYPE*, PTR)
-
-/** @internal */
-#define DEFINE_QLIST_WRAPPER_3(NAME, TYPE, PTR_VALUE) \
-	DEFINE_QLIST_WRAPPER_ALL_PART(NAME, TYPE) \
-	DEFINE_QLIST_WRAPPER_ ## PTR_VALUE ## _PART(NAME, TYPE) \
-	
-
-/** @internal
- * size, free and make_list. */
-#define DEFINE_QLIST_WRAPPER_ALL_PART(NAME, TYPE) \
-CL_SMOKE_QT_EXPORT int \
-qt_smoke_list_ ## NAME ## _size(const void* list) \
-{ \
-	return static_cast<const QList< TYPE >*>(list)->size(); \
-} \
-\
-CL_SMOKE_QT_EXPORT void \
-qt_smoke_free_list_ ## NAME (void* list) \
-{ \
-	delete static_cast<QList< TYPE >*>(list); \
-} \
- \
-CL_SMOKE_QT_EXPORT void* \
-qt_smoke_make_list_ ## NAME () \
-{ \
-	return new QList< TYPE >(); \
-} \
- \
-
-/** @internal
- * At and append for pointer types
- */
-#define DEFINE_QLIST_WRAPPER_PTR_PART(NAME, TYPE) \
-CL_SMOKE_QT_EXPORT const void* \
-qt_smoke_list_ ## NAME ## _at(const void* list, int index) \
-{ \
-	const QList< TYPE >* qlist = static_cast<const QList< TYPE > *>(list); \
-	return qlist->at(index); \
-} \
-\
-CL_SMOKE_QT_EXPORT void \
-qt_smoke_list_ ## NAME ## _append(void* list, void* data) \
-{ \
-	static_cast<QList< TYPE >*>(list) \
-		->append(static_cast<TYPE>(data)); \
-} \
-
-/** @internal
- * At and append for value types.
- */
-#define DEFINE_QLIST_WRAPPER_VALUE_PART(NAME, TYPE) \
-CL_SMOKE_QT_EXPORT const void* \
-qt_smoke_list_ ## NAME ## _at(const void* list, int index) \
-{ \
-	const QList< TYPE >* qlist = static_cast<const QList< TYPE > *>(list); \
-	return new TYPE(qlist->at(index)); \
-} \
-\
-CL_SMOKE_QT_EXPORT void \
-qt_smoke_list_ ## NAME ## _append(void* list, void* data) \
-{ \
-	static_cast<QList< TYPE >*>(list) \
-		->append(*static_cast<TYPE*>(data)); \
-} \
-
-#endif // CL_SMOKE_QT_QLIST_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-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/lib/qstring.cpp	1970-01-01 01:00:00.000000000 +0100
@@ -1,46 +0,0 @@
-#include <QString>
-#include <QtDebug>
-
-#include "cl_smoke_qt.h"
-
-/** @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. 
- */
-CL_SMOKE_QT_EXPORT 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
- */
-CL_SMOKE_QT_EXPORT 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
- */
-CL_SMOKE_QT_EXPORT 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-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/lib/qstringlist.cpp	1970-01-01 01:00:00.000000000 +0100
@@ -1,71 +0,0 @@
-#include <QStringList>
-#include <QtDebug>
-#include <cstring>
-
-#include "cl_smoke_qt.h"
-
-/** @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
- */
-CL_SMOKE_QT_EXPORT 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
- */
-CL_SMOKE_QT_EXPORT 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
- */
-CL_SMOKE_QT_EXPORT void
-qt_smoke_free_string_list(void* string_list)
-{
-	delete static_cast<QStringList*>(string_list);
-}
-
-/** Allocates a new QStringList.
- *
- * @return a new QStringList
- */
-CL_SMOKE_QT_EXPORT 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
- */
-CL_SMOKE_QT_EXPORT 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-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/lib/qt-smoke.cpp	1970-01-01 01:00:00.000000000 +0100
@@ -1,53 +0,0 @@
-#include <qnamespace.h>
-#include <QEvent>
-#include <QtDebug>
-
-#include "cl_smoke_qt.h"
-
-/** @file
- * @brief Qt support functions */
-
-#include <exception>
-
-static void
-terminate()
-{
-	qFatal("caught an exception.");
-}
-
-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 otherwise
- */
-CL_SMOKE_QT_EXPORT int
-qt_smoke_register_event_notify(void* callback)
-{
-	Q_ASSERT(callback);
-	std::set_terminate(terminate);
-
-	return QInternal::registerCallback(QInternal::EventNotifyCallback,
-			reinterpret_cast<qInternalCallback>(callback));
-}
-
-/** Returns the most specific QMetaObject of the QObject instance @a object.
- * Used to determine the actual class of an object. Smoke can not be used since it calls the
- * metaObject() of the class the method was called for.
- *
- * @param object A QObject
- *
- * @return QMetaObject
- */
-CL_SMOKE_QT_EXPORT void*
-qt_smoke_meta_object(void* object)
-{
-	Q_ASSERT(object);
-	static_cast<QObject*>(object)->metaObject();	
-}
-
-
-} // 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-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/lisp-object.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,67 +0,0 @@
-(in-package :cl-smoke.qt-impl)
-
-(defvar *cxx-lisp-objects* (smoke::make-synchronized-hash-table)
-  "Objects that are currently passed in a C++ class.")
-
-(let ((id 0))
-  (declare (type (smoke::c-integer :unsigned-int) id))
-  (defun gen-cxx-lisp-object-id ()
-    "Returns a new unique ID."
-    (loop do
-         (setf id
-               (logand (1- (expt 2 (* 8 (foreign-type-size :unsigned-int) )))
-                       (1+ id)))
-       while (nth-value 1 (gethash id *cxx-lisp-objects*)))
-    id))
-    
-(defcfun qt-smoke-setup-lisp-object :int
-  (destruct :pointer))
-
-(defcfun qt-smoke-lisp-object-id :unsigned-int
-  (object :pointer))
-
-(defcfun qt-smoke-lisp-object-is-set :int
-  (object :pointer))
-
-(defcfun qt-smoke-make-lisp-object :pointer
-  (id :unsigned-int))
-
-(defcfun qt-smoke-free-lisp-object :void
-  (object :pointer))
-
-(defcallback destruct-cxx-lisp-object :void
-    ((id :unsigned-int))
-  (remhash id *cxx-lisp-objects*))
-
-(defvar *cxx-lisp-object-metatype* "Metatype ID of the C++ lisp_object.")
-
-(eval-startup ()
-  (setf *cxx-lisp-object-metatype*
-        (qt-smoke-setup-lisp-object (callback destruct-cxx-lisp-object)))
-  (assert (>= *cxx-lisp-object-metatype*
-              (smoke::value qt: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 being 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/list.lisp new-qt.gui/src/list.lisp
--- old-qt.gui/src/list.lisp	2014-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/list.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,72 +0,0 @@
-(in-package :cl-smoke.qt-impl)
-
-(defmacro define-qlist-wrapper (type-name element-type &optional c-name)
-  (let* ((c-name (or c-name type-name))
-         (type (string-upcase c-name))
-         (list-type (symbolicate 'qlist- type)))
-    `(progn
-       (defcfun ,(concatenate 'string "qt_smoke_list_" c-name "_size") :int
-         "Returns the size of LIST."
-         (list :pointer))
-       (defcfun ,(concatenate 'string "qt_smoke_free_list_" c-name) :void
-         "Frees LIST."
-         (list :pointer))
-       (defcfun ,(concatenate 'string "qt_smoke_make_list_" c-name) :pointer
-         "Makes a list.")
-       (defcfun ,(concatenate 'string "qt_smoke_list_" c-name "_at") :pointer
-         "Returns the a newly constructed copy of the element at position AT of LIST."
-         (list :pointer)
-         (index :int))
-       (defcfun ,(concatenate 'string "qt_smoke_list_" c-name "_append") :pointer
-         "Appends NEW-ELEMENT to LIST."
-         (list :pointer)
-         (new-element :pointer))
-       ;; To Lisp
-       ,@(loop for type-name in (ensure-list type-name) collect
-              `(defun ,(symbolicate 'from- type-name) (list-pointer)
-                 (let ((vector (make-array (,(symbolicate 'qt-smoke-list-
-                                                          type '-size)
-                                             list-pointer))))
-                   (dotimes (index (length vector) vector)
-                     (setf (aref vector index)
-                           ;; FIXME the returned object is not wrapped by Smoke
-                           ;; -> change this? 
-                           (smoke::object-to-lisp
-                            (,(symbolicate 'qt-smoke-list-
-                                           type '-at)
-                              list-pointer index)
-                            (smoke::make-smoke-type *smoke-module*
-                                                    ,type-name)))))))
-       ,@(loop for type-name in (ensure-list type-name) collect
-              `(define-to-lisp-translation
-                   (,(format nil "const QList<~A>&" type-name)
-                     ,(format nil "QList<~A>" type-name))
-                   ,(symbolicate 'from- type-name)
-                 ,(symbolicate 'qt-smoke-free-list- type)))
-       ;; From Lisp
-       (defun ,(symbolicate 'coerce- list-type) (list)
-         (let ((qlist (,(symbolicate 'qt-smoke-make-list- type))))
-           (loop for element across list do
-                (,(symbolicate 'qt-smoke-list- type '-append)
-                  qlist (pointer (make-instance ',element-type :args (list element)))))
-           (make-cleanup-pointer
-            qlist
-            (function ,(symbolicate 'qt-smoke-free-list- type)))))
-       (defun ,(symbolicate list-type '-p) (list)
-         (every #'(lambda (element)
-                    (typep element ',element-type))
-                list))
-       ,@(loop for type-name in (ensure-list type-name) collect
-              `(define-from-lisp-translation (,(format nil "const QList<~A>&" type-name)
-                                               ,(format nil "QList<~A>" type-name))
-                   ;; FIXME allow sequence
-                   (and (vector ,element-type)
-                        (satisfies ,(symbolicate list-type '-p)))
-                 ,(symbolicate 'coerce- list-type))))))
-
-;; FIXME it would be nice to have QList<QVariant> as fallback for any
-;; list we can not convert otherwise. e.g.: '("a" 1)
-(define-qlist-wrapper "QVariant" qt:variant)
-
-(define-qlist-wrapper ("QObject*" "QWidget*") qt:object "void")
-(define-qlist-wrapper "QByteArray" qt:byte-array)
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-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/msg-handler.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,24 +0,0 @@
-(in-package :cl-smoke.qt-impl)
-
-;; FIXME Determine the actual size of the QtMsgType enum.
-(cffi:defctype qt-msg-type :int)
-
-;; QtMsgHandler is a typedef for a pointer.
-(define-pointer-typedef "QtMsgHandler" foreign-pointer)
-
-(define-pointer-typedef "void(*)(QtMsgType,const char*)" foreign-pointer)
-(define-pointer-typedef "unsigned char*" foreign-pointer)
-
-(defcallback qt-msg-handler :void
-    ((type qt-msg-type)
-     (message :string))
-  (ecase type
-    (#.(value qt:+qt-debug-msg+)
-       (write-string "qDebug: " *debug-io*)
-       (write-line message *debug-io*))
-    (#.(value qt:+qt-warning-msg+) (warn message))
-    (#.(value qt:+qt-critical-msg+) (cerror "Ignore" "~A" message))
-    (#.(value qt:+qt-fatal-msg+) (error message))))
-
-(eval-startup (:load-toplevel)
-  (qt:q-install-msg-handler (callback qt-msg-handler)))
diff -rN -u old-qt.gui/src/object.lisp new-qt.gui/src/object.lisp
--- old-qt.gui/src/object.lisp	2014-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/object.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,247 +0,0 @@
-(in-package :cl-smoke.qt-impl)
-
-;; Smoke always calls the method of the class the object is assumed to
-;; be and not the most specific method like required for virtual
-;; methods. Thus we implement a virtual metaObject() method to
-;; determine the actual class. This is only needed for objects not
-;; constructed by Smoke, since otherwise we would know the most
-;; specific class.
-(defcfun qt-smoke-meta-object :pointer (object :pointer))
-(defun meta-object (object)
-  (make-instance 'qt:meta-object
-                 :pointer (qt-smoke-meta-object (pointer object))))
-
-(defmethod cxx:static-meta-object ((class cxx:class))
-  (cxx:static-meta-object (smoke::find-smoke-class class)))
-
-(defmethod documentation :around ((class smoke::smoke-standard-class)
-                                  (doc-type (eql 't)))
-  (if (and (subtypep class (find-class 'qt:object))
-           (not (subtypep class (find-class 'cxx:class))))
-      (format nil "~@[~A~%~]Properties:~%~T~{~<~%~T~0,75:; ~(~A~)~>~}
-
-Signals:
-~{~T~A~%~}
-Slots:
-~{~T~A~%~}"
-              (call-next-method) (sort (qt:class-direct-properties class) #'string<=)
-              (sort (class-signals class) #'string<=)
-              (sort (class-slots class) #'string<=))
-      (call-next-method)))
-
-(defmethod print-object ((object qt:object) stream)
-  (if (or (not (slot-boundp object 'pointer))
-          (null-pointer-p (pointer object)))
-      (call-next-method)
-      (if (string= "" (cxx:object-name object))
-          (print-unreadable-object (object stream :type t :identity t)
-            (when (smoke::const-p object)
-              (princ "CONST " stream)))
-          (print-unreadable-object (object stream :type t :identity t)
-            (when (smoke::const-p object)
-              (princ "CONST " stream))
-            (princ (cxx:object-name object) stream)))))
-
-(defmethod print-object ((object qt:meta-object) stream)
-  (if (or (not (slot-boundp object 'pointer))
-          (null-pointer-p (pointer object)))
-      (call-next-method)
-          (print-unreadable-object (object stream :type t :identity t)
-            (princ (cxx:class-name object) stream))))
-
-(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 &key all)
-  (mapcar #'cxx:signature
-          (remove-if-not #'(lambda (m) (enum= qt:meta-method.+signal+
-                                                  (cxx:method-type m)))
-                         (meta-object-methods meta-object (not all)))))
-
-(defun class-signals (class &key all)
-  (meta-object-signals (cxx:static-meta-object class) :all all))
-
-(defun meta-object-slots (meta-object &key all)
-  (mapcar #'cxx:signature
-          (remove-if-not #'(lambda (m) (enum= qt:meta-method.+slot+
-                                                  (cxx:method-type m)))
-                         (meta-object-methods meta-object (not all)))))
-
-
-(defun class-slots (class &key all)
-  (meta-object-slots (cxx:static-meta-object class) :all all))
-
-(defun parent-p (object)
-  (not (null-pointer-p (smoke::pointer-call
-                        (smoke::make-smoke-method-from-name 
-                         (find-class 'qt:object)
-                         "parent")
-                        (smoke::pointer object)))))
-
-
-;; FIXME this might not be that smart.
-(eval-startup (:compile-toplevel :execute)
-  (defparameter *destroyed-slot* (qt:make-slot
-                                  #'(lambda (object)
-                                      (foreign-funcall-pointer
-                                       (get-callback 'smoke::destructed)
-                                       () :pointer (smoke:pointer object))))))
-
-(defvar *toplevel-objects* nil)
-
-(defun ensure-smoke-parent (object)
-  (declare (optimize (speed 3)))
-  (let ((parent (cxx:parent object)))
-    (assert (not (null-pointer-p (smoke:pointer parent)))
-            ()
-            "The object ~A has not parent." object)
-    (unless (smoke::has-pointer-p (smoke:pointer parent))
-      ;; Before we ADD-OBJECT PARENT it must know its real class to
-      ;; prevent a clash when the same pointer is returned by a
-      ;; function with a more specific type.
-      (change-class parent 
-                    ;; Note: there can be classes that are not known
-                    ;; to Smoke, like KDE's OxygenStyle that might
-                    ;; be seen by the event-notify callback.  But
-                    ;; it's probably save to assume the user will
-                    ;; never use those.
-                    (let ((class-name (cxx:class-name (meta-object parent))))
-                      (smoke::lispify class-name (ecase (char class-name 0)
-                                                   (#\Q :qt)
-                                                   (#\K :kde)))))
-      (smoke::add-object parent)
-      (qt:connect (qt:get-signal parent "destroyed(QObject*)")
-                  *destroyed-slot* qt:+direct-connection+)
-      (tg:cancel-finalization parent)
-      (if (null-pointer-p (smoke:pointer (cxx:parent parent)))
-          (push parent *toplevel-objects*)
-      (smoke::transfer-ownership-to parent (ensure-smoke-parent parent))))
-    parent))
-
-(defmethod initialize-instance :after ((object qt:object)
-                                       &key (pointer nil pointer-p) &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."
-  (declare (optimize (speed 3)))
-  (when (and (not pointer-p)
-             (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)))
-             (parent-p object))
-    (smoke::transfer-ownership-to object
-                                  (ensure-smoke-parent object))))
-
-(define-condition wrapper-gc (storage-condition)
-  ((object-class :initarg :object-class
-                 :documentation "The class of the gc'ed object.")
-   (pointer :initarg :pointer))
-  (:report (lambda (condition stream)
-               (format stream "The object ~A ~A of type cxx:class
-has the parent  but got garbage collected."
-                       (slot-value condition 'object-class)
-                       (slot-value condition 'pointer)))))
-
-(eval-startup (:compile-toplevel :execute)
-  (defparameter *get-parent*
-    (smoke::make-smoke-method-from-name (find-class 'qt:object) "parent"))
-
-  ;; FIXME this leaks memory when QCoreApplication::exec() is never
-  ;; called, beause then, deleteLater() has no effect.
-  (defparameter *delete-later*
-    (smoke::make-smoke-method-from-name (find-class 'qt:object) "deleteLater")))
-
-(defmethod smoke::make-finalize ((object qt:object))
-  "Delete the qt:object OBJECT,
- by calling cxx:delete-later iff it has no parent."
-  (let ((pointer (pointer object))
-        (class (class-of object))
-        (next (call-next-method)))
-    (declare (function next))
-    (if (typep (class-of object) 'cxx:class)
-        #'(lambda ()
-            (declare (optimize (speed 3)))
-            (handler-case 
-                (if (null-pointer-p (smoke::pointer-call *get-parent* pointer))
-                    (smoke::pointer-call *delete-later* pointer)
-                    (error (make-condition 'wrapper-gc
-                                           :object-class class
-                                           :pointer pointer)))
-              (error (condition)
-                (smoke::report-finalize-error condition "qt:object wrap"
-                                              (name class) pointer))))
-        #'(lambda ()
-           (declare (optimize (speed 3)))
-            (handler-case 
-                (if (null-pointer-p (smoke::pointer-call *get-parent* pointer))
-                    (funcall next)
-                    (cerror "Ignore" "Finalizer for object with a parent called."))
-              (error (condition)
-                (smoke::report-finalize-error condition "qt:object"
-                                              (name class) pointer)))))))
-
-
-;;;
-;;; 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 ((receiver (smoke::get-object (cffi:mem-aref data :pointer 0)))
-        (event (cast-event
-                (make-instance 'qt:event
-                               :pointer (cffi:mem-aref data :pointer 1)))))
-    (enum-case (cxx:type event)
-      (qt:event.+child-added+
-       (tg:cancel-finalization (cxx:child event))
-       (when (smoke::has-pointer-p (smoke::pointer (cxx:child event)))
-         (unless receiver
-           (setf receiver (ensure-smoke-parent (cxx:child event))))
-         (smoke::transfer-ownership-to (cxx:child event) receiver)))
-      (qt:event.+child-removed+
-       ;; We receive child removed events for any QObject, whether
-       ;; it was constructed by Smoke or not. Only take ownership of
-       ;; objects that have been constructed by Smoke.
-       (when (smoke::has-pointer-p (smoke::pointer (cxx:child event)))
-         (assert receiver)
-         (smoke::take-ownership (cxx:child event) receiver)))))
-  nil)
-    
-(eval-when (:compile-toplevel :load-toplevel :execute)
-  (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 "Registering event-notify callback failed."))))
-
-(defun check-child-parent-ownership ()
-  (loop for parent being the hash-values of smoke::*object-map* do
-       (loop for child in (smoke::owned-objects parent) do
-            (when (typep child 'qt:object)
-              (assert (eql (cxx:parent child) parent)
-                      (child parent)
-                      "cl-smoke thinks ~A has the parent ~A, but ~A is its parent."
-                      child parent (cxx:parent child))))))
-
-(eval-startup ()
- (register-event-notify))
diff -rN -u old-qt.gui/src/operator.lisp new-qt.gui/src/operator.lisp
--- old-qt.gui/src/operator.lisp	2014-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/operator.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,96 +0,0 @@
-(in-package :cl-smoke.qt-impl)
-(declaim (optimize (debug 3)))
-
-(defun cxx:= (object &rest more-objects)
-  (if (null more-objects)
-      t
-      (every #'(lambda (o)
-                 ;; Consider Class::operator== and operator==
-                 ;; FIXME integrate this in the overload resolution
-                 (if (typep object 'smoke::smoke-standard-object)
-                     (handler-case (qt:operator== object o)
-                       (smoke::no-applicable-cxx-method ()
-                         (cxx:operator== object o)))
-                     (qt:operator== object o)))
-             more-objects)))
-
-(defun cxx:/= (object &rest more-objects)
-  (if (null more-objects)
-      t
-      (some #'(lambda (o)
-                (qt:operator!= object o))
-            more-objects)))
-      
-(defun ordered-p (relation list)
-  "Returns true when LIST is ordered according to RELATION."
-  (if (or (null list) (null (rest list)))
-      t
-      (and (funcall relation (first list)
-                    (second list))
-           (ordered-p relation (rest list)))))
-
-(defmacro define-cxx-relation (relation)
-  `(defun ,(intern (symbol-name relation) :cxx) (object &rest more-objects)
-     (ordered-p (symbol-function (quote ,(intern (format nil "OPERATOR~A"
-                                                         relation)
-                                                 :qt)))
-                (cons object more-objects))))
-  
-(defmacro define-cxx-relations (&rest relations)
-  `(progn
-     ,@(mapcar #'(lambda (r) `(define-cxx-relation ,r)) relations)))
-
-(define-cxx-relations < <= >= >)
-
-
-(defun cxx:incf (object &optional (delta 1))
-  (cxx:operator+= object delta))
-
-(defun cxx:decf (object &optional (delta 1))
-  (cxx:operator-= object delta))
-
-(defun cxx:+ (&rest args)
-  (if (null args)
-      0
-      (reduce #'qt:operator+ args)))
-
-(defun cxx:- (object &rest subtrahends)
-  (if (null subtrahends)
-      (cxx:operator- object)
-      (reduce #'qt:operator- (cons object subtrahends))))
-
-(defun cxx:* (&rest args)
-  (if (null args)
-      1
-      (reduce #'qt:operator- args)))
-
-(defun cxx:/ (object &rest denominators)
-  (if (null denominators)
-      (qt:operator/ 1 object)
-      (qt:operator/ object (apply #'cxx:+ denominators))))
-
-(defun cxx:1+ (object)
-  (qt:operator+ object 1))
-
-(defun cxx:1- (object)
-  (qt:operator- object 1))
-
-(defun cxx:aref (object index)
-  "Returns the element of OBJECT at position INDEX."
-  (declare ((integer 0) index))
-  (assert (< index (cxx:size object))
-          (index)
-          "Index ~A for ~A requested, but the length is ~A"
-          index object (cxx:size object))
-  (cxx:at object index))
-
-
-(defun (setf cxx:aref) (new-value object index)
-  (declare ((integer 0) index))
-  (assert (< index (cxx:size object))
-          (index)
-          "Index ~A for ~A requested, but the length is ~A"
-          index object (cxx:size object))
-  (cxx:operator= (cxx:operator[] object index)
-                 new-value)
-  new-value)
diff -rN -u old-qt.gui/src/ownership.lisp new-qt.gui/src/ownership.lisp
--- old-qt.gui/src/ownership.lisp	2014-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/ownership.lisp	2014-10-30 07:41:23.000000000 +0100
@@ -1,4 +1,4 @@
-(in-package :cl-smoke.qt-impl)
+(in-package :cl-smoke.qt.gui)
 
 ;; undo-stack
 (define-takes-ownership cxx:push ((undo-stack qt:undo-stack) undo-command)
diff -rN -u old-qt.gui/src/package.lisp new-qt.gui/src/package.lisp
--- old-qt.gui/src/package.lisp	2014-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/package.lisp	2014-10-30 07:41:23.000000000 +0100
@@ -1,52 +1,2 @@
-(defpackage :cl-smoke.qt-impl
+(defpackage :cl-smoke.qt.gui
   (:use :cl :smoke :cffi :bordeaux-threads :cxx-support :alexandria))
-
-(defpackage :cl-smoke.qt
-  (:use) ;; do not use :cl to prevent collision with TIME and CHAR
-  (:nicknames :qt)
-  (:export #:app
-           #:app-p
-           #:exec
-           #:*exec-p*
-           #:with-app
-           #:with-core-app
-
-           #:with-painter
-           #:single-shot
-           #:do-delayed-initialize
-           
-           #:tr
-           #:with-translator
-           #:with-libqt-translator 
-
-           #:qmethod
-           #:qsignal
-           #:qslot
-
-           #:property
-           #:property-p
-           #:remove-property
-           #:properties
-           #:class-properties
-           #:class-direct-properties
-
-           #:make-char
-           #:from-char
-           
-           #:from-variant
-           #:make-variant
-           #:make-lisp-variant
-           #:value
-           #:variant-boundp
-
-           #:search-file
-
-           #:connect
-           #:disconnect
-           #:disconnect-all
-           #:get-slot
-           #:get-signal
-           #:make-slot
-           #:make-signal
-           #:sender))
-
diff -rN -u old-qt.gui/src/painter.lisp new-qt.gui/src/painter.lisp
--- old-qt.gui/src/painter.lisp	2014-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/painter.lisp	2014-10-30 07:41:23.000000000 +0100
@@ -1,4 +1,4 @@
-(in-package :cl-smoke.qt-impl)
+(in-package :cl-smoke.qt.gui)
 
 (defmacro qt:with-painter ((painter paint-device) &body body)
   "Binds a PAINTER instance for PAINT-DEVICE to PAINTER
diff -rN -u old-qt.gui/src/properties.lisp new-qt.gui/src/properties.lisp
--- old-qt.gui/src/properties.lisp	2014-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/properties.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,97 +0,0 @@
-(in-package :cl-smoke.qt-impl)
-
-(defun reverse-lispify (symbol)
-  "Converts the name of symbol to C++ style."
-  (if (eq (symbol-package symbol)
-          (find-package :keyword))
-      (smoke::lisp-to-cxx (symbol-name symbol))
-      (concatenate 'string
-                   (package-name (symbol-package symbol))
-                   "::"
-                   (symbol-name symbol))))
-
-(defun property-package (name)
-  (let ((package-end (search "::" name)))
-    (if package-end
-        (values 
-         (find-package (intern (subseq name 0 package-end) :keyword))
-         (+ 2 package-end))
-        (values (find-package :keyword) 0))))
-
-(defun lispify-property-name (name)
-  (multiple-value-bind (package name-start)
-      (property-package name)
-    (if (= 0 name-start)
-        (smoke::lispify name package)
-        (intern (subseq name name-start) package))))
-
-(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 qt:property (object name)
-  "Returns the property NAME of OBJECT."
-  (declare (type qt:object object)
-           (type (or string symbol) name))
-  (assert (qt:property-p object name)
-          (object name)
-          "~A has no property ~A." object name)
-  (qt:from-variant (cxx:property object (property-name name))))
-
-(defun (setf qt:property) (new-value object name)
-  (declare (type qt:object object)
-           (type (or string symbol) name))
-  (cxx:set-property object (property-name name)
-                    (make-instance 'qt:variant :arg0 new-value))
-  new-value)
-
-(defun qt:remove-property (object name)
-  "Removes the property NAME from OBJECT."
-  (declare (type qt:object object)
-           (type (or string symbol) name))
-  (setf (qt:property object name) (qt:make-variant)))
-
-(defun qt:property-p (object name)
-  "Returns T when NAME is a property of OBJECT and NIL otherwise."
-  (declare (type qt:object object)
-           (type (or string symbol) name))
-  (qt:variant-boundp (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 (lispify-property-name (cxx:name (cxx:property meta-object index)))))
-
-(defun sort-symbols (symbols)
-  (sort symbols
-        #'(lambda (a b)
-            (string<= (write-to-string a) (write-to-string b)))))
-
-(defgeneric qt:class-properties (class)
-  (:documentation "Returns a list of the properties of CLASS.")
-  (:method ((class class))
-    (sort-symbols
-     (meta-object-properties (cxx:static-meta-object class))))
-  (:method ((symbol symbol))
-    (qt:class-properties (find-class symbol))))
-
-(defgeneric qt: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))
-    (qt:class-direct-properties (find-class symbol))))
-
-(defun dynamic-properties (object)
-  (map 'list (compose #'lispify-property-name #'cxx:data)
-       (cxx:dynamic-property-names object)))
-
-(defun qt:properties (object)
-  "Returns a list of the properties of OBJECT."
-  (declare (type qt:object object))
-  (sort-symbols
-   (nconc (dynamic-properties object)
-          (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-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/qstring.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,57 +0,0 @@
-(in-package :cl-smoke.qt-impl)
-
-(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))
-
-;;; make sure, that you have configured slime correctly.
-;;; 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.
-;;; Use emacs 23 for better unicode support.
-(smoke:eval-startup (:compile-toplevel :execute)
-  (qt:text-codec.set-codec-for-cstrings
-   (qt:text-codec.codec-for-name (string *default-foreign-encoding*)))
-  (qt:text-codec.set-codec-for-locale
-   (qt:text-codec.codec-for-name (string *default-foreign-encoding*))))
-
-(smoke:eval-startup (:compile-toplevel :execute)
-  (let ((method (smoke::make-smoke-method-from-name (find-class 'qt:byte-array)
-                                                    "constData")))
-    (defmethod cxx:const-data ((array qt:byte-array))
-      (values ;; Discharge second return value (length of string)
-       (foreign-string-to-lisp (smoke::pointer-call method
-                                                    (smoke::pointer array))
-                               :count (cxx:size array))))))
-
-(defun from-qstring (qstring)
-  (cxx:const-data (make-instance 'qt:byte-array
-                                 :pointer (qt-smoke-qstring-to-byte-array qstring))))
-
-(define-to-lisp-translation ("QString" "const QString&")
-    from-qstring qt-smoke-free-qstring)
-
-(defun coerce-qstring (string)
-  (make-cleanup-pointer
-   (with-foreign-string ((data length) string :null-terminated-p nil)
-     (qt-smoke-string-to-qstring data length))
-   #'qt-smoke-free-qstring))
-
-(define-from-lisp-translation ("const QString&" "QString") string
-  coerce-qstring)
-
-(defmethod print-object ((object qt:byte-array) stream)
-  (if (null-pointer-p (pointer object))
-      (call-next-method)
-      (print-unreadable-object (object stream :type t :identity t)
-        (when (smoke::const-p object)
-          (princ "CONST " stream))
-        (prin1 (cxx:const-data object) stream))))
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-10-30 07:41:23.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-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/qt.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,38 +0,0 @@
-;;; Copyright (C) 2009 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-impl)
-
-(define-smoke-module :cl-smoke.qt libsmokeqt
-  (*qt-smoke* "qt_Smoke")
-  (init-qt-smoke "init_qt_Smoke"))
-
-(eval-when (:load-toplevel :compile-toplevel :execute)
-  (define-foreign-library libqt-smoke-extra
-      (:unix "libqt-smoke-extra.so")
-    (t (:default "libqt-smoke-extra")))
-  (use-foreign-library libqt-smoke-extra))
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-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/signal-slot/connect.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,204 +0,0 @@
-(in-package :cl-smoke.qt-impl)
-
-(defgeneric qt:connect (qsignal slot &optional type)
-  (:documentation "Connects a signal to a slot."))
-
-(defgeneric qt:disconnect (qsignal slot)
-  (:documentation "Disconnects a connection."))
-
-(defgeneric qt: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
-       (if (typep signal-arg 'smoke::smoke-type)
-           (assert (smoke-type= signal-arg slot-arg))
-           (assert (subtypep signal-arg slot-arg)))))
-
-;;FIXME check argument-types
-(defmethod qt: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 qt:connect ((sender qsignal) (function function) &optional type)
-  (let ((slot (make-instance 'qslot
-                             :arg0 (signal-object sender)
-                             :argument-types (argument-types (signal-object sender))
-                             :slot-function function)))
-
-    (unless (connect-id (signal-object sender) (id (signal-object sender))
-                        slot (id slot)
-                        type 
-                        (types (argument-types (signal-object 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."))
-
-(defmethod print-object ((qt-signal qt-signal) stream)
-  (print-unreadable-object (qt-signal stream :type t :identity t)
-    (when (slot-boundp qt-signal 'sender)
-      (princ (qsender qt-signal) stream))
-    (princ " " stream)
-    (when (slot-boundp qt-signal 'name)
-      (princ (name qt-signal) stream))))
-
-(defgeneric qt:get-slot (receiver name)
-  (:documentation "Returns the slot of RECEIVER with NAME.")
-  (:method (receiver name)
-    (make-instance 'qt-slot :receiver receiver :name name))
-  (:method (receiver (function function))
-    "Returns a slot for RECEIVER that calls function
-with RECEIVER as the first argument."
-    (make-instance 'qslot 
-                   :arg0 receiver
-                   :slot-function #'(lambda (&rest args)
-                                      (apply function (cxx:parent *this*)
-                                             args)))))
-
-(define-compiler-macro qt:get-slot (&whole form receiver name)
-  "Normalize the slot name."
-  (if (stringp name)
-      (let ((normalized-name (cxx:data
-                              (qt:meta-object.normalized-signature name))))
-        (if (string= name normalized-name) ;; Avoid infinite recursion
-            form
-            `(qt:get-slot ,receiver ,normalized-name)))
-      form))
-
-(defun qt:get-signal (sender name)
-  "Returns the signal NAME of SENDER."
-  (make-instance 'qt-signal :sender sender :name name))
-
-(define-compiler-macro qt:get-signal (&whole form sender name)
-  "Normalize the signal name."
-  (if (stringp name)
-      (let ((normalized-name (cxx:data 
-                              (qt:meta-object.normalized-signature name))))
-        (if (string= name normalized-name) ;; Avoid infinite recursion
-            form
-            `(qt:get-signal ,sender ,normalized-name)))
-      form))
-  
-(defmethod qt:connect ((qt-signal qt-signal) (qt-slot qt-slot) &optional type)
-  (unless (qt:object.connect (qsender qt-signal) (qt:qsignal (name qt-signal))
-                          (receiver qt-slot) (qt:qslot (name qt-slot))
-                          (or type  qt:+auto-connection+))
-    (cerror "Failed to connect ~A ~A to ~A ~A."
-            (qsender qt-signal) (name qt-signal)
-            (receiver qt-slot) (name qt-slot))))
-
-(defmethod qt:disconnect ((qt-signal qt-signal) (qt-slot qt-slot))
-  (unless (qt:object.disconnect (qsender qt-signal) (qt:qsignal (name qt-signal))
-                             (receiver qt-slot) (qt: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 qt:disconnect-all ((sender qt:object))
-  (unless (qt:object.disconnect sender 0 0 0)
-    (cerror "Failed to disconnect everything connected to ~A."
-            sender)))
-
-       
-(defmethod qt: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
-                              :arg0 (qsender qt-signal)
-                              :slot-function function
-                              :argument-types
-                              (method-arguments-type
-                               (cxx:meta-object (qsender qt-signal))
-                               signal-id))))
-    ;; Ensure that the slot is not gc'ed as long as the QT-SIGNAL
-    ;; exists.
-    ;;
-    ;; FIXME: remove on disconnect.
-    ;; This no not critical because the slot
-    ;; object is not accessible to the user,
-    ;; who thus can not connect it to other
-    ;; signals.
-    (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 qt: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 qt: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)
-  (qt:meta-object.connect sender signal-id
-                       receiver slot-id
-                       (if (null type)
-                           qt:+auto-connection+
-                           type)
-                       types))
-
-(defun disconnect-id (sender signal-id receiver slot-id)
-  (qt:meta-object.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-10-30 07:41:23.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 :cl-smoke.qt-impl)
-
-
-(defclass funcallable-smoke-class (closer-mop:funcallable-standard-class
-                                   cxx: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 qt:qmethod (name)
-  "Equivalent of the METHOD(a) CPP macro."
-  (assert (not (munged-name-p name)))
-  (format nil "0~A" name))
-
-(defun qt:qslot (name)
-  "Equivalent of the SLOT(a) CPP macro."
-  (assert (not (munged-name-p name)))
-  (format nil "1~A" name))
-
-(defun qt: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-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/signal-slot/signal.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,122 +0,0 @@
-(in-package :cl-smoke.qt-impl)
-
-(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 (qt: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 qt: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."
-  ;; For efficiency assume that SLOT is normalized and fallback to
-  ;; normalizing when not. (Just like Qt does.)
-  (let ((id (cxx:index-of-slot (cxx:meta-object receiver)
-                               slot)))
-    (when (< id 0)
-      (setf id (cxx:index-of-slot (cxx:meta-object receiver)
-                                  (qt: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 make-lisp-object (object)
-  (smoke:make-cleanup-pointer (make-cxx-lisp-object object)
-                              #'qt-smoke-free-lisp-object))
-                        
-
-(defun convert-arguments (arguments types)
-  "Returns a list of ARGUMENTS converted to TYPES."
-  (mapcar #'(lambda (argument type)
-              (if (typep type 'smoke::smoke-type)
-                  (smoke::convert-argument argument type)
-                  (progn (assert (typep argument type)
-                                 ()
-                                 "The argument ~S is not of type ~S.")
-                         (make-lisp-object argument))))
-          arguments types))
-  
-(defun emit (qsignal &rest arguments)
-  "Emits the signal QSIGNAL."
-  (activate qsignal (id qsignal) (argument-types qsignal) arguments))
-
-(defun activate (object id types arguments)
-  ;;; 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 (convert-arguments arguments types)
-                            types)
-    (with-foreign-object (args :pointer (1+ (length arguments)))
-      (loop for i from 1 to (smoke::size stack)
-         for type in types
-         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 (smoke::call-stack-pointer stack)
-                                'smoke::smoke-stack-item
-                                i)
-                      'smoke::smoke-stack-item 'smoke::voidp)
-                     (foreign-slot-pointer
-                      (mem-aref (smoke::call-stack-pointer stack)
-                                'smoke::smoke-stack-item
-                                i)
-                      'smoke::smoke-stack-item 'smoke::voidp))))
-      (setf (mem-aref args :pointer 0)
-            (null-pointer))
-      (qt:meta-object.activate object id args))))
-
-(defmethod qt: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-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/signal-slot/slot.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,63 +0,0 @@
-(in-package :cl-smoke.qt-impl)
-
-(defclass qslot (qt: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 slot function specified")
-             :documentation "The function called when the slot is invoked."))
-  (:metaclass cxx:class)
-  (:documentation "A Qt slot that calls its associated function"))
-
-(defun qt: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 "The sender of the signal.")
-(defparameter *this* nil "The slot that is invoked.")
-(defmacro qt:sender ()
-  "Returns the sender that invoked the slot."
-  `*sender*)
-
-(defmethod cxx:qt-metacall ((slot qslot) call id arguments)
-  "Invoke the slots function when it is called. The return value
-of the invoked slot function is ignored."
-  (declare (ignore id))
-  (let ((id (call-next-method)))
-    (if (< id 0)
-        id
-        (if (enum= call qt:meta-object.+invoke-meta-method+)
-            (progn
-              (ccase id
-                (0 (let ((*sender* (cxx:sender slot))
-                         (*this* slot))
-                     (with-simple-restart
-                         (continue "Skip the function ~A of slot ~A."
-                                   (slot-function slot) slot)
-                       (apply (slot-function slot)
-                              (arguments-to-lisp arguments (arguments slot)))))))
-              (1- id))
-            id))))
-
-(defun find-signal-id (sender signal)
-  "Returns the ID of SIGNAL from SENDER."
-  ;; For efficiency assume that SIGNAL is normalized and fallback to
-  ;; normalizing when not. (Just like Qt does.)
-  (let ((id (cxx:index-of-signal (cxx:meta-object sender)
-                                 signal)))
-    (when (< id 0)
-      (setf id (cxx:index-of-signal (cxx:meta-object sender)
-                                    (qt:meta-object.normalized-signature signal))))
-    (when (< id 0)
-      (error "No signal ~S for class ~S."
-             signal (class-of sender)))
-    id))
-
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-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/signal-slot/translate.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,111 +0,0 @@
-(in-package :cl-smoke.qt-impl)
-
-(defun find-type (name &optional start end)
-  (smoke::make-smoke-type *smoke-module* (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 disown-object (object)
-  (tg:cancel-finalization object)
-  (unless (smoke::virtual-destructor-p (class-of object))
-    (smoke::remove-object (pointer object)))
-  object)
-
-(defun pointer-to-lisp (pointer type)
-  "Returns the lisp value or object at POINTER of type TYPE."
-  (if (smoke::class-p type)
-      (if (smoke::pointer-p type)
-          (smoke::object-to-lisp (mem-ref pointer :pointer) type)
-          ;; By-value means that the object at POINTER is allocated by
-          ;; the C++ signal code and has dynamic extend in the
-          ;; slot. The C++ signal code frees the object when the slot
-          ;; returns.
-          (disown-object (smoke::object-to-lisp pointer type)))
-      (ecase (smoke::type-id type)
-        (0 (if-let ((translation (gethash (name type) smoke::*to-lisp-translations*)))
-             ;; Do not free stack allocated stuff (e.g.: QString); that is the callers
-             ;; responisbility.
-             (funcall (car translation) pointer)
-             (error "Do not know how to convert the type ~A to Lisp." 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)
-  "Returns ARGUMENTS for a slot invocation as lisp objects."
-  (arguments-to-lisp2
-   (inc-pointer arguments ;; index 0 is for the return value
-                (foreign-type-size :pointer))
-   types ()))
-
-
-(defun get-type (smoke-type)
-  "Returns the QMetaType ID for SMOKE-TYPE."
-  (typecase smoke-type
-    (smoke::smoke-standard-object
-     (if (smoke::pointer-p smoke-type)
-         (error "Not implemented: pointer type.") ;;qmetatype.+voidstar+
-         (let ((type (qt: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)
-  "Returns a newly allocated array of QMetaType IDs of 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-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/string-list.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,49 +0,0 @@
-(in-package :cl-smoke.qt-impl)
-
-(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))
-
-(defun from-string-list (string-list)
-  (let ((vector (make-array (qt-smoke-string-list-size string-list)
-                            :initial-element ""
-                            :element-type 'string)))
-    (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)))))))
-  
-(define-to-lisp-translation ("QStringList" "const QStringList&")
-    from-string-list qt-smoke-free-string-list)
-
-(defun coerce-string-list (sequence)
-  (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)
-    (make-cleanup-pointer
-     string-list #'qt-smoke-free-string-list)))
-
-(defun string-list-p (sequence)
-  (every #'stringp sequence))
-
-(define-from-lisp-translation "const QStringList&"
-    (and (vector string)
-         (satisfies string-list-p))
-  coerce-string-list)
diff -rN -u old-qt.gui/src/timer.lisp new-qt.gui/src/timer.lisp
--- old-qt.gui/src/timer.lisp	2014-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/timer.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,31 +0,0 @@
-(in-package :cl-smoke.qt-impl)
-
-(defclass single-shot-timer (qt:object)
-  ((function :initarg :function
-             :type function)
-   (timer-id :type integer))
-  (:metaclass cxx:class))
-
-(defvar *single-shot-timers* nil "Pending timers.")
-
-(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. Equivalent to QTimer::singleShot,
-but calls a function instead of a slot."
-  (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 qt: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) event)
-  (declare (ignore event))
-  (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/variant.lisp new-qt.gui/src/variant.lisp
--- old-qt.gui/src/variant.lisp	2014-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/src/variant.lisp	1970-01-01 01:00:00.000000000 +0100
@@ -1,118 +0,0 @@
-(in-package :cl-smoke.qt-impl)
-
-(defmethod print-object ((variant qt:variant) stream)
-  "Print the type and value of the variant."
-  (if (or (not (slot-boundp variant 'pointer))
-          (null-pointer-p (pointer variant)))
-      (call-next-method)
-      (print-unreadable-object (variant stream :type t :identity t)
-        (format stream "~A~@[ ~S~]" 
-                (cxx:type-name variant)
-                (handler-case (qt:from-variant variant)
-                  (error () nil))))))
-
-(defun qt:make-variant (&optional (value nil value-p))
-  "Returns a new VARIANT containing a C++ version of VALUE
-or an empty variant when VALUE is not specified."
-  (if value-p
-      (make-instance 'qt:variant :arg0 value)
-      (make-instance 'qt:variant)))
-
-(defun qt:make-char (character)
-  "Returns a char for a lisp CHARACTER."
-  (let ((octets (babel:string-to-octets (string character))))
-    (case (length octets)
-      (1 (make-instance 'qt:char :arg0 (aref octets 0)))
-      (2 (make-instance 'qt:char :args (list (aref octets 0)
-                                             (aref octets 1))))
-      (t (error "qt:char requires the character ~A to be encoded
-in one or two octets, but it is using ~A."
-                character (length octets))))))
-
-(defun surrogate-p (char)
-  (or (cxx:is-high-surrogate char)
-      (cxx:is-low-surrogate char)))
-
-(defun qt:from-char (char)
-  "Returns the Lisp character represented by CHAR."
-  (assert (not (surrogate-p char))
-          (char)
-          "The char ~A is part of a surrogate.")
-  (char
-   (babel:octets-to-string (make-array 2 :element-type '(unsigned-byte 8)
-                                       :initial-contents
-                                       (list
-                                        (char-code (cxx:cell char))
-                                        (char-code (cxx:row char)))))
-   0))
-
-(defmethod print-object ((char qt:char) stream)
-  (if (or (null-pointer-p (pointer char))
-          (surrogate-p char))
-      (call-next-method)
-      (print-unreadable-object (char stream :type t)
-        (princ (qt:from-char char) stream))))
-
-
-;; FIXME include in MAKE-VARIANT? how??
-(defun qt:make-lisp-variant (value)
-  "Returns a new VARIANT that wraps VALUE.
-
-The variant contains the actual Lisp object VALUE
-and not its C++ value like in MAKE-VARIANT."
-  (let ((object (make-cxx-lisp-object value)))
-    (unwind-protect
-         (make-instance 'qt:variant :args (list *cxx-lisp-object-metatype*
-                                                object))
-      (free-cxx-lisp-object object))))
-
-(defcfun qt-smoke-lisp-object-value :pointer
-  (variant :pointer))
-
-(defun qt:variant-boundp (variant)
-  "Returns true when VARIANT is valid (has a value) and false otherwise."
-  (cxx:is-valid variant))
-
-(defmacro variant-conversions ((variant) &body types)
-  `(ecase (cxx:user-type ,variant)
-    
-     ,@(loop for type in types collect
-            (if (symbolp type)
-            `(,(value (symbol-value 
-                       (let ((*package* (find-package :cl-smoke.qt)))
-                       (alexandria:symbolicate 'variant.+ type '+))))
-               (,(intern (format nil "TO-~A" type) :cxx) ,variant))
-            type))))
-
-(defun qt:from-variant (variant)
-  "Returns the value of VARIANT."
-  (variant-conversions (variant)
-    (#.(value qt:variant.+invalid+)
-       (cerror "Return (VALUES)" "Type of variant ~A is invalid." variant)
-       (values))
-    bit-array bool byte-array
-    char
-    date date-time double
-    int
-    line line-f list locale long-long
-    point point-f
-    rect rect-f reg-exp
-    size size-f string string-list
-    time
-    uint
-    ulong-long
-    url
-    (#.*cxx-lisp-object-metatype*
-     (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))))
-    
-(defmethod qt:value ((variant qt:variant))
-  "Returns the value of VARIANT."
-  (qt:from-variant variant))
-
-(defmethod (setf qt:value) (new-value (variant qt:variant))
-  (cxx:operator= variant (qt:make-variant new-value))
-  new-value)
diff -rN -u old-qt.gui/test.lisp new-qt.gui/test.lisp
--- old-qt.gui/test.lisp	2014-10-30 07:41:23.000000000 +0100
+++ new-qt.gui/test.lisp	2014-10-30 07:41:23.000000000 +0100
@@ -3,7 +3,7 @@
 # Used for testing on darcs record.
 |#
 
-(asdf:operate 'asdf:load-op :qt)
-(asdf:operate 'asdf:test-op :qt)
+(asdf:operate 'asdf:load-op :cl-smoke.qt.gui)
+(asdf:operate 'asdf:test-op :cl-smoke.qt.gui)
 
 (sb-ext:quit)