Wed Mar 10 18:13:52 CET 2010 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Delete QPainDevices before the QApplication is destroyed.

Mon Jan 25 20:09:40 CET 2010 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Fix with-app cleanup

Mon Jan 25 19:50:16 CET 2010 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Fix with-painter

Mon Jan 25 19:49:07 CET 2010 Tobias Rautenkranz <tobias@rautenkranz.ch>

* QList<Foo*> translations

Mon Jan 25 19:48:42 CET 2010 Tobias Rautenkranz <tobias@rautenkranz.ch>

* QVector<QPointF> translation

Mon Jan 25 19:48:17 CET 2010 Tobias Rautenkranz <tobias@rautenkranz.ch>

* ownership transfer QGraphicsScene::addItem

Sat Jan 23 20:48:00 CET 2010 Tobias Rautenkranz <tobias@rautenkranz.ch>

* QVector translations

Sun Jan 10 09:52:49 CET 2010 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Split up in qt.gui & cleanup name prefix.

Sun Dec 13 13:44:37 CET 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Support ASDF instead of Mudballs.

Sun Dec 13 11:50:24 CET 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Install msg-handler also when starting from an image

Sun Dec 13 11:49:35 CET 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Convert C++ exceptions to a qFatal

Wed Sep 9 15:18:08 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Cleanup msg-handler

Wed Sep 2 14:00:35 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Better Lisp vector to QList<*> conversion.

Thu Aug 27 10:37:36 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Update to the new smokegenerator.

Sun Aug 2 13:29:13 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Fix double space when printing a qt:object.

Sun Aug 2 13:29:02 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* qt:event upcasting cleanup

Sun Aug 2 13:15:21 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Support ownership transfer to non smoke wrapped QObjects & cleanup C++ to Lisp translation.

Mon Jul 27 21:39:43 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Fix ownership transfer for lambda slot to no Smoke object.

Fri Jul 24 15:40:52 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Remove unnecessary #'cxx:data calls.

Thu Jul 23 00:21:01 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* support packages for symbols as property names.

Wed Jul 8 22:55:24 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* The smoke call stack is now a struct -> adapt.

Fri Jul 3 12:14:09 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Fix nested #'qt:exec

Thu Jul 2 21:37:42 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Fix potential lisp-object ID generation overflow for excessive lisp-object creation.

Thu Jul 2 21:12:45 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* move emit slot code to new function ACTIVATE & image startup fix for STATIC-META-OBJECT

Wed Jul 1 12:58:06 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Break API compatibility for qt:with-app and qt:exec & spellcheck

Sun Jun 21 11:29:25 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* *SMOKE-MODULE* must be passed instead of *QT-SMOKE*.

Thu Jun 11 20:50:26 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* The CLISP null pointer is NIL

Thu Jun 11 16:59:48 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* :qt and :qt-impl packages to prevent collision with :cl symbols and fix object with non smoke parent.

Wed Jun 10 14:14:34 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Transfer ownerhip only for smoke classes.

Wed Jun 10 14:02:01 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* more qt:variant conversions

Fri Jun 5 09:45:07 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* get-slot for function with this argument

Thu Jun 4 12:58:29 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Normalize signal and slot names at compile time.

Thu Jun 4 00:02:12 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* Fix QT:APPLICATION cleanup in QT:WITH-APP and add restart to slot invocation.

Mon Jun 1 00:39:13 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* QList<QWidget*>

Mon Jun 1 00:22:22 CEST 2009 Tobias Rautenkranz <tobias@rautenkranz.ch>

* QList<QObject*>

--- old-qt.gui/CMakeLists.txt 2014-10-30 07:48:16.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)

--- old-qt.gui/TODO 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/TODO 1970-01-01 01:00:00.000000000 +0100

@@ -1 +0,0 @@

-* QApplication and KCmdLineArgs.init call exit() on e.g. "--help"

--- 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:48:16.000000000 +0100

@@ -0,0 +1,21 @@

+(defsystem :cl-smoke.qt.gui

+ :name :cl-smoke.qt.gui

+ :version (0 0 1)

+ :author "Tobias Rautenkranz"

+ :license "GPL with linking exception"

+ :description "Smoke Qt GUI bindings."

+ :depends-on (:cl-smoke.qt.core)

+

+ :components

+ ((:module "src"

+ :components

+ ((:file "package")

+ (:file "qt.gui" :depends-on ("package"))

+ (:file "ownership" :depends-on ("qt.gui"))

+ (:file "application" :depends-on ("qt.gui"))

+ (:file "translations" :depends-on ("qt.gui"))

+ (:file "painter" :depends-on ("qt.gui"))))))

+

+(defmethod perform ((operation test-op) (c (eql (find-system :cl-smoke.qt.gui))))

+ (operate 'asdf:load-op :cl-smoke.qt.tests)

+ (operate 'asdf:test-op :cl-smoke.qt.tests))

--- old-qt.gui/examples/hello-world.lisp 2014-10-30 07:48:16.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)))))

--- old-qt.gui/examples/package.lisp 2014-10-30 07:48:16.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))

--- old-qt.gui/qt.mbd 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/qt.mbd 1970-01-01 01:00:00.000000000 +0100

@@ -1,71 +0,0 @@

-;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-

-

-;;; SYSDEF.CMAKE

-(defpackage :sysdef.cmake

- (:use :cl :sysdef)

- (:export :cmake-file :cmake-library))

-

-(in-package :sysdef.cmake)

-(defclass sysdef.cmake:cmake-file (source-file)

- ()

- (:default-initargs :type "txt"))

-

-(defclass sysdef.cmake:cmake-library (component)

- ())

-;;; end SYSDEF.CMAKE

-

-(in-package :sysdef-user)

-(eval-when (:compile-toplevel :load-toplevel :execute)

- (use-package :sysdef.cmake))

-

-(define-system :qt ()

- (:version 0 0 1)

- (:documentation "Smoke Qt bindings.")

- (:keywords "GUI" "Qt")

- (:author "Tobias Rautenkranz")

- (:license "GPL with linking exception")

- (:components

- ("CMakeLists" sysdef.cmake:cmake-file)

- ("src" module

- (:needs "CMakeLists")

- (:components

- ("CMakeLists.txt" static-file)

- "package"

- ("lib" module

- (:needs "package")

- (:components

- ("libqt-smoke-extra" sysdef.cmake:cmake-library)

-

- ("CMakeLists.txt" static-file)

- ("qt-smoke.cpp" static-file)

- ("lisp-object.h" static-file)

- ("lisp-object.cpp" static-file)

- ("qstring.cpp" static-file)

- ("qstringlist.cpp" static-file)))

-

- ("qt" (:needs "package" "lib"))

- ("ownership" (:needs "qt"))

- ("object" (:needs "qt"))

- ("operator" (:needs "qt" "object"))

- ("application" (:needs "qt"))

- ("qstring" (:needs "qt"))

- ("list" (:needs "qt"))

- ("msg-handler" (:needs "lib"))

- ("painter" (:needs "qt"))

- ("timer" (:needs "qt"))

- ("i18n" (:needs "qt"))

- ("lisp-object" (:needs "qt" "lib"))

- ("signal-slot" module

- (:needs "lisp-object")

- (:serial t)

- (:components

- "signal-slot"

- "translate"

- "signal"

- "slot"

- "connect"))

- ("string-list" (:needs "qt" "lib" "qstring"))

- ("variant" (:needs "qt" "qstring" "lisp-object"))

- ("properties" (:needs "variant")))))

- (:uses-macros-from :smoke)

- (:needs :smoke :sysdef.cmake :cffi :alexandria))

--- old-qt.gui/src/CMakeLists.txt 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/src/CMakeLists.txt 1970-01-01 01:00:00.000000000 +0100

@@ -1 +0,0 @@

-add_subdirectory(lib)

--- old-qt.gui/src/application.lisp 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/src/application.lisp 2014-10-30 07:48:16.000000000 +0100

@@ -1,108 +1,60 @@

-(in-package :qt)

+(in-package :cl-smoke.qt.gui)

-(declaim (optimize (debug 3)))

-

-(defvar *app*)

(defvar *widgets* nil)

-(defvar *exec-p* t

- "Run exec if true and not otherwise.")

-(defun app ()

- "Returns the APPLICATION (or CORE-APPLICATION) object,

-within a WITH-APP."

- (assert (app-p)

- (*app*)

- "No application.")

- *app*)

-

-(defun app-p ()

- "Returns t when the APPLICATION object exists and nil otherwise."

- (boundp '*app*))

-

-

-(let ((argv (null-pointer))

- (argc (null-pointer)))

- (declare (cffi:foreign-pointer argv argc))

- (defun ensure-app (&optional

- (application 'application)

- (args #+sbcl sb-ext:*posix-argv*

- #+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 (app-p)

- (progn

- (assert (typep (app) (find-class application))

- (application)

- "The existing application object ~A is

-not of type ~A." (app) (find-class application))

- (values (app) nil))

- (progn

- ;(assert (null-pointer-p (smoke::pointer (core-application.instance))))

- (foreign-free argv)

- (foreign-free argc)

-

- (setf argv (foreign-alloc :string :initial-contents args))

- (setf argc (foreign-alloc :int :initial-element (length args)))

- (values (make-instance 'qt:application :args (list argc argv)) t))))

- (defun kill-app ()

- (cxx:quit (app))

- (when (typep (app) (find-class 'qt:application))

- (application.close-all-windows))

- (setf *widgets* nil)

- (trivial-garbage:cancel-finalization (app))

- (smoke::remove-object (smoke::pointer (app)))

- ;; FIXME leak memory or memory fault!

- ;(smoke::delete-pointer (smoke::pointer (app)) (class-of (app)))

- (cxx:delete-later (app))

- (setf (slot-value (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 cl-smoke.qt.core:delete-app :around ((application qt:application))

+ (qt:application.close-all-windows)

+ ;; widgets are only valid as long, as an application object

+ ;; exists. QApplication::~QApplication() deletes all widgets in

+ ;; QApplication::allWidgets().

+ ;;

+ ;; see: qt4/src/gui/kernel/qapplication.cpp

+ (loop for widget across (qt:application.all-widgets) do

+ (tg:cancel-finalization widget))

+ ;; QPaintDevices are only valid when a application object exists.

+ (loop for object being the hash-values of smoke::*object-map* do

+ (when (typep object 'qt:paint-device)

+ (delete-object object)))

+ ;; Finalize other stuff before deleting the QApplication,

+ ;; e.g. QGraphicsScene

+ (tg:gc :full t)

+ (call-next-method)

+ (setf *widgets* nil))

-(defmacro with-app (&body body)

+(defmacro qt:with-app (options &body body)

"Ensures that a APPLICATION instance exists,

evaluates BODY and executes the APPLICATION instance after BODY.

The instance can be accessed with:

-APP.

+QT:APP.

Can be nested.

When a APPLICATION was created, it will be deleted when returning

from BODY."

- `(with-application ((ensure-app 'application) (kill-app))

- ,@body))

-

-(defmacro with-core-app (&body body)

- `(with-application ((ensure-app 'core-application) (kill-app))

- ,@body))

-

-

-(defun exec (&rest widgets)

- "Executes APP."

- (setf *widgets* (append widgets *widgets*))

- (when *exec-p*

- (restart-bind ((abort-app #'(lambda ()

- (application.close-all-windows)

- (cxx:quit (app))

- (invoke-restart (find-restart 'continue)))

- :report-function

- #'(lambda (stream)

- (format stream "Return from the application event loop."))

- :test-function

- #'(lambda (condition)

- (declare (ignore condition))

- (find-restart 'continue))))

- (cxx:exec (app)))))

+ (assert (null options)

+ (options)

+ "Currently no options can be passed to QT:WITH-APP.")

+ `(cl-smoke.qt.core:with-application ((cl-smoke.qt.core:ensure-app 'qt:application)

+ (cl-smoke.qt.core:kill-app))

+ ,@body))

+

+(defun qt:exec ()

+ "Executes APP. When QT:*EXEC-P* is false it returns immediately

+and transfers the ownership of the top-level widgets to the qt:application

+instance."

+ (if qt:*exec-p*

+ (restart-bind ((qt::abort-app #'(lambda ()

+ (cxx:quit (qt:app))

+ (invoke-restart (find-restart 'continue)))

+ :report-function

+ #'(lambda (stream)

+ (format stream "Return from the application event loop."))

+ :test-function

+ #'(lambda (condition)

+ (declare (ignore condition))

+ (and (qt:app-p)

+ (find-restart 'continue)))))

+ (let ((qt:*exec-p* nil))

+ (cxx:exec (qt:app))))

+ (when (typep (qt:app) 'qt:application)

+ (setf *widgets* (qt:application.top-level-widgets)))))

--- old-qt.gui/src/i18n.lisp 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/src/i18n.lisp 1970-01-01 01:00:00.000000000 +0100

@@ -1,57 +0,0 @@

-(in-package :qt)

-

-(defun tr (message &optional context)

- "Returns the translated MESSAGE for CONTEXT or

-a string STRING-EQUAL to MESSAGE when no translation was found.

-

-Translations can be loaded with WITH-TRANSLATOR."

- (qt:core-application.translate (or context "") message))

-

-(defmacro with-installed-translator (translator &body body)

- `(unwind-protect

- (progn

- (cxx:install-translator (qt:app) ,translator)

- ,@body)

- (cxx:remove-translator (qt:app) ,translator)))

-

-(defmacro with-translator ((base-name &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 '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 with-libqt-translator (&body body)

- "Loads the translations for the Qt library.

-

-Must be in a WITH-APP."

- (let ((translator (gensym)))

- `(let ((,translator (make-instance 'translator)))

- (unless (cxx:load ,translator (format nil "qt_~A"

- (cxx:name (qt:locale.system)))

- (qt:library-info.location qt:library-info.+translations-path+))

- (cerror "Ignore" "Loading the Qt library translations failed."))

- (with-installed-translator ,translator

- ,@body))))

-

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

-

--- old-qt.gui/src/lib/CMakeLists.txt 2014-10-30 07:48:16.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)

--- old-qt.gui/src/lib/cl_smoke_qt.h 2014-10-30 07:48:16.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

--- old-qt.gui/src/lib/lisp-object.cpp 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/src/lib/lisp-object.cpp 1970-01-01 01:00:00.000000000 +0100

@@ -1,179 +0,0 @@

-#include "lisp-object.h"

-

-#include <QtGlobal>

-#include <QtDebug>

-

-namespace cl_smoke {

-namespace qt {

-

-/** @struct lisp_object::data

- * @internal

- * Holds a reference ID for a lisp object and calls

- * the destructor callback when it is deleted.

- */

-

-/** @typedef lisp_object::destructor

- * Destructor.

- * @param id The ID

- */

-

-lisp_object::destructor lisp_object::destruct = NULL;

-

-

-/** Constructor. */

-lisp_object::data::data()

-: id(id),

- is_set(false)

-{ }

-

-/** Constructor.

- * @param id The ID.

- */

-lisp_object::data::data(int id)

-: id(id),

- is_set(true)

-{ }

-

-/** Destructor. */

-lisp_object::data::~data()

-{

- Q_ASSERT_X(lisp_object::destruct, __func__,

- "call setup_lisp_object() first.");

-

- if (this->is_set)

- (*lisp_object::destruct)(this->id);

-}

-

-/** @class lisp_object

- * @brief Holds a reference ID to a lisp object.

- *

- * The registered destructor callback is called when

- * the last instance for a specific lisp object is deleted.

- *

- * Used for lisp objects in QVariants and signal/slots.

- */

-

-/** Constructor. */

-lisp_object::lisp_object()

- : d(new data())

-{ }

-

-/** Constructor.

- * @param id the ID

- */

-lisp_object::lisp_object(int id)

- : d(new data(id))

-{ }

-

-/** Constructor.

- * @param other the lisp_object to copy

- */

-lisp_object::lisp_object(const lisp_object& other)

- : d(other.d)

-{ }

-

-/** @fn lisp_object::id() const

- * Gets the ID.

- *

- * @return the ID

- */

-

-/** @fn lisp_object::set() const

- * Determines werter the ID is set.

- *

- * @return @c true when the id is set and @c false otherwise.

- */

-

-/** Sets a new ID.

- * @param id the ID

- */

-void

-lisp_object::set_id(int id)

-{

- Q_ASSERT(this->set() ? id != this->id() : true);

-

- d = new data(id);

-}

-

-} // namespace qt

-} // namespace cl_smoke

-

-using namespace cl_smoke::qt;

-

-/** Initialize the lisp_object.

- * @relates cl_smoke::qt::lisp_object

- * @param destruct destructor callback

- *

- * @return the QMetaType ID of lisp_object

- */

-int

-qt_smoke_setup_lisp_object(void* destruct)

-{

- Q_ASSERT(destruct != NULL);

- lisp_object::destruct = reinterpret_cast<lisp_object::destructor>(destruct);

-

- return qRegisterMetaType<lisp_object>();

-}

-

-/** Gets the ID of @a object.

- * @relates cl_smoke::qt::lisp_object

- * @param object the lisp_object.

- *

- * @return the ID

- */

-int

-qt_smoke_lisp_object_id(const void* object)

-{

- return static_cast<const lisp_object*>(object)->id();

-}

-

-

-/** Determines werter the ID of @a object is set.

- * @relates cl_smoke::qt::lisp_object

- * @param object the object

- *

- * @return @c true when the ID is set and @c false otherwise.

- */

-int

-qt_smoke_lisp_object_set(const void* object)

-{

- return static_cast<const lisp_object*>(object)->set();

-}

-

-/** Makes a new lisp_object.

- * @relates cl_smoke::qt::lisp_object

- * @param id the ID

- *

- * @return A new lisp_object instance.

- */

-void*

-qt_smoke_make_lisp_object(int id)

-{

- return new lisp_object(id);

-}

-

-/** Deletes a lisp_object.

- * @relates cl_smoke::qt::lisp_object

- * @param object the lisp_object

- */

-void*

-qt_smoke_free_lisp_object(void* object)

-{

- delete static_cast<lisp_object*>(object);

-}

-

-#include <QVariant>

-/** Gets the lisp_object of a QVariant.

- * @relates cl_smoke::qt::lisp_object

- * @param variant the QVariant

- *

- * @return a new lisp_object.

- */

-void*

-qt_smoke_lisp_object_value(const void* variant)

-{

- const QVariant* qvariant = static_cast<const QVariant*>(variant);

- Q_ASSERT(QVariant::UserType == qvariant->type());

-

- new lisp_object(qvariant->value<lisp_object>());

-}

--- old-qt.gui/src/lib/lisp-object.h 2014-10-30 07:48:16.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 int

- qt_smoke_lisp_object_id(const void* object);

-

- CL_SMOKE_QT_EXPORT int

- qt_smoke_lisp_object_set(const void* object);

-

- CL_SMOKE_QT_EXPORT void*

- qt_smoke_make_lisp_object(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)(int id);

-

- lisp_object();

-

- lisp_object(int id);

-

- lisp_object(const lisp_object& other);

-

- inline int

- id() const

- { Q_ASSERT(this->set()); return d->id; }

-

- void

- set_id(int id);

-

- inline bool

- set() const

- { return d->is_set; }

-

- friend int

- ::qt_smoke_setup_lisp_object(void* destruct);

-

- private:

- struct data : public QSharedData

- {

- data();

- data(int id);

- ~data();

- int id;

- bool is_set;

-

- private:

- Q_DISABLE_COPY(data)

- };

-

- QExplicitlySharedDataPointer<data> d;

-

- static destructor destruct;

-};

-

-} // namespace qt

-} // namespace cl_smoke

-

-Q_DECLARE_METATYPE(cl_smoke::qt::lisp_object);

-

-#endif // LISP_OBJECT_H

--- old-qt.gui/src/lib/qlist.cpp 2014-10-30 07:48:16.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"

--- old-qt.gui/src/lib/qlist.h 2014-10-30 07:48:16.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

--- old-qt.gui/src/lib/qstring.cpp 2014-10-30 07:48:16.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"

--- old-qt.gui/src/lib/qstringlist.cpp 2014-10-30 07:48:16.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"

--- old-qt.gui/src/lib/qt-smoke.cpp 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/src/lib/qt-smoke.cpp 1970-01-01 01:00:00.000000000 +0100

@@ -1,28 +0,0 @@

-#include <qnamespace.h>

-#include <QEvent>

-#include <QtDebug>

-

-#include "cl_smoke_qt.h"

-

-/** @file

- * @brief Qt support functions */

-

-extern "C" {

-

-/** Registers a callback to be invoked for every QEvent.

- * @see QCoreApplication::notifyInternal

- *

- * @param callback the callback

- *

- * @return @c true on success and @c false when the callback table is full.

- */

-CL_SMOKE_QT_EXPORT int

-qt_smoke_register_event_notify(void* callback)

-{

- Q_ASSERT(callback);

-

- return QInternal::registerCallback(QInternal::EventNotifyCallback,

- reinterpret_cast<qInternalCallback>(callback));

-}

-

-} // extern "C"

--- old-qt.gui/src/lisp-object.lisp 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/src/lisp-object.lisp 1970-01-01 01:00:00.000000000 +0100

@@ -1,61 +0,0 @@

-(in-package :qt)

-

-(defvar *cxx-lisp-objects* (smoke::make-synchronized-hash-table)

- "Objects that are currently passed in a C++ class.")

-

-(let ((id 0))

- (defun gen-cxx-lisp-object-id ()

- "Returns a new unique ID."

- (incf id)))

-

-(defcfun qt-smoke-setup-lisp-object :int

- (destruct :pointer))

-

-(defcfun qt-smoke-lisp-object-id :int

- (object :pointer))

-

-(defcfun qt-smoke-lisp-object-set :int

- (object :pointer))

-

-(defcfun qt-smoke-make-lisp-object :pointer

- (id :int))

-

-(defcfun qt-smoke-free-lisp-object :void

- (object :pointer))

-

-(defcallback destruct-cxx-lisp-object :void

- ((id :int))

- (remhash id *cxx-lisp-objects*))

-

-(defvar *cxx-lisp-object-metatype* "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 meta-type.+user+))

- (*cxx-lisp-object-metatype*)

- "setup of lisp-object failed"))

-

-(defun make-cxx-lisp-object (object)

- "Constructs a C++ object wrapper for OBJECT."

- (let ((id (gen-cxx-lisp-object-id)))

- (setf (gethash id *cxx-lisp-objects*) object)

- (qt-smoke-make-lisp-object id)))

-

-(defun free-cxx-lisp-object (pointer)

- "Deletes the lisp_object at POINTER."

- (qt-smoke-free-lisp-object pointer))

-;; (qmetatype.destroy *cxx-lisp-object-metatype* pointer)) ;; FIXME use this?

-

-(defun translate-cxx-lisp-object (pointer)

- "Returns the object of the cxx-lisp-object at POINTER.

-

-When beeing received as an argument by a slot,

-the object must not be deallocated."

- (multiple-value-bind (value present-p)

- (gethash (qt-smoke-lisp-object-id pointer)

- *cxx-lisp-objects*)

- (assert present-p (value present-p)

- "No object for ~A in ~A" pointer *cxx-lisp-objects*)

- value))

--- old-qt.gui/src/list.lisp 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/src/list.lisp 1970-01-01 01:00:00.000000000 +0100

@@ -1,64 +0,0 @@

-(in-package :qt)

-

-(defmacro define-qlist-wrapper (type-name)

- (let* ((type (string-upcase type-name))

- (list-type (symbolicate 'qlist- type)))

- `(progn

- (defcfun ,(concatenate 'string "qt_smoke_list_" type-name "_size") :int

- "Returns the size of LIST."

- (list :pointer))

- (defcfun ,(concatenate 'string "qt_smoke_free_list_" type-name) :void

- "Frees LIST."

- (list :pointer))

- (defcfun ,(concatenate 'string "qt_smoke_make_list_" type-name) :pointer

- "Makes a list.")

- (defcfun ,(concatenate 'string "qt_smoke_list_" type-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_" type-name "_append") :pointer

- "Appends NEW-ELEMENT to LIST."

- (list :pointer)

- (new-element :pointer))

- (define-foreign-type ,list-type ()

- ()

- (:actual-type :pointer))

- (define-parse-method ,list-type ()

- (make-instance ',list-type))

- (eval-when (:load-toplevel :execute)

- (smoke::add-type ,(format nil "const QList<~A>&" type-name)

- ',list-type)

- (smoke::add-type ,(format nil "QList<~A>" type-name) ',list-type))

- (defmethod translate-from-foreign (list (type ,list-type))

- (let ((vector (make-array (,(symbolicate 'qt-smoke-list-

- type '-size)

- list))))

- (dotimes (index (length vector) vector)

- (setf (aref vector index)

- ;; FIXME the retuned object is not wrapped by Smoke

- ;; -> change this?

- (smoke::object-to-lisp

- (,(symbolicate 'qt-smoke-list-

- type '-at)

- list index)

- (smoke::make-smoke-type *qt-smoke* ,type-name))))))

- (defmethod free-translated-object (pointer (type ,list-type) param)

- (declare (ignore param))

- (,(symbolicate 'qt-smoke-free-list- type)

- pointer))

- (defun ,(symbolicate 'coerce- list-type) (list)

- (let ((qlist (,(symbolicate 'qt-smoke-make-list- type))))

- (loop for element in list do

- (,(symbolicate 'qt-smoke-list- type '-append)

- qlist (pointer (make-instance ',type :args (list element)))))

- (smoke::make-cleanup-pointer

- qlist

- (function ,(symbolicate 'qt-smoke-free-list- type)))))

- (define-from-lisp-translation (,(format nil "const QList<~A>&" type-name)

- ,(format nil "QLIst<~A>" type-name))

- list ;; FIXME allow seqence and define element type

- ,(symbolicate 'coerce- list-type)))))

-

-(define-qlist-wrapper "QVariant")

-;(define-qlist-wrapper "void")

-(define-qlist-wrapper "QByteArray")

--- old-qt.gui/src/msg-handler.lisp 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/src/msg-handler.lisp 1970-01-01 01:00:00.000000000 +0100

@@ -1,26 +0,0 @@

-(in-package :qt)

-

-(cffi:defcenum qt-msg-type

- (:debug-message)

- (:warning-message)

- (:critical-message)

- (:fatal-message))

-

-(defcallback qt-msg-handler :void

- ((type qt-msg-type)

- (message :string))

- (ecase type

- (:debug-message

- (write-string "qDebug: " *debug-io*)

- (write-line message *debug-io*))

- (:warning-message (warn message))

- (:critical-message (cerror "Ignore" "~A" message))

- (:fatal-message (error message))))

-

-(defun register-msg-handler ()

- (with-foreign-object (handler :pointer)

- (setf (mem-ref handler :pointer) (callback qt-msg-handler))

- (qt:q-install-msg-handler handler)))

-

-(eval-when (:load-toplevel)

- (register-msg-handler))

--- old-qt.gui/src/object.lisp 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/src/object.lisp 1970-01-01 01:00:00.000000000 +0100

@@ -1,170 +0,0 @@

-(in-package :qt)

-

-(let ((object (make-instance 'object)))

- (defmethod cxx:static-meta-object ((class (eql (find-class 'object))))

- "No OBJECT.STATIC-META-OBJECT (r558420)."

- (cxx:meta-object object))

- (defmethod cxx:static-meta-object ((class cxx:class))

- (cxx:static-meta-object (smoke::find-smoke-class class))))

-

-(defmethod documentation :around ((class cxx:class)

- (doc-type t))

- (if (and (subtypep class (find-class '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 (class-properties class) #'string<=)

- (sort (class-signals class) #'string<=)

- (sort (class-slots class) #'string<=))

- (call-next-method)))

-

-(defmethod print-object ((object 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:object-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)

- (mapcar #'cxx:signature

- (remove-if-not #'(lambda (m) (enum= qt:meta-method.+signal+

- (cxx:method-type m)))

- (meta-object-methods meta-object))))

-

-(defun class-signals (class)

- (meta-object-signals (cxx:static-meta-object class)))

-

-(defun meta-object-slots (meta-object)

- (mapcar #'cxx:signature

- (remove-if-not #'(lambda (m) (enum= qt:meta-method.+slot+

- (cxx:method-type m)))

- (meta-object-methods meta-object))))

-

-

-(defun class-slots (class)

- (meta-object-slots (cxx:static-meta-object class)))

-

-

-(defmethod initialize-instance :after ((object object)

- &key pointer &allow-other-keys)

- "Registers the object to the parent when a parent was set in the constructor

-and the objects metaclass is SMOKE-WRAPPER-CLASS."

- (when (and (null pointer)

- (null-pointer-p (smoke::pointer object)))

- (error "Object ~A has not been constructed" object))

- (when (and (null pointer)

- (not (null-pointer-p (smoke::pointer object)))

-; (typep (class-of object) 'cxx:class)

- (not (null-pointer-p (smoke::pointer (cxx:parent object)))))

- (smoke::disown-object object)))

-

-(define-condition wrapper-gc (storage-condition)

- ((class-name :initarg :class-name

- :documentation "The class name of the gc'ed object.")

- (pointer :initarg :pointer))

- (:report (lambda (condition stream)

- (format stream "The object ~A ~A of type cxx:class

-has a parent but got garbage collected."

- (slot-value condition 'class-name)

- (slot-value condition 'pointer)))))

-

-(smoke:eval-startup (:compile-toplevel :execute)

-(defparameter *get-parent*

- (smoke::make-smoke-method (smoke::make-smoke-class

- *qt-smoke*

- "QObject")

- "parent"))

- ;; FIXME this leaks memory when QCoreApplication::exec is never called,

- ;; beause then, deleteLater has no effect.

-(defparameter *delete-later*

- (smoke::make-smoke-method (smoke::make-smoke-class

- *qt-smoke*

- "QObject")

- "deleteLater")))

-

-(defun print-object-to-string (object)

- (with-output-to-string (stream)

- (print-object object stream)))

-

-(defmethod smoke::make-finalize ((object object))

- "Delete the qt:object OBJECT,

- by calling cxx:delete-later iff it has no parent."

- (let ((pointer (pointer object))

- (class (class-of object))

- (next (call-next-method)))

- (if (typep (class-of object) 'cxx:class)

- #'(lambda ()

- (handler-case

- (if (null-pointer-p (smoke::pointer-call *get-parent* pointer))

- (smoke::pointer-call *delete-later* pointer)

- (error (make-condition 'wrapper-gc :class-name name

- :pointer pointer)))

- (error (condition)

- (smoke::report-finalize-error condition "qt:object wrap"

- (name class) pointer))))

- #'(lambda ()

- (handler-case

- (if (null-pointer-p (smoke::pointer-call *get-parent* pointer))

- (funcall next)

- (cerror 'continue "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 ((event (make-instance 'event :pointer (cffi:mem-aref data :pointer 1))))

- (enum-case (cxx:type event)

- (event.+child-added+

- (let* ((child-event (make-instance 'child-event

- :pointer

- (smoke::upcast event (find-class 'child-event)))))

- (smoke::disown-object (cxx:child child-event))))

- (event.+child-removed+

- (let* ((child-event (make-instance 'child-event

- :pointer (smoke::upcast event

- (find-class 'child-event)))))

- ;; We receive child removed events for any QObject, wherter

- ;; it was construted by Smoke or not. Only take ownership of objects

- ;; that have been constructed by Smoke.

- (when (smoke::has-pointer-p (smoke::pointer (cxx:child child-event)))

- (smoke::take-ownership (cxx:child child-event)))))))

- 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 "The event-notify callback table is full."))))

-

-(smoke:eval-startup ()

- (register-event-notify))

--- old-qt.gui/src/operator.lisp 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/src/operator.lisp 1970-01-01 01:00:00.000000000 +0100

@@ -1,96 +0,0 @@

-(in-package :qt)

-

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

- (handler-case (qt:operator== object o)

- (smoke::no-applicable-cxx-method ()

- (cxx: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."

- ;;FIXME smoke does not support casting operators => can not

- ;; return a useful value with operator[]."

- ;;(cxx:operator[] 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: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)

--- old-qt.gui/src/ownership.lisp 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/src/ownership.lisp 2014-10-30 07:48:16.000000000 +0100

@@ -1,4 +1,82 @@

-(in-package :qt)

+(in-package :cl-smoke.qt.gui)

-(define-takes-ownership cxx:push ((undo-stack undo-stack) undo-command)

+;; undo-stack

+(define-takes-ownership cxx:push ((undo-stack qt:undo-stack) undo-command)

undo-command)

+

+

+#|

+;; FIXME TODO

+;; application

+(define-takes-ownership cxx:set-style ((application application) (style style))

+ ;; NOT QString style

+ style) ;; STATIC

+

+

+;; core-application

+(define-takes-ownership cxx:post-event ((app core-application) receiver (event event))

+ event) ;; STATIC

+(define-takes-ownership cxx:post-event ((app core-application) receiver event priority)

+ event) ;; STATIC

+|#

+

+;; AbstractFileEngine::beginEntryList return value

+

+;; grid-layout

+(define-takes-ownership cxx:add-item ((layout qt:grid-layout) (item qt:layout-item)

+ row column)

+ item)

+(define-takes-ownership cxx:add-item ((layout qt:grid-layout) (item qt:layout-item)

+ row column row-span)

+ item)

+(define-takes-ownership cxx:add-item ((layout qt:grid-layout) (item qt:layout-item)

+ row column row-span colum-span)

+ item)

+(define-takes-ownership cxx:add-item ((layout qt:grid-layout) (item qt:layout-item)

+ row column row-span colum-span aligment)

+ item)

+

+(define-takes-ownership cxx:add-item ((layout qt:layout) (item qt:layout-item))

+ item)

+

+;; QIcon::QIcon(QIconEngine* engine)

+

+(define-takes-ownership cxx:register-editor ((factory qt:item-editor-factory)

+ type creator)

+ creator)

+

+

+(define-takes-ownership cxx:set-child ((this qt:standard-item) row colum item)

+ item)

+(define-takes-ownership cxx:set-child ((this qt:standard-item) row item)

+ item)

+(define-takes-ownership cxx:set-horizontal-header-item ((this qt:standard-item-model)

+ column item)

+ item)

+(define-takes-ownership cxx:set-vertical-header-item ((this qt:standard-item-model)

+ row item)

+ item)

+(define-takes-ownership cxx:set-item ((this qt:standard-item-model)

+ row column item)

+ item)

+(define-takes-ownership cxx:set-item ((this qt:standard-item-model)

+ row item)

+ item)

+(define-takes-ownership cxx:set-item-prototype ((this qt:standard-item-model)

+ item)

+ item)

+

+;; FIXME graphic-item has a lot more.

+(define-takes-ownership cxx:add-item ((this qt:graphics-scene) item)

+ item)

+

+;; Allocates return value

+;; QLineEdit::createStandardContextMenu()

+

+;; parent

+;; QListwidgetitem

+

+

+;; Releases ownership

+;;QList<QStandardItem *> QStandardItemModel::takeColumn ( int column )

+;; etc

--- old-qt.gui/src/package.lisp 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/src/package.lisp 2014-10-30 07:48:16.000000000 +0100

@@ -1,45 +1,2 @@

-(defpackage :qt

- (:use :cl :smoke :cffi :bordeaux-threads :cxx-support :alexandria)

- (: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

-

- #:from-variant

- #:make-variant

- #:make-lisp-variant

- #:value

- #:variant-boundp

-

- #:search-file

-

- #:connect

- #:get-slot

- #:get-signal

- #:make-slot

- #:make-signal

- #:connect-signal

- #:connect-function

- #:sender))

-

+(defpackage :cl-smoke.qt.gui

+ (:use :cl :smoke :cffi :bordeaux-threads :cxx-support :alexandria))

--- old-qt.gui/src/painter.lisp 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/src/painter.lisp 2014-10-30 07:48:16.000000000 +0100

@@ -1,16 +1,22 @@

-(in-package :qt)

+(in-package :cl-smoke.qt.gui)

-(defmacro with-painter ((painter paint-device) &body body)

+(defmacro qt:with-painter ((painter &optional paint-device) &body body)

"Binds a PAINTER instance for PAINT-DEVICE to PAINTER

- during the evaulation of BODY.

+ during the evaluation of BODY. Or when PAINT-DEVICE is not

+specified, saves and restored the state of PAINTER around BODY.

-Makes sure the painter ends after BODY; thus prevening problems with

-still active and not yet garbage collected painters."

- `(let ((,painter (make-instance 'painter :args (list ,paint-device))))

- (assert (cxx:is-active ,painter)

- (,painter)

- "Painter ~A for ~A is not active"

- ,painter ,paint-device)

- (unwind-protect

- (progn ,@body)

- (cxx:end ,painter))))

+Makes sure the painter ends after BODY; thus preventing problems with

+still active and not yet garbage collected painters in CXX:PAINT-EVENT."

+ (if paint-device

+ `(let ((,painter (make-instance 'qt:painter :arg0 ,paint-device)))

+ (assert (cxx:is-active ,painter)

+ (,painter)

+ "Painter ~A for ~A is not active"

+ ,painter ,paint-device)

+ (unwind-protect

+ (progn ,@body)

+ (cxx:end ,painter)))

+ `(progn (cxx:save ,painter)

+ (unwind-protect

+ (progn ,@body)

+ (cxx:restore ,painter)))))

--- old-qt.gui/src/properties.lisp 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/src/properties.lisp 1970-01-01 01:00:00.000000000 +0100

@@ -1,59 +0,0 @@

-(in-package :qt)

-

-(defun reverse-lispify (symbol)

- "Converts the name of symbol to C++ style."

- (smoke::lisp-to-cxx (symbol-name symbol)))

-

-(defun property-name (name)

- "The property name is a string or a to camelCase converted symbol."

- (typecase name

- (string name)

- (symbol (reverse-lispify name))))

-

-(defun property (object name)

- "Returns the property NAME of OBJECT."

- (from-variant (cxx:property object (property-name name))))

-

-

-(defun (setf property) (new-value object name)

- (cxx:set-property object (property-name name)

- (make-instance 'qt:variant

- :args (list new-value)))

- new-value)

-

-(defun remove-property (object name)

- "Removes the property NAME from OBJECT."

- (setf (property object name) (qt:make-variant)))

-

-(defun property-p (object name)

- "Returns T when NAME is a property of OBJECT and NIL otherwise."

- (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 (smoke::lispify (cxx:name (cxx:property meta-object index)))))

-

-(defgeneric class-properties (class)

- (:documentation "Returns a list of the properties of CLASS.")

- (:method ((class class))

- (meta-object-properties (cxx:static-meta-object class)))

- (:method ((symbol symbol))

- (class-properties (find-class symbol))))

-

-(defgeneric class-direct-properties (class)

- (:documentation "Returns a list of the properties of CLASS.")

- (:method ((class class))

- (meta-object-properties (cxx:static-meta-object class) nil))

- (:method ((symbol symbol))

- (class-direct-properties (find-class symbol))))

-

-(defun dynamic-properties (object)

- (map 'list (compose #'smoke::lispify #'cxx:data)

- (cxx:dynamic-property-names object)))

-

-(defun properties (object)

- "Returns a list of the properties of OBJECT."

- (nconc (dynamic-properties object)

- (meta-object-properties (cxx:meta-object object))))

--- old-qt.gui/src/qstring.lisp 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/src/qstring.lisp 1970-01-01 01:00:00.000000000 +0100

@@ -1,66 +0,0 @@

-(in-package :qt)

-

-(defcfun qt-smoke-string-to-qstring :pointer

- (data :string)

- (length :int))

-

-(defcfun qt-smoke-free-qstring :void

- (string :pointer))

-

-(defcfun qt-smoke-qstring-to-byte-array :pointer

- (qstring :pointer))

-

-(define-foreign-type qstring ()

- ()

- (:actual-type :pointer))

-

-(defun setup-type-map ()

- (smoke::add-type "QString" 'qstring)

- (smoke::add-type "const QString&" 'qstring))

-

-(eval-when (:load-toplevel :execute)

- (setup-type-map))

-

-;;; make sure, that you have configured slime corretly.

-;;; e.g.

-;;; (string #\U9999) crashed slime for me. Adding

-;;; (set-language-environment "UTF-8")

-;;; (setq slime-net-coding-system 'utf-8-unix)

-;;; to .emacs helps.

-(smoke:eval-startup (:compile-toplevel :execute)

- (text-codec.set-codec-for-cstrings

- (text-codec.codec-for-name (string *default-foreign-encoding*)))

- (text-codec.set-codec-for-locale

- (text-codec.codec-for-name (string *default-foreign-encoding*))))

-

-

-(define-parse-method qstring ()

- (make-instance 'qstring))

-

-(smoke:eval-startup (:compile-toplevel :execute)

-(let ((method (smoke::make-smoke-method (find-class 'byte-array)

- "data")))

- (defmethod cxx:data ((array byte-array))

- (values ;; Discarge second return value (length of string)

- (foreign-string-to-lisp (smoke::pointer-call method

- (smoke::pointer array))

- :count (cxx:size array))))))

-

-(defmethod translate-from-foreign (string (type qstring))

- (cxx:data (make-instance 'byte-array

- :pointer (qt-smoke-qstring-to-byte-array string))))

-

-(defmethod free-translated-object (pointer (type qstring) param)

- (declare (ignore param))

- (qt-smoke-free-qstring pointer))

-

-(defun coerce-qstring (string)

- (make-cleanup-pointer

- (with-foreign-string ((data length) string :null-terminated-p nil)

- (qt-smoke-string-to-qstring data length))

- #'(lambda (pointer)

- (free-translated-object pointer (make-instance 'qt::qstring)

- nil))))

-

-(define-from-lisp-translation ("const QString&" "QString") string

- coerce-qstring)

--- 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:48:16.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"))

--- old-qt.gui/src/qt.lisp 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/src/qt.lisp 1970-01-01 01:00:00.000000000 +0100

@@ -1,41 +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 :qt)

-

-(define-smoke-module libsmokeqt

- (*qt-smoke* "qt_Smoke")

- (init-qt-smoke "init_qt_Smoke"))

-

-

-(eval-when (:load-toplevel :compile-toplevel :execute)

- #-mudballs

- (define-foreign-library libqt-smoke-extra

- (:unix "libqt-smoke-extra.so")

- (t (:default "libqt-smoke-extra")))

-

- (use-foreign-library libqt-smoke-extra))

--- old-qt.gui/src/signal-slot/connect.lisp 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/src/signal-slot/connect.lisp 1970-01-01 01:00:00.000000000 +0100

@@ -1,161 +0,0 @@

-(in-package :qt)

-

-(defgeneric connect (qsignal slot &optional type)

- (:documentation "Connects a signal to a slot."))

-

-(defgeneric disconnect (qsignal slot)

- (:documentation "Disconnects a connection."))

-

-(defgeneric disconnect-all (qsignal)

- (:documentation "Disconnects all connections of QSIGNAL."))

-

-(defun check-argument-types (signal-arguments slot-arguments)

- (assert (= (length signal-arguments) (length slot-arguments)))

- (loop for signal-arg in signal-arguments

- for slot-arg in slot-arguments do

- (assert (subtypep signal-arg slot-arg))))

-

-;;FIXME check argument-types

-(defmethod connect ((qsignal qsignal) (qslot qslot) &optional type)

- (assert (or (slot-boundp (signal-object qsignal) 'argument-types)

- (slot-boundp qslot 'arguments))

- ((slot-value (signal-object qsignal) 'argument-types)

- (slot-value qslot 'arguments))

- "Argument types must be specified for at least on of

-~A and ~A." qsignal qslot)

- (when (not (slot-boundp (signal-object qsignal) 'argument-types))

- (setf (argument-types (signal-object qsignal))

- (arguments qslot)))

- (when (not (slot-boundp qslot 'arguments))

- (setf (slot-value qslot 'arguments)

- (argument-types (signal-object qsignal))))

- (check-argument-types (argument-types (signal-object qsignal))

- (arguments qslot))

- (unless (connect-id (signal-object qsignal) (id (signal-object qsignal))

- qslot (id qslot)

- type

- (types (arguments qslot)))

- (cerror "Failed to connect ~S to ~S." qsignal qslot)))

-

-(defmethod connect ((sender qsignal) (function function) &optional type)

- (let ((slot (make-instance 'qslot

- :args (list (signal-object sender))

- :slot-function function)))

- (unless (connect-id (signal-object sender) (id (signal-object sender))

- slot (id slot)

- type

- (types (arguments sender)))

- (cerror "Failed to connect the function ~S to the signal ~S."

- function sender))))

-

-(defclass qt-signal-slot-name ()

- ((name :initarg :name

- :reader name)))

-

-(defclass qt-signal (qt-signal-slot-name)

- ((sender :initarg :sender

- :reader qsender))

- (:documentation "Qt C++ signal."))

-

-(defclass qt-slot (qt-signal-slot-name)

- ((receiver :initarg :receiver

- :reader receiver))

- (:documentation "Qt C++ slot."))

-

-(defun get-slot (receiver name)

- "Returns the slot of RECEIVER with NAME."

- (make-instance 'qt-slot :receiver receiver :name name))

-

-(defun get-signal (sender name)

- "Returns the signal NAME of SENDER."

- (make-instance 'qt-signal :sender sender :name name))

-

-(defmethod connect ((qt-signal qt-signal) (qt-slot qt-slot) &optional type)

- (unless (object.connect (qsender qt-signal) (qsignal (name qt-signal))

- (receiver qt-slot) (qslot (name qt-slot))

- (or type +auto-connection+))

- (cerror "Failed to connect ~A ~A to ~A ~A."

- (qsender qt-signal) (name qt-signal)

- (receiver qt-slot) (name qt-slot))))

-

-(defmethod disconnect ((qt-signal qt-signal) (qt-slot qt-slot))

- (unless (object.disconnect (qsender qt-signal) (qsignal (name qt-signal))

- (receiver qt-slot) (qslot (name qt-slot)))

- (cerror "Failed to disconnect ~A ~A from ~A ~A."

- (receiver qt-slot) (name qt-slot)

- (qsender qt-signal) (name qt-signal))))

-

-(defmethod disconnect-all ((sender object))

- (unless (object.disconnect sender 0 0 0)

- (cerror "Failed to disconnect everything connected to ~A."

- sender)))

-

-

-(defmethod connect ((qt-signal qt-signal) (function function) &optional type)

- (let* ((signal-id (find-signal-id (qsender qt-signal) (name qt-signal)))

- (slot (make-instance 'qslot

- ;; Set the sender as the slots parent,

- ;; to ensure it does not get gc'ed.

- ;; FIXME: unset parent on disconnect

- ;; this no not critical beause the slot object

- ;; is hidden from the user, who thus can not

- ;; connect it to other signals.

- :args (list (qsender qt-signal))

- :slot-function function

- :argument-types

- (method-arguments-type

- (cxx:meta-object (qsender qt-signal))

- signal-id))))

- (if (connect-id (qsender qt-signal) signal-id

- slot (id slot)

- type (types (arguments slot)))

- (cxx:connect-notify (qsender qt-signal)

- (name qt-signal))

- (cerror "Ignore" "Failed to connect the signal ~S of ~S to the function ~S."

- (name qt-signal) (qsender qt-signal) function))))

-

-(defmethod connect ((qt-signal qt-signal) (slot qslot) &optional type)

- (let ((signal-id (find-signal-id (qsender qt-signal) (name qt-signal))))

- (if (slot-boundp slot 'arguments)

- (check-argument-types (method-arguments-type (cxx:meta-object

- (qsender qt-signal))

- signal-id)

- (arguments slot))

- (setf (slot-value slot 'arguments)

- (method-arguments-type (cxx:meta-object (qsender qt-signal))

- signal-id)))

- (if (connect-id (qsender qt-signal) signal-id

- slot (id slot)

- type (types (arguments slot)))

- (cxx:connect-notify (qsender qt-signal)

- (name qt-signal))

- (cerror "Ignore" "Failed to connect the signal ~S of ~S to the slot ~S."

- (name qt-signal) (qsender qt-signal) slot))))

-

-(defmethod connect ((qsignal qsignal) (slot qt-slot) &optional type)

- (let ((slot-id (find-slot-id (receiver slot) (name slot))))

- (if (slot-boundp (signal-object qsignal) 'argument-types)

- (check-argument-types (argument-types (signal-object slot))

- (method-arguments-type (cxx:meta-object

- (receiver slot))

- slot-id))

- (setf (argument-types (signal-object qsignal))

- (method-arguments-type (cxx:meta-object (receiver slot))

- slot-id)))

- (unless (connect-id (signal-object qsignal) (id (signal-object qsignal))

- (receiver slot) slot-id

- type

- (types (argument-types (signal-object qsignal))))

- (cerror "Failed to connect ~S to ~S." qsignal slot))))

-

-

-(defun connect-id (sender signal-id receiver slot-id type types)

- (meta-object.connect sender signal-id

- receiver slot-id

- (if (null type)

- (value +auto-connection+)

- (value type))

- types))

-

-(defun disconnect-id (sender signal-id receiver slot-id)

- (meta-object.disconnect sender signal-id receiver slot-id))

--- old-qt.gui/src/signal-slot/signal-slot.lisp 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/src/signal-slot/signal-slot.lisp 1970-01-01 01:00:00.000000000 +0100

@@ -1,35 +0,0 @@

-(in-package :qt)

-

-

-(defclass funcallable-smoke-class (closer-mop:funcallable-standard-class

- 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 qmethod (name)

- "Equivalent of the METHOD(a) CPP macro."

- (assert (not (munged-name-p name)))

- (format nil "0~A" name))

-

-(defun qslot (name)

- "Equivalent of the SLOT(a) CPP macro."

- (assert (not (munged-name-p name)))

- (format nil "1~A" name))

-

-(defun qsignal (name)

- "Equivalent of the SIGNAL(a) CPP macro."

- (assert (not (munged-name-p name)))

- (format nil "2~A" name))

-

--- old-qt.gui/src/signal-slot/signal.lisp 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/src/signal-slot/signal.lisp 1970-01-01 01:00:00.000000000 +0100

@@ -1,158 +0,0 @@

-(in-package :qt)

-(declaim (optimize (debug 3)))

-

-(defclass qsignal-mixin ()

- ((signal-object :accessor signal-object

- :initarg :signal-object

- :initform (make-instance 'signal-object)))

- (:documentation "in SB-PCL you can not have both

-FUNCALLABLE-STANDARD-CLASS and STANDARD-CLASS,

-thus QSIGNAL is split in three classes.

-

-See:

- http://www.sbcl.org/manual/Metaobject-Protocol.html#index-validate_002dsuperclass-164"))

-

-(defclass signal-object (object)

- ((argument-types :accessor argument-types

- :initarg :argument-types

- :documentation "List of the argument types"))

- (:documentation "Qt Signal object.")

- (:metaclass cxx:class))

-

-#+cmu (defmethod closer-mop:validate-superclass ((class closer-mop:funcallable-standard-class)

- (superclass standard-class))

- t)

-

-(defclass qsignal (closer-mop:funcallable-standard-object qsignal-mixin)

- ()

- (:metaclass closer-mop:funcallable-standard-class)

- (:documentation "A funcallable Qt signal.

-The argument types can be supplied by the :METHOD-TYPES initarg.

-Calling an instance emits the signal."))

-

-(defun make-signal (&rest argument-types)

- "Returns a funcallable signal. When ARGUMENT-TYPES are not

-specified, they are determined when the first connection is made."

- (if argument-types

- (make-instance 'qsignal :argument-types argument-types)

- (make-instance 'qsignal)))

-

-(defmethod id ((qsignal signal-object))

- (cxx:method-count (cxx:meta-object qsignal)))

-

-(defmethod initialize-instance :after ((object qsignal) &rest initargs

- &key (argument-types nil arg-types-p)

- &allow-other-keys)

- (declare (ignore initargs))

- (when arg-types-p

- (setf (argument-types (signal-object object))

- argument-types))

- (closer-mop:set-funcallable-instance-function object

- #'(lambda (&rest args)

- (apply #'emit (signal-object object) args)))

- )

-

-(defun find-slot-id (receiver slot)

- "Returns the ID of RECEIVER from SLOT."

- (let ((id (cxx:index-of-slot (cxx:meta-object receiver)

- (cxx:data (meta-object.normalized-signature slot)))))

- (when (< id 0)

- (error "No slot ~S for class ~S.

-The valid slots are: ~{~<~%~T~0,75:;~A ~>~}"

- slot (class-of receiver)

- (class-slots (class-of receiver))))

- id))

-

-(defun connect-signal (qsignal receiver slot &optional (type 0))

- "Connects a signal to a slot. Returns T on success and NIL otherwise."

-

- (let ((qsignal (signal-object qsignal))

- (slot-id (find-slot-id receiver slot)))

- (when (not (slot-boundp qsignal 'argument-types))

- (setf (argument-types qsignal)

- (method-arguments-type (cxx:meta-object receiver)

- slot-id)))

- (assert (>= slot-id 0)

- ()

- "No slot ~S for class ~S."

- slot (class-name receiver))

- (or (meta-object.connect qsignal (id qsignal)

- receiver slot-id

- type

- ;; QMetaObject::connect is responsible

- ;; for freeing the types array.

- (types (method-arguments-type

- (cxx:meta-object receiver)

- slot-id)))

- (cerror "Ignore"

- "Failed to connect ~S to the slot ~S of ~S."

- qsignal slot receiver))))

-

-(defun disconnect-signal (qsignal receiver slot)

- (let ((qsignal (signal-object qsignal))

- (slot-id (cxx:index-of-slot (cxx:meta-object receiver)

- (cxx:data

- (meta-object.normalized-signature slot)))))

- (assert (>= slot-id 0)

- ()

- "No slot ~S for class ~S."

- slot (class-name receiver))

- (or (meta-object.disconnect qsignal (id qsignal)

- receiver slot-id)

- (cerror "Ignore"

- "Failed to disconnect ~S to the slot ~S of ~S."

- qsignal slot receiver))))

-

-(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."

-;;; The first element of args would be used for the return value

-;;; by QMetaObject::invokeMethod(), but for signal-slot connection

-;;; it is ignored.

- (let ((types (argument-types qsignal)))

- (smoke::with-stack (stack (convert-arguments arguments types)

- types)

- (cffi:with-foreign-object (args :pointer (1+ (length arguments)))

- (loop for i from 1 to (smoke::size stack)

- for type in (argument-types qsignal)

- do

- (setf (mem-aref args :pointer i)

- (if (or (not (typep type (find-class 'smoke::smoke-type)))

- (= 0 (smoke::type-id type))

- (= 13 (smoke::type-id type)))

- (foreign-slot-value

- (mem-aref (pointer stack)

- 'smoke::smoke-stack-item

- i)

- 'smoke::smoke-stack-item 'smoke::voidp)

- (foreign-slot-pointer

- (mem-aref (pointer stack)

- 'smoke::smoke-stack-item

- i)

- 'smoke::smoke-stack-item 'smoke::voidp))))

- (setf (mem-aref args :pointer 0)

- (null-pointer))

- (meta-object.activate qsignal (cxx:meta-object qsignal)

- (id qsignal)

- args)))))

-

-(defmethod disconnect-all ((qsignal qsignal))

- (unless (disconnect-id (signal-object qsignal)

- (id (signal-object qsignal))

- 0

- 0)))

--- old-qt.gui/src/signal-slot/slot.lisp 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/src/signal-slot/slot.lisp 1970-01-01 01:00:00.000000000 +0100

@@ -1,70 +0,0 @@

-(in-package :qt)

-(declaim (optimize (debug 3)))

-

-(defclass qslot (object)

- ((arguments :reader arguments :initarg :argument-types

- :documentation "List of the argument types for the slot.")

- (function :reader slot-function :initarg :slot-function

- :initform (error "no function specified")

- :documentation "The function called when the slot is invoked."))

- (:metaclass cxx:class)

- (:documentation "A Qt slot that calls its associated function"))

-

-(defun make-slot (function &optional (arguments nil arguments-p))

- "Returns a slot that calls FUNCTION when it receives a signal."

- (if arguments-p

- (make-instance 'qslot

- :slot-function function

- :argument-types arguments)

- (make-instance 'qslot

- :slot-function function)))

-

-(defmethod id ((slot qslot))

- (cxx:method-count (cxx:meta-object slot)))

-

-(defparameter *sender* nil)

-(defmacro sender ()

- "Returns the sender that invoked the slot."

- `*sender*)

-

-(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."

- (let ((id (call-next-method)))

- (if (< id 0)

- id

- (if (enum= call meta-object.+invoke-meta-method+)

- (progn

- (case id

- (0 (let ((*sender* (cxx:sender 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."

- (let ((id (cxx:index-of-signal (cxx:meta-object sender)

- (cxx:data (meta-object.normalized-signature signal)))))

- (when (< id 0)

- (error "No signal ~S for class ~S."

- signal (class-of sender)))

- id))

-

-(defun connect-function (sender signal function &optional (type 0))

- "Connects FUNCTION to the SIGNAL of SENDER.

-The return value of FUNCTION is ignored."

- (let* ((signal-id (find-signal-id sender signal))

- (slot (make-instance 'qslot

- :args (list sender)

- :slot-function function

- :argument-types (method-arguments-type

- (cxx:meta-object sender)

- signal-id))))

- (let ((ret (meta-object.connect sender signal-id

- slot (id slot)

- type (types (arguments slot)))))

- (if ret

- (cxx:connect-notify sender signal)

- (cerror "Failed to connect the signal ~S of ~S to the function ~S."

- signal sender function)))))

--- old-qt.gui/src/signal-slot/translate.lisp 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/src/signal-slot/translate.lisp 1970-01-01 01:00:00.000000000 +0100

@@ -1,110 +0,0 @@

-(in-package :qt)

-

-(defun find-type (name &optional start end)

- (smoke::make-smoke-type *qt-smoke* (subseq name start end)))

-

-(defun method-arguments-type (metaobject index)

- "Returns a type name list for the arguments of method INDEX of METAOBJECT."

- (let* ((signature (cxx:signature (cxx:method metaobject index)))

- (arguments (subseq signature (1+ (position #\( signature))

- (position #\) signature :from-end t)))

- (argument-types ())

- (last-pos (length arguments)))

- (loop as pos = (position #\, arguments :from-end t :end last-pos)

- while pos

- do

- (push (find-type arguments (1+ pos) last-pos) argument-types)

- (setf last-pos pos))

- (when (> last-pos 0)

- (push (find-type arguments 0 last-pos) argument-types))))

-

-

-(defun arguments-to-lisp2 (argument types values)

- (if (null types)

- values

- (arguments-to-lisp2 (inc-pointer argument (foreign-type-size :pointer))

- (rest types)

- (nconc values

- (list

- (typecase (first types)

- (smoke::smoke-type

- (pointer-to-lisp (mem-ref argument :pointer)

- (first types)))

-

- (t

- (translate-cxx-lisp-object

- (mem-ref argument :pointer)))))))))

-

-(defun 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 they are allocated by the C++ signal

- ;; code and have dynamic extend in the slot. The C++ singal code

- ;; frees the object when the slot returns.

- (disown-object (smoke::object-to-lisp pointer type)))

- (ecase (smoke::type-id type)

- (0 (let ((cffi-type (smoke::get-type (name type))))

- (if (null cffi-type)

- (progn

- pointer)

- (convert-from-foreign pointer

- cffi-type))))

- (1 (mem-ref pointer 'cxx-bool))

- (2 (code-char (mem-ref pointer :char)))

- (3 (code-char (mem-ref pointer :unsigned-char)))

- (4 (code-char (mem-ref pointer :short)))

- (5 (code-char (mem-ref pointer :unsigned-short)))

- (6 (mem-ref pointer :int))

- (7 (mem-ref pointer :unsigned-int))

- (8 (mem-ref pointer :long))

- (9 (mem-ref pointer :unsigned-long))

- (10 (mem-ref pointer :float))

- (11 (mem-ref pointer :double))

- (12 (make-instance 'enum

- :value (mem-ref pointer :long)

- :type type)))))

-

-

-(defun arguments-to-lisp (arguments types)

- "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 "FOO");;qmetatype.+voidstar+

- (let ((type (meta-type.type (smoke::name smoke-type))))

- (assert (/= 0 type)

- (type)

- "The type ~S has no QMetaType."

- (smoke::name smoke-type))

- type)))

- (t

- *cxx-lisp-object-metatype*)))

-

-

-(defun types (smoke-types)

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

--- old-qt.gui/src/string-list.lisp 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/src/string-list.lisp 1970-01-01 01:00:00.000000000 +0100

@@ -1,61 +0,0 @@

-(in-package :qt)

-

-(defcfun qt-smoke-string-list-size :int

- (string-list :pointer))

-

-(defcfun qt-smoke-string-list-at :pointer

- (string-list :pointer)

- (index :int))

-

-(defcfun qt-smoke-free-string-list :void

- (string-list :pointer))

-

-(defcfun qt-smoke-make-string-list :pointer)

-

-(defcfun qt-smoke-string-list-append :void

- (string-list :pointer)

- (string :pointer)

- (length :int))

-

-(define-foreign-type string-list ()

- ()

- (:actual-type :pointer))

-

-(eval-when (:load-toplevel)

- (smoke::add-type "QStringList" 'string-list)

- (smoke::add-type "const QStringList&" 'string-list))

-

-

-(define-parse-method string-list ()

- (make-instance 'string-list))

-

-(defmethod translate-to-foreign (sequence (type string-list))

- (let ((string-list (qt-smoke-make-string-list)))

- (map nil #'(lambda (string)

- (with-foreign-string ((data length) string :null-terminated-p nil)

- (qt-smoke-string-list-append string-list data length)))

- sequence)

- string-list))

-

-

-(defmethod translate-from-foreign (string-list (type string-list))

- (let ((vector (make-array (qt-smoke-string-list-size string-list))))

- (dotimes (index (length vector) vector)

- (setf (aref vector index)

- (cxx:data (make-instance 'qt:byte-array

- :pointer (qt-smoke-string-list-at

- string-list index)))))))

-

-(defmethod free-translated-object (string-list (type string-list) param)

- (declare (ignore param))

- (qt-smoke-free-string-list string-list))

-

-(defun coerce-string-list (list)

- (make-cleanup-pointer

- (translate-to-foreign list (make-instance 'qt::string-list))

- #'(lambda (pointer)

- (free-translated-object pointer (make-instance 'qt::string-list)

- nil))))

-

-(define-from-lisp-translation "const QStringList&"

- (vector string) coerce-string-list)

--- old-qt.gui/src/timer.lisp 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/src/timer.lisp 1970-01-01 01:00:00.000000000 +0100

@@ -1,30 +0,0 @@

-(in-package :qt)

-

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

- (cxx:kill-timer timer (slot-value timer 'timer-id))

- (funcall (slot-value timer 'function))

- (remove timer *single-shot-timers*))

--- old-qt.gui/src/translations.lisp 1970-01-01 01:00:00.000000000 +0100

+++ new-qt.gui/src/translations.lisp 2014-10-30 07:48:16.000000000 +0100

@@ -0,0 +1,14 @@

+(in-package :cl-smoke.qt.gui)

+

+;; QPoint has a trivial copy ctor and destructor, thus memcpying it

+;; should be fine.

+(cl-smoke.qt.core:define-qvector-translations "QPoint" qt:point)

+(cl-smoke.qt.core:define-qvector-translations "QPointF" qt:point-f)

+

+(cl-smoke.qt.core:define-qvector-translations "unsigned int"

+ (smoke:c-integer :unsigned-int))

+

+(cl-smoke.qt.core::define-qlist-wrapper "QAction*" qt:action "void")

+(cl-smoke.qt.core::define-qlist-wrapper "QGraphicsItem*" qt:graphics-item "void")

+(cl-smoke.qt.core::define-qlist-wrapper "QStandardItem*" qt:standard-item "void")

+(cl-smoke.qt.core::define-qlist-wrapper "QWidget*" qt:widget "void")

--- old-qt.gui/src/variant.lisp 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/src/variant.lisp 1970-01-01 01:00:00.000000000 +0100

@@ -1,109 +0,0 @@

-(in-package :qt)

-

-(defmethod print-object ((variant 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 (from-variant variant)

- (error () nil))))))

-

-(defun 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 'variant :args (list value))

- (make-instance 'variant)))

-

-(defun make-char (character)

- "Returns a char for a lisp CHARACTER."

- (let ((octets (babel:string-to-octets (string character))))

- (case (length octets)

- (1 (make-instance 'char :args (list (aref octets 0))))

- (2 (make-instance '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 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 char) stream)

- (if (or (null-pointer-p (pointer char))

- (surrogate-p char))

- (call-next-method)

- (print-unreadable-object (char stream :type t)

- (princ (from-char char) stream))))

-

-

-;; FIXME include in MAKE-VARIANT?

-(defun make-lisp-variant (value)

- "Returns a new VARIANT that wraps VALUE.

-

-The variant contains the actual Lisp object

-and not its C++ value like in MAKE-VARIANT."

- (let ((object (make-cxx-lisp-object value)))

- (unwind-protect

- (make-instance 'variant :args (list *cxx-lisp-object-metatype*

- object))

- (free-cxx-lisp-object object))))

-

-(defcfun qt-smoke-lisp-object-value :pointer

- (variant :pointer))

-

-(defun variant-boundp (variant)

- "Returns true when VARIANT is valid (has a value) and false otherwise."

- (cxx:is-valid variant))

-

-(defun from-variant (variant)

- "Returns the value of VARIANT."

- (ecase (cxx:user-type variant)

- (#.(value variant.+invalid+)

- (cerror "Return (VALUES)" "Type of variant ~A is invalid." variant)

- (values))

- (#.(value variant.+string+)

- (cxx:to-string variant))

- (#.(value variant.+string-list+)

- (cxx:to-string-list variant))

- (#.(value variant.+uint+)

- (cxx:to-uint variant))

- (#.(value variant.+int+)

- (cxx:to-int variant))

- (#.(value variant.+double+)

- (cxx:to-double variant))

- (#.(value variant.+char+)

- (cxx:to-char variant))

- (#.(value variant.+bool+)

- (cxx:to-bool variant))

- (#.*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 value ((variant variant))

- "Returns the value of VARIANT."

- (from-variant variant))

-

-(defmethod (setf value) (new-value (variant variant))

- (cxx:operator= variant (make-variant new-value))

- new-value)

--- old-qt.gui/test.lisp 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/test.lisp 2014-10-30 07:48:16.000000000 +0100

@@ -1,25 +1,9 @@

#|

exec -a "$0" sbcl --noinform --noprint --disable-debugger --load $0 --end-toplevel-options "$@"

-# do not use --script to allow loading mudballs with ${HOME}/.sbclrc

# Used for testing on darcs record.

|#

-

-(in-package :sysdef-user)

-

-(defun load-sysdef (pathname system)

- (load pathname)

- (setf (mb.sysdef::pathname-of (find-system system)) pathname))

-

-(defun load-sysdef-file (system-name)

- "Loads a mbd file in the current directory."

- (load-sysdef (make-pathname :defaults *default-pathname-defaults*

- :name (string-downcase system-name)

- :type "mbd")

- system-name))

-

-(load-sysdef-file :qt)

-(mb:clean :qt)

-(mb:test :qt)

+(asdf:operate 'asdf:load-op :cl-smoke.qt.gui)

+(asdf:operate 'asdf:test-op :cl-smoke.qt.gui)

(sb-ext:quit)

--- old-qt.gui/tests/test.lisp 2014-10-30 07:48:16.000000000 +0100

+++ new-qt.gui/tests/test.lisp 1970-01-01 01:00:00.000000000 +0100

@@ -1 +0,0 @@

-(mb:test :qt.tests)